What are the main multiagent design patterns?

The main multiagent design patterns are the sequential pipeline, concurrent fan out and fan in, orchestrator worker (also called the supervisor pattern), handoff routing, group chat with a manager, hierarchical supervisors, and the evaluator optimizer loop. A single agent with tools is the baseline every one of them should beat. They differ mainly in who decides the next step: fixed code, a central agent, or whichever agent currently holds the conversation.

Which pattern dynamically transfers control between agents based on context?

The handoff pattern. The active agent passes control of the conversation to a specialist when the context calls for it, and the specialist continues until it finishes or hands off again. Microsoft Agent Framework describes handoff as agents transferring control to each other based on context, and the OpenAI Agents SDK exposes each handoff to the model as a tool. Sequential and concurrent patterns follow a fixed plan instead.

What is the difference between the supervisor pattern and the handoff pattern?

In the supervisor pattern, one central agent delegates subtasks to workers, receives their results, and owns the final answer. In the handoff pattern, control moves to the specialist, which then talks to the user directly, so no single agent owns the whole run. Pick a supervisor when you need one accountable controller or parallel subtasks. Pick handoffs when the right specialist only becomes clear during the conversation.

When should you use a multiagent system instead of a single agent?

Use a system of agents when a single agent measurably fails: it has too many tools to choose between reliably, the task spans domains that need separate instructions, independent subtasks could run in parallel to cut latency, or the output needs a separate evaluator. Anthropic, Microsoft, and LangChain all advise starting with a single agent and adding agents only when simpler options fall short.

What is the difference between sequential and concurrent agents?

Sequential agents run one after another, and each stage uses the previous stage's output, so total latency is the sum of every stage. Concurrent agents run at the same time on the same input, and an aggregator merges their outputs, so latency stays close to the slowest branch while cost multiplies by the number of branches. Use sequential for dependent steps and concurrent for independent ones.

What is group chat orchestration and when does it fit?

Group chat orchestration puts several agents in one shared conversation thread, and a manager decides who speaks next and when the discussion ends. It fits decisions that benefit from debate, review, or consensus between distinct viewpoints. It costs more than most patterns because every turn rereads the growing transcript. Microsoft's architecture guidance suggests limiting a group chat to three or fewer agents.

How is the recommendation scored, and can I share it?

Each answer adds or subtracts points for each of the eight patterns, the single agent starts with a 2 point simplicity bonus, and the highest total wins, with ties going to the simpler pattern. The scoring panel shows every weight for your current answers. Your answers are encoded in the page URL, so copying the link shares the exact scenario. Nothing is sent to a server.

Multi-Agent Pattern Chooser: Pick an Orchestration Pattern

Question and your answer	Single agent	Sequential	Concurrent	Supervisor	Handoff	Group chat	Hierarchical	Evaluator loop
Simplicity baseline	2	0	0	0	0	0	0	0
Do you know the subtasks before the run starts? Partly, some steps depend on the input	+1	0	0	+2	+1	0	0	+1
Do the steps run in a fixed order? Dynamic, the next step depends on results	+1	-3	0	+2	+2	+1	+1	0
Can subtasks run independently at the same time? No, each step needs the previous result	+1	+2	-3	0	+1	0	0	+1
Do you need one accountable controller that owns the final answer? No, ownership can move between agents	0	+1	+1	-1	+2	0	0	0
Should control pass to a specialist based on what the conversation reveals? Yes, that is the core of the flow	-1	-2	-2	0	+4	0	0	0
Do agents need to critique or refine each other's output? No, one pass per step is enough	0	0	0	0	0	-3	0	-2
What is your latency and cost budget per request? Moderate, seconds are fine	0	+1	+1	+1	+1	0	0	0
Where do humans need to approve work? Between specific steps	0	+2	-1	+1	+1	-1	0	0
How many distinct tools or skill domains does the system need? 10 to 30 tools across 2 to 4 domains	-1	+1	+1	+2	+2	0	0	0
Total	3	2	-3	7	14	-3	1	0

Pattern	Who controls the flow	Best when	Main risk
Single agent with tools	One loop owns everything	One domain, fewer than about ten tools, tight budget	Tool overload and context bloat as scope grows
Sequential pipeline	The pipeline code, not a model	Known stages with clear linear dependencies	Errors in an early stage flow into every later stage
Concurrent fan out and fan in	A fixed dispatcher and an aggregator	Independent subtasks, or several takes on one task	Conflicting outputs that the aggregator cannot reconcile
Orchestrator worker (supervisor)	The orchestrator owns the plan and the final answer	Subtasks are unknown until the input arrives	The orchestrator becomes a bottleneck and a single point of failure
Handoff routerYour pick	Whichever agent currently holds the conversation	The right specialist only becomes clear during the conversation	Agents bounce the task back and forth in a loop
Group chat with a manager	A chat manager selects the next speaker	The output needs debate, review, or consensus from distinct viewpoints	Long, circular discussion that burns tokens without converging
Hierarchical supervisors	A tree of supervisors, each owning its team	Many tools across several domains that one supervisor cannot hold	Coordination overhead and errors that compound across levels
Evaluator optimizer loop	The loop condition and the evaluator's criteria	Clear evaluation criteria and measurable value from iteration	Endless revision when the criteria are vague

About this tool

What this multiagent pattern chooser answers

The Multi-Agent Pattern Chooser scores eight multiagent design patterns, from a single agent with tools to hierarchical supervisors, against nine questions about your workflow and returns the best fit plus a runner up. Use it before writing orchestration code to decide between the supervisor pattern, the handoff pattern, sequential vs concurrent agents, group chat orchestration, or an evaluator loop, with the failure modes and cost of each in view.

Most teams copy a framework tutorial, which shows what the framework does best rather than what the workflow needs. This chooser starts from workflow shape instead: known or unknown subtasks, parallel or dependent steps, who owns the answer, and how much latency each request can absorb. Once the pattern is settled, the AI Agent Framework Chooser picks the library to build it with.

How to use it

Answer the nine questions in order. The first three describe the work: whether you can list subtasks before the run, whether the steps always run in the same order, and whether subtasks can run at the same time.

The next three describe control: whether one component must own the final answer, whether control should move to a specialist as the conversation unfolds, and whether agents must critique each other. The last three are constraints: latency and cost budget, where humans approve work, and how many tools the system needs.

The result updates as you click. Read the runner up as seriously as the winner, and copy the share link to send the exact scenario to a reviewer.

How the recommendation is computed

Every answer carries a weight for each pattern, from minus 3 to plus 6. A known, fixed sequence pushes toward a sequential pipeline. Independent subtasks push toward concurrent fan out and fan in. Subtasks that only appear at run time push toward the orchestrator worker, the supervisor pattern. Context driven transfers push toward handoffs, and explicit pass or fail criteria push toward an evaluator optimizer loop.

The single agent starts 2 points ahead. That prior encodes advice from Anthropic, which recommends the simplest solution that works, and from Microsoft's agent design pattern guidance, which calls a single agent with tools the right default for many enterprise cases. Ties go to the simpler pattern.

The eight orchestration patterns, defined

Single agent with tools: One model runs a loop, picks tools, reads the results, and decides when it is done. No second agent exists.
Sequential pipeline: Agents run one after another in a fixed order, and each stage consumes the output of the previous stage.
Concurrent fan out and fan in: Several agents work on the same input at the same time, then an aggregator merges, votes on, or ranks their outputs.
Orchestrator worker (supervisor): A central agent breaks the task down at run time, delegates subtasks to worker agents, and synthesises their results into one answer.
Handoff router: The active agent transfers control of the conversation to a specialist based on context, and the specialist continues until it finishes or hands off again.
Group chat with a manager: Several agents share one conversation thread, and a manager decides who speaks next and when the discussion has reached a result.
Hierarchical supervisors: A top supervisor delegates to team supervisors, each running its own workers: the supervisor pattern nested one or more levels deep.
Evaluator optimizer loop: One agent generates an output, a second evaluates it against explicit criteria and returns feedback, and the loop repeats until it passes or hits a limit.

Where the answer usually breaks down

The chooser cannot see your data. Two workflows with identical answers can still differ in how noisy their tool outputs are and how long their contexts grow. Those details decide whether a supervisor keeps its plan coherent over twenty steps or loses it after five.

Handoffs fail most often when no agent owns an edge case, so two specialists transfer the task back and forth. Group chat fails when nothing says the discussion is finished. Hierarchical supervisors fail when instructions degrade at each level. Build an eval that catches these loops before you add a second agent.

When the answer is real and when it is not

The result is most reliable for workflows you have already run by hand or in a prototype, because you can answer the decomposition and parallelism questions from evidence. Support triage, document processing pipelines, research fan out, and code review loops all fit well.

It is weaker for open research problems where nobody can yet name the subtasks, and for systems that nest patterns: a handoff router at the front, a supervisor inside one specialist, an evaluator loop on its output. Run the chooser once per layer instead of once for the whole system.

How this tool differs from vendor guides

Vendor docs describe the patterns their own framework ships. The OpenAI Agents SDK represents handoffs to the model as tools named transfer_to_<agent_name>. Microsoft Agent Framework ships sequential, concurrent, handoff, group chat, and Magentic orchestrations. LangChain documents subagents, handoffs, skills, and routers, and Building effective agents describes prompt chaining, parallelization, orchestrator workers, and evaluator optimizer workflows.

This chooser maps those names onto one vocabulary and shows its weights so you can disagree with them. For patterns that hold up under load, read the four multiagent design patterns that work in production and LangGraph in production.

Pressure test the pattern before you build it

Bring the recommended topology, your traces, and the runner up to a review, and leave with an orchestration design, an eval plan, and the failure modes to watch.

Book an architecture review

Frequently asked questions

What are the main multiagent design patterns?: The main multiagent design patterns are the sequential pipeline, concurrent fan out and fan in, orchestrator worker (also called the supervisor pattern), handoff routing, group chat with a manager, hierarchical supervisors, and the evaluator optimizer loop. A single agent with tools is the baseline every one of them should beat. They differ mainly in who decides the next step: fixed code, a central agent, or whichever agent currently holds the conversation.
Which pattern dynamically transfers control between agents based on context?: The handoff pattern. The active agent passes control of the conversation to a specialist when the context calls for it, and the specialist continues until it finishes or hands off again. Microsoft Agent Framework describes handoff as agents transferring control to each other based on context, and the OpenAI Agents SDK exposes each handoff to the model as a tool. Sequential and concurrent patterns follow a fixed plan instead.
What is the difference between the supervisor pattern and the handoff pattern?: In the supervisor pattern, one central agent delegates subtasks to workers, receives their results, and owns the final answer. In the handoff pattern, control moves to the specialist, which then talks to the user directly, so no single agent owns the whole run. Pick a supervisor when you need one accountable controller or parallel subtasks. Pick handoffs when the right specialist only becomes clear during the conversation.
When should you use a multiagent system instead of a single agent?: Use a system of agents when a single agent measurably fails: it has too many tools to choose between reliably, the task spans domains that need separate instructions, independent subtasks could run in parallel to cut latency, or the output needs a separate evaluator. Anthropic, Microsoft, and LangChain all advise starting with a single agent and adding agents only when simpler options fall short.
What is the difference between sequential and concurrent agents?: Sequential agents run one after another, and each stage uses the previous stage's output, so total latency is the sum of every stage. Concurrent agents run at the same time on the same input, and an aggregator merges their outputs, so latency stays close to the slowest branch while cost multiplies by the number of branches. Use sequential for dependent steps and concurrent for independent ones.
What is group chat orchestration and when does it fit?: Group chat orchestration puts several agents in one shared conversation thread, and a manager decides who speaks next and when the discussion ends. It fits decisions that benefit from debate, review, or consensus between distinct viewpoints. It costs more than most patterns because every turn rereads the growing transcript. Microsoft's architecture guidance suggests limiting a group chat to three or fewer agents.
How is the recommendation scored, and can I share it?: Each answer adds or subtracts points for each of the eight patterns, the single agent starts with a 2 point simplicity bonus, and the highest total wins, with ties going to the simpler pattern. The scoring panel shows every weight for your current answers. Your answers are encoded in the page URL, so copying the link shares the exact scenario. Nothing is sent to a server.

Multi-Agent Pattern Chooser

All eight patterns compared