Planning and collaboration

For a dinner, shopping produces what cooking needs, while setting the table can happen independently. Decomposition exposes those smaller jobs and their dependencies.

Give each subtask a useful output and keep its relationship to the larger goal visible. Otherwise, an agent can complete every item on its list and still leave part of the actual job undone.

A code-change plan might identify the files to inspect, the edit to make, and the checks to run. It provides a starting sequence that can be revised when investigation reveals something new. Plan enough to guide the next work, with room to respond to what the tools find.

ReAct interleaves reasoning, action, and observation. An action gathers information that helps the model decide what to try next, instead of planning every move without feedback. The original method explicitly combines reasoning text with actions. It is one approach to structuring an agent, rather than a label for every system that uses a loop.

Planning and execution can be separate stages. A planner proposes the work, an executor carries it out, and progress or problems feed back into revisions. Those stages may use different components or models. The practical question is how the executor reports a surprise and who is responsible for changing the remaining steps.

A model can review an attempt and propose a correction before trying again. Reflection is useful when the review identifies a specific problem the next attempt can address. Give it evidence such as a failed test or a mismatch with the requirement. The critique itself can be mistaken, so assess whether the revision actually improves the result.

Define completion before the agent starts, and give the runtime clear limits on continued execution. A successful check, deadline, step limit, cancellation, or unrecoverable error can end a run. The final status should say which occurred. Reaching the time limit and completing the task are different outcomes that deserve different messages.

Multiple agents introduce a coordination problem as well as extra capacity. Someone must assign work, supply context, track dependencies, and combine the results. Separate agents can be useful when tasks benefit from distinct expertise or independent investigation. That benefit has to justify the communication overhead and the work of reconciling their outputs.

A supervisor agent decides what to assign and what to do with the responses. It can request more work, compare findings, or assemble a final result. Give it explicit review criteria and access to the relevant evidence. The supervisor is another model-driven participant, so the title alone adds no assurance that its judgment is sound.

A subagent takes responsibility for a bounded part of another agent's task. It may receive specialized instructions, tools, or its own context. Specify what information travels with the assignment and what should come back. The parent can then evaluate the result and use it in the broader workflow.

“Inspect this” leaves quite a lot for the recipient to guess. A useful delegation includes the goal, relevant context, constraints, and expected output. It also identifies what counts as finished. The caller remains responsible for integrating the returned work, including resolving gaps or contradictions with other parts of the task.

A handoff transfers responsibility for continuing the work. In an agent application, it may move a conversation and selected state to a specialist. Decide what control transfers, what context is carried, and where any later response should go. Delegation usually returns a subtask result to a caller; a handoff emphasizes who takes over next.

Three independent searches can run during the same period instead of waiting in a queue behind one another. That may shorten the task, even when total resource usage stays the same or rises.

Dependencies decide what must wait. Shared files and records also need coordination so concurrent workers do not overwrite one another’s changes.