Agent Orchestration Patterns Explained: What Each One Costs and How Each One Fails

The main agent orchestration patterns are sequential, handoff, fan-out and fan-in, supervisor, graph, and human in the loop. Pick by task shape. Use a sequential pipeline or a graph when you can draw the steps in advance, a handoff when a specialist should take over the conversation, fan-out when the jobs are independent, a supervisor when the subtasks only appear as work proceeds, and a human gate before anything costly or irreversible.

Every pattern adds model calls, and every one has a signature way of failing. Anthropic reported in January 2026 that its multi-agent systems typically use 3 to 10 times more tokens than a single agent on the same task. So the cheapest pattern that fits is usually the right one, and one agent with tools is a valid answer.

The short version

Who this is for

You are building or buying an agent system and a vendor deck says "multi-agent" without saying which shape. You want to know what the shape costs and what breaks first, before you commit to a framework.

For the framework comparison, see our Microsoft Agent Framework vs Google ADK vs LangGraph post. For the cost side in depth, see agent orchestration cost control.

How we checked this

On November 12, 2026 we opened every vendor page in the sources list and read it directly. We ran none of these systems. Every cost multiplier below is a vendor's own measurement on its own workload, and we say so each time. The one number we computed is a labelled arithmetic example in the fan-out section, with assumed inputs.

Disclosure, Oakgen is our product. It is not an orchestration framework, and the post covers it in one short section near the end.

Start with one agent

OpenAI's Agents SDK guide says to start with one agent whenever you can, because splitting too early "creates more prompts, more traces, and more approval surfaces without necessarily making the workflow better".

Anthropic's Building effective agents post, published December 19, 2024, separates workflows (LLMs and tools orchestrated through predefined code paths) from agents (LLMs that direct their own process). Sequential, fan-out and graph are mostly workflows. Supervisor and handoff move decisions to a model.

Anthropic's October 22, 2026 article reports that a single agent with skills frequently outperformed subagent designs on quality, often at lower cost and latency, across several enterprise comparisons. One customer saw roughly 2 times faster runtime with a single loop. That is an Anthropic anecdote, not a benchmark. We cover the split decision in single agent vs multi-agent.

Pattern 1. Sequential (pipeline)

What it is. Step A feeds step B feeds step C. Anthropic calls it prompt chaining and says it fits tasks that decompose cleanly into fixed subtasks, trading latency for accuracy by making each call easier. Microsoft Agent Framework ships it as Sequential, where agents run one after another in a defined order.

What it costs. Roughly the sum of its steps. Each step usually reads the previous output, so input tokens grow along the chain. No vendor we read publishes a multiplier for it, so this is our inference, and it is the cheapest multi-step shape.

How it fails. There is no way back. Microsoft's handoff tour makes this concrete. In a Researcher, Writer, Editor pipeline the Writer cannot ask the Researcher for another source, and the Editor cannot stop to ask the user which English spelling to use. Anthropic adds that errors compound in agentic systems, so a bad early step shapes every later one.

What I would do. Add a programmatic gate between steps (length, schema, banned claims) before reaching for a second agent. If a step keeps needing to revisit an earlier one, you have outgrown the pipeline.

Pattern 2. Handoff

What it is. One agent passes control, and ownership, to another. OpenAI's guide says handoffs fit when "a specialist should take over the conversation for that branch of the work". Microsoft's version has you declare the agents and the directed edges, and the framework injects a handoff tool per edge. In Microsoft's words, routing decisions stay with the agents while topology and guardrails stay with the developer.

workflow = (
    HandoffBuilder(participants=[triage, billing, tech])
    .with_start_agent(triage)
    .add_handoff(triage, [billing, tech])
    .build()
)

What it costs. Close to a single agent, because only one agent speaks at a time. That is our inference, since no vendor publishes a figure. Two additions matter. Each edge is a tool the model must read and choose, and Microsoft says every agent sees the full shared transcript, so context grows with the conversation.

How it fails. Three ways, all documented. First, ping-pong. In Microsoft's Python builder, if you declare no handoffs, every agent can hand off to every other, which can invite loops. Second, vague routing. Microsoft notes the per-edge reason becomes the tool description the model reads, and OpenAI tells you to keep each handoff description short and concrete. Third, no clean end. The .NET builder has no termination callback and relies on terminal agents, while Python has with_termination_condition and an autonomous mode with per-agent turn limits.

What I would do. Declare edges explicitly, keep the cast small, and write each edge reason as a tool description, because it is one. Anthropic's October guidance reserves a full handoff for subagents that must talk to the user directly.

Pattern 3. Fan-out and fan-in

What it is. Independent jobs run at the same time and a merge step joins the results. Microsoft's Build 2026 post lists a BackgroundAgentsProvider that delegates subtasks to child agents running in parallel for fan-out orchestration, and Microsoft's Concurrent orchestration runs agents on the same task, with a default aggregator that returns one message per participant. We found no dedicated docs page for the provider, only that announcement line, so check the samples before relying on it. In ADK 2.0 a nested tuple starts branches together and a JoinNode waits for all of them.

edges=[(START, (fetch_order, fetch_payment, fetch_history), join_case)]

That line comes from Google's September 29, 2026 post. Its rule is that dependencies, not the order in your prompt, decide the edges.

What it costs. This is where the bill moves. Anthropic's January 2026 article says multi-agent implementations typically use 3 to 10 times more tokens than single-agent ones. Its June 2025 research-system post says agents used about 4 times more tokens than chat, and multi-agent systems about 15 times. In that same post a lead Opus 4 with Sonnet 4 subagents beat a single Opus 4 by 90.2% on Anthropic's internal research eval, and parallel calls cut research time by up to 90%. All of that is Anthropic's data on its research workload.

Here is arithmetic you can check, with assumed numbers. Take a 4,000-token brief and three parallel workers, ignoring tool output and caching.

That is 5.6 times the single read on the brief alone, which sits inside Anthropic's 3 to 10 times range. Anthropic's January article says the main benefit of parallelism is thoroughness, not speed. See cost control for caps and caching.

How it fails. Cognition's June 12, 2025 post gives the classic case. Asked for a Flappy Bird clone, one subagent builds a Super Mario style background and another builds an unrelated bird. Each acted on a different reading of the task. Its principle is that actions carry implicit decisions, and conflicting decisions give bad results. Anthropic's research post lists duplicated searches across subagents and early versions that spawned 50 subagents for simple queries. And the fan-in waits for the slowest branch.

What I would do. Fan out only over facets that share no context, like regions, sources or variants. Give each worker an objective, an output format and boundaries, and cap the worker count in code.

Pattern 4. Supervisor (orchestrator-worker)

What it is. A lead agent decides the subtasks at run time, delegates, and synthesizes. Anthropic's post says it differs from parallelization because the subtasks are not predefined. LangGraph's docs describe the same shape and provide a Send API to create workers dynamically, each with its own state, writing to a shared key. OpenAI calls the manager variant agents as tools. Microsoft's Magentic is the heavy version, a manager that plans, tracks a progress ledger and replans.

What it costs. Everything in fan-out, plus the supervisor's planning and synthesis turns. Microsoft's Magentic builder exposes limits for coordination rounds, consecutive stalls and plan resets (its sample sets 10, 3 and 2), which is a hint about what runs away without them.

How it fails. Anthropic's April 10, 2026 article says the orchestrator becomes an information bottleneck. A finding from one subagent that matters to another must travel through the lead, and after several hops details get lost or summarized away. Sequential execution also means you pay multi-agent token costs without the speed benefit. Microsoft's own Magentic page warns it is untested how well the pattern performs outside the original Magentic-One design.

What I would do. Use a supervisor only when you cannot list the subtasks, like research across unknown sources. Put scaling rules in its prompt, since Anthropic found agents misjudge effort on their own.

Pattern 5. Graph (state machine)

What it is. You declare nodes and edges, with routes, joins and loops. ADK 2.0 moved from a hierarchical agent executor to a graph-based execution engine, with Python 2.0 generally available May 19, 2026, Go on June 30 and TypeScript on August 21. A node can be a function, an agent, a tool or another workflow. LangGraph and Microsoft's workflow builder follow the same idea.

Google's test is whether you can draw the possible workflow before the input arrives, including branches and loops. You need not predict each request's path.

What it costs. Often less than the alternatives, because code nodes make no model call. Google's refund example applies its policy in a pure function with zero LLM calls, and uses a model only where meaning needs interpreting. A deterministic router is also testable without calling a model.

How it fails. ADK validates the graph at construction and rejects unconditional cycles, so a loop needs a conditional back-edge and an iteration limit. It also rejects schema mismatches between connected nodes. The bigger risk is fit. A static graph over an open-ended task either grows branch after branch or forces the wrong path, and ADK's own docs offer dynamic workflows for that. ADK 2.0 migration notes add an error-handling trap. A broad except Exception inside a tool hides failures from the framework and disables its automatic retries.

What I would do. Model the stable skeleton as a graph and put a model only where judgment is needed. A generator-verifier loop fits inside it, but Anthropic warns that a verifier with no explicit criteria will rubber-stamp the output.

Pattern 6. Human in the loop

What it is. The run pauses, a person decides, and it resumes. LangGraph's interrupt() saves state through a checkpointer and waits indefinitely for a resume with the same thread ID. ADK uses a RequestInput event. Microsoft's Magentic can require sign-off on the plan, which is on by default in .NET and off by default in Python, and its Python sequential builder can pause between steps.

What it costs. Nothing in tokens while waiting, but real wall-clock delay, plus storage for durable state. LangGraph's docs say to use a persistent, database-backed checkpointer in production.

How it fails. The sharpest edge is replay. LangGraph's docs say the node restarts from its beginning on resume, so code before interrupt() runs again. Side effects placed before it should be idempotent, or moved after it or into a separate node, or you risk duplicate records. Wrapping interrupt() in a bare try/except swallows the pause. ADK has the equivalent, catching BaseException traps NodeInterruptedError and breaks the pause. The human failure is approval fatigue. Our human approval framework covers what to gate and what to batch.

What I would do. Gate actions that spend money, publish, or touch rights and likeness, and show the reviewer the exact payload.

The pattern-choice matrix

This is the asset to bookmark. Find your task shape in the left column.

The failure-mode checklist

The paper Why Do Multi-Agent LLM Systems Fail? (Cemri and colleagues, arXiv, last revised October 26, 2025) annotated 1,600 or more traces across seven frameworks and found 14 failure modes in three groups, system design, inter-agent misalignment and task verification. This checklist is ours, organized the same way and filled from the vendor pages above. Run it before you ship.

System design

• Could one agent with tools do this job? If you have not tested that, stop here.
• Is each agent's job one sentence, with its own tools or policy? OpenAI says split only when the contract changes.
• Is the graph or handoff topology declared in code, not left to a default full mesh?

Between agents

• Does every delegated task carry an objective, an output format, tool guidance and boundaries? Vague tasks produced duplicated work in Anthropic's tests.
• Do workers share context they actually need, or do their assumptions conflict, as in Cognition's example?
• Are results passed as compact references, not copied through the lead? Anthropic suggests writing large outputs to a filesystem.
• Does fan-in handle a branch that fails or times out?

Verification and stopping

• Does every loop have an iteration cap and a fallback, such as escalating to a human?
• Does the verifier have explicit criteria?
• Is there a hard cap on agent count, rounds and spend, set in code and not in the prompt?
• Do you have an end-to-end task eval, not only per-agent checks? Anthropic recommends even 10 golden examples as a start. See agent observability and evals basics.

Resume and humans

• Are side effects before a pause idempotent, or moved after it?
• Can the run resume from a checkpoint after a crash or a three-day wait?
• Does the reviewer see the exact action and cost, and is there a log of who approved it?

How a creative team would apply this

Take a campaign brief. A sequential pipeline drafts the angle, then the script, with a banned-claims check between them. A fan-out generates three concept variants from the approved script, since variants share no context. A human gate approves one variant and its cost. Only then does a tool-calling step start the paid generation.

This is the shape Oakgen's own MCP server supports for the last step. Its tool reference lists start_generation with a maxCredits ceiling and an idempotency key, which protect against surprise prices and double charges. That is our product and we are describing one tool, not a protocol feature. Our agentic creative pipelines post shows a worked version.

Decision framework

1. Try one agent first. Add tools, skills and a clear prompt. Measure.
2. If steps are known, write a workflow. Sequential or a graph, with code where code is enough.
3. If facets are independent, fan out. Cap the count and budget 3 to 10 times the tokens.
4. If subtasks are unknowable, use a supervisor. Limit rounds and replans.
5. If a specialist must talk to the user, hand off. Otherwise call it as a tool.
6. Gate what is costly, public or irreversible with a human. Make resume safe.

Sub-agent fan-out is also where users report surprise bills. See our Fable 5.2 community reactions and cost per task posts. For tool wiring, see MCP vs A2A, Agent Skills vs MCP and code execution with MCP.

What I would do

I would start as one agent with tools and a short eval set, add a graph skeleton the first time I could draw the process, and fan out only over independent facets, capped in code. I would keep a supervisor for research-shaped work, and put a human gate in front of spend and publishing from day one, because it is cheap to add and painful to retrofit.

Common mistakes

1. Splitting by job title. A planner, writer and reviewer for one feature recreate your org chart. Anthropic recommends splitting by context boundary.
2. Fan-out without a cap. Anthropic's early agents spawned 50 subagents for simple queries.
3. A verifier with no criteria, or a loop with no exit.
4. Side effects before a pause, or exceptions swallowed in tools. Resume replays the first, and the second blocks retries.
5. Trusting vendor multipliers. The 3 to 10 times and 15 times figures are Anthropic's, on its workloads.

Frequently asked questions

What are the main agent orchestration patterns?

Six cover most systems. Sequential (a pipeline of fixed steps), handoff (one agent passes control and ownership to another), fan-out and fan-in (independent jobs run in parallel and are merged), supervisor or orchestrator-worker (a lead agent plans and delegates), graph or state machine (nodes and edges you declare, with routes and loops), and human in the loop (the run pauses for a person). Anthropic's Building effective agents post names five workflow patterns, and Microsoft Agent Framework ships Sequential, Concurrent, Handoff, Group Chat and Magentic. The names differ between vendors, the shapes do not.

What is the difference between a handoff and agents as tools?

In a handoff control moves to the specialist, which then owns the next response. With agents as tools, a manager agent stays in control, calls the specialist like a function, and keeps ownership of the final answer. OpenAI's Agents SDK docs describe exactly this split. Anthropic's October 2026 guidance adds that a full handoff is only worth it when the subagent has to talk to the user directly.

How much more do multi-agent systems cost?

Anthropic's January 2026 article says its multi-agent implementations typically use 3 to 10 times more tokens than single-agent approaches for equivalent tasks. Its June 2025 research-system post says agents used about 4 times more tokens than chat and multi-agent systems about 15 times more. Both are Anthropic's own measurements on its own workloads, so test your own task before budgeting from them.

When should I use a graph instead of an agent that decides the steps?

Use a graph when you can draw the possible workflow before the input arrives, including branches and loops. Google's ADK team puts it that way in its September 2026 post. Rules in code are cheaper, testable and repeatable, and a model node is only needed where meaning has to be interpreted. If the next step depends on what earlier results reveal, a lead agent or a dynamic node fits better.

Why do human-in-the-loop pauses cause duplicate side effects?

In LangGraph, resuming after an interrupt restarts the node from its beginning, so any code before the interrupt() call runs again. LangGraph's docs say side effects placed before an interrupt should be idempotent, or moved after the interrupt or into a separate node. ADK 2.0 has a related trap, a broad exception handler inside a tool can mask failures from the framework and block its retries and pauses.

Do I need multiple agents at all?

Often not. OpenAI's orchestration guide says to start with one agent whenever you can and add specialists only when they improve capability isolation, policy isolation, prompt clarity or trace legibility. Anthropic's October 2026 article reports that a single agent with skills often matched or beat subagent designs in its enterprise comparisons, and names three cases where subagents still pay off (context bloat, parallel work, tool selection or conflicting instructions).

Is Oakgen a multi-agent orchestration framework?

No. Oakgen is an AI creative studio for image, video and audio, with an Agent Chat and an MCP server. It is not a framework like Microsoft Agent Framework, ADK or LangGraph. Oakgen is our product, and we mention it only where a creative team would apply these patterns, for example quoting a price and setting a credit ceiling before a generation starts.

Sources

1. Microsoft Agent Framework team, Microsoft Agent Framework at BUILD 2026, Jun 3 2026 (read 2026-11-12)
2. Microsoft Agent Framework team, A Tour of the Handoff Orchestration Pattern, May 8 2026 (read 2026-11-12)
3. Microsoft Learn, Workflow orchestrations in Agent Framework, updated Aug 25 2026 (read 2026-11-12)
4. Microsoft Learn, Magentic orchestration, updated Sep 21 2026 (read 2026-11-12)
5. Microsoft Learn, Concurrent orchestration, updated Oct 22 2026 (read 2026-11-12)
6. Google ADK docs, Welcome to ADK 2.0 (read 2026-11-12)
7. Google ADK docs, Graph-based agent workflows (read 2026-11-12)
8. Google Cloud Blog, Graph Workflows in ADK: Everything You Need to Know, Sep 29 2026 (read 2026-11-12)
9. LangChain docs, LangGraph workflows and agents (read 2026-11-12)
10. LangChain docs, LangGraph interrupts (read 2026-11-12)
11. OpenAI, Orchestration and handoffs, Agents SDK guide (read 2026-11-12)
12. OpenAI, A practical guide to building agents, Apr 7 2025 (read 2026-11-12)
13. Anthropic, Building effective agents, Dec 19 2024 (read 2026-11-12)
14. Anthropic, How we built our multi-agent research system, Jun 13 2025 (read 2026-11-12)
15. Anthropic, Building multi-agent systems: when and how to use them, Jan 23 2026 (read 2026-11-12)
16. Anthropic, Multi-agent coordination patterns: five approaches and when to use them, Apr 10 2026 (read 2026-11-12)
17. Anthropic, Building agents: when to fold subagents into your main agent loop, Oct 22 2026 (read 2026-11-12)
18. Cognition, Don't Build Multi-Agents, Jun 12 2025 (read 2026-11-12)
19. Cemri et al., Why Do Multi-Agent LLM Systems Fail? arXiv 2503.13657, v3 Oct 26 2025 (read 2026-11-12)