Skip to content
sync ai agents

What is the supervisor agent pattern?

Updated November 2026

The supervisor agent pattern gives one lead agent responsibility for delegating bounded tasks to specialists and combining their results. It is the central orchestrator pattern used elsewhere on this site, not a sixth coordination pattern. Workers normally return results to the supervisor rather than taking ownership of the whole conversation.

What does the supervisor own?

The supervisor owns the task plan, selection of specialists, integration of results, and decision to continue or stop. The application should own hard limits and permission enforcement. Keeping those responsibilities separate prevents a model-generated plan from changing access rights or treating a requested action as already approved. A supervisor can propose an operation without being authorized to execute it.

In the official LangChain multi-agent documentation, the subagent approach uses centralized coordination, with a main agent invoking specialists. That is one implementation of this architectural idea, not a requirement to use a particular framework. The essential property is that delegated results return to a lead decision point before the overall response is completed.

How does delegation differ from a handoff?

With delegation, the supervisor remains accountable while a worker completes a bounded assignment. With a handoff, another agent becomes the active owner. This affects who answers the user, receives follow-up information, and resolves blocked work. Naming both operations as simply calling an agent hides an important lifecycle distinction.

The supervisor is also more than a one-time router. A router can classify an incoming request and select a destination once. A supervisor evaluates intermediate results and may revise the plan. Use a router when routing is all you need; repeated model-based planning adds overhead and more opportunities for inconsistent decisions.

MechanismOwnership after dispatchExpected next step
Supervisor delegationSupervisor retains overall ownership.Worker returns evidence or an artifact for validation.
HandoffRecipient becomes active owner after acceptance.Recipient continues the task or user interaction.
One-time routingDestination owns execution under application rules.Selected workflow runs without ongoing planning by the router.
Fixed workflow stepWorkflow state defines ownership.Predetermined transition runs when conditions are met.

What should a specialist receive and return?

A useful delegation includes an objective, relevant inputs, constraints, permitted tools, required output fields, and a stopping condition. For a procurement review, a pricing worker might receive line items and contract references but not unrelated employee records. A security worker might receive the proposed integration and data categories, with permission to read evidence but not change production configuration.

Require each worker to return findings, evidence references, uncertainties, and execution status. Keep operational errors separate from substantive conclusions. A missing contract is not proof that a discount is unavailable. The supervisor needs to know whether the worker found negative evidence, failed to retrieve a document, or lacked permission to inspect it.

Preserve context that affects interpretation. If the request excludes a deployment region, include that restriction in every relevant assignment. If the supervisor summarizes a worker result, retain links to its source evidence and any caveats. Isolation keeps contexts smaller, but it also makes the supervisor responsible for reconnecting information workers could not see.

How should the supervisor combine results?

Validate the result contract before synthesizing an answer. Check that required fields exist, evidence refers to the requested case, and the result was produced against the current input revision. Then check domain-specific constraints. A well-formed pricing recommendation can still violate the spending limit, and a confident security conclusion can still rely on an outdated architecture diagram.

Use explicit reconciliation rules for incompatible findings. The pricing worker may favor a vendor while security identifies an unresolved access requirement. The supervisor should present the conflict or request targeted follow-up, not turn incompatible statements into a vague compromise. Treat worker content as task data: it must not redefine system instructions, approval requirements, or available permissions.

What happens when workers or the supervisor fail?

Give each delegation an attempt identifier and a deadline. On a worker timeout, determine whether any side effect occurred before deciding to retry. Read-only analysis is usually easier to repeat than account creation or message delivery. For consequential writes, use operation identity and destination checks where available so a lost response does not become a duplicated action.

Checkpoint accepted results and plan state outside the supervisor conversation. If the supervisor process restarts, recovery should reconstruct completed work and outstanding approvals without asking every worker to repeat its task. Ignore or separately review late results from canceled attempts. A worker that eventually answers may still be using a superseded input revision.

Bound the number of delegations, follow-up rounds, and total execution time. Repeatedly asking specialists to reconsider without adding evidence can create a loop. Stop with a recorded unresolved question, partial result, or escalation. Keep one authoritative owner for each pending task so a recovery process and a resumed supervisor do not both dispatch the same work.

When should you choose a different pattern?

Use supervision when tasks decompose into bounded assignments and one decision point can evaluate their outputs. It is less suitable when every small interaction must pass through a lead agent that lacks the workers' detailed context. The controller can become both an execution bottleneck and an information bottleneck, especially when many concurrent branches require repeated synthesis.

Choose handoffs for sustained specialist ownership, event-driven coordination for loosely coupled reactions, shared memory for a common evolving record, or a collaboration layer for addressed discussion involving people. None automatically replaces the others. A supervisor can read shared records or request human review, but the design still needs clear rules for who can change state and when work is complete.

What else should you know?

  • Is a supervisor the same as the central orchestrator?

    On this site, yes: a supervisor agent is the agent-led form of the central orchestrator pattern. A central orchestrator can also use fixed code rather than model-based planning.

  • Can workers call other workers?

    They can, but nested delegation needs explicit depth limits, permissions, and cancellation behavior. Otherwise the supervisor may lose visibility into how much work a seemingly small assignment creates.

  • Can specialists run in parallel?

    Yes, when their inputs are ready and their writes do not conflict. Define the join condition and deadline before launch, including whether incomplete branches block the final answer.

  • Should the supervisor approve its own external actions?

    Not when policy requires independent approval. Enforce that requirement outside the model, bind approval to a specific proposal version, and recheck authorization immediately before execution.

  • How can you test a supervisor beyond answer quality?

    Supply malformed worker results, contradictory evidence, timeouts, and stale revisions. Check routing, permissions, bounded retries, conflict handling, and whether the supervisor reaches an honest terminal state instead of claiming success.

Where can you go deeper?