Multi-Agent Systems

The intuition

One expert with one desk can only hold so many open binders. Multi-agent systems hire specialists with separate desks: each gets a clean workspace, a focused job, and a thin report back to a lead — or control of the whole conversation is handed to the next specialist at the counter.

That buys desk space (context isolation), simultaneous research (parallelism), and tools matched to the job (specialization) — plus coordination meetings, conflicting decisions, and a bill that can jump to ~15× a simple chat.

Why it exists

A single agent hits hard limits that more prompt engineering cannot always fix.

1. Context windows fill. Deep research can burn 100k tokens of tool output. A subagent explores in a clean window and returns a 1–2k summary so the lead stays sharp.
2. Wall-clock breadth. Independent investigations in sequence are slow; parallel workers trade tokens for latency.
3. Tool and prompt interference. One mega-prompt with 80 tools selects poorly; focused agents with small toolsets raise reliability.
4. Coordination is a new failure class. Conflicting implicit decisions, multiplied cost, N transcripts to debug.

Until a measured bottleneck forces a split, prefer one agent, compaction, and better tools — including dynamic tool discovery so you never load 80 schemas at once. Cognition's restraint argument and Anthropic's research system are both right for different task shapes.

The core idea

A multi-agent system is several LLM agents — each with its own context window, prompt, and toolset — coordinated by code. Three architectures cover almost everything shipped:

• Supervisor / orchestrator-workers — a lead decomposes the task, spawns workers (often in parallel), and synthesizes results. Workers report to the supervisor, not each other.
• Handoffs — peer agents transfer control of the whole conversation (triage → billing). One agent is active at a time: dynamic routing, not parallelism. OpenAI's Agents SDK formalizes this; contrast agents-as-tools, where the manager keeps the final reply and specialists are bounded callable capabilities.
• Swarm / peer networks — agents messaging without a central coordinator. Rarely production-stable; coordination failures multiply with every edge.

Multi-agent purchases capacity and isolation, not a smarter model. Anthropic measured multi-agent research at ~15× chat tokens (single agents ~4×), with latency set by the slowest worker plus synthesis. Start single; go multi only when context, parallelism, or specialization is proven.

How it actually works

Supervisor. Spawning a worker is a tool call whose arguments are the task brief. The brief is the whole game: workers need an objective, output format, tool guidance, and task boundaries, or two workers silently duplicate or gap. Workers return condensed findings — not transcripts — as tool results; the supervisor synthesizes. Anthropic's pattern: stronger lead for decomposition and writing, cheaper workers for fan-out. On their internal research eval (mid-2025), multi-agent beat a single strong agent by 90.2%, and token usage alone explained ~80% of variance — multi-agent largely wins by spending more compute in parallel.

Handoff. A handoff is a tool call (transfer_to_billing) that swaps the active agent's system prompt and toolset, keeping all or a filtered view of history. In LangGraph this is a node returning Command(goto="billing_agent", update={...}). One context, sequential control — cheap, no parallel coordination risk. Use handoffs when the UX is one conversation routed to a specialist; use a supervisor when the work behind the scenes is breadth-first.

The context tradeoff. Parallel workers do not see each other's actions, and actions carry implicit decisions. Cognition's example: two subagents building one game produce a bird and a background with clashing styles — each locally correct, jointly incoherent. Harrison Chase's rule operationalizes the debate: parallelize reads, serialize writes. Conflicting reads waste tokens; conflicting writes produce incompatible artifacts. Anthropic's research system obeys this: parallel subagents search; one agent writes the final report. Claude Code takes the same restraint — investigation subagents in a clean window, no parallel code writes.

So split where context can truly be isolated: independent research paths, blackbox verification, components behind a clean interface. Sequential phases of the same feature as separate agents usually do not.

On the governed enterprise platform, multi-agent shows up sparingly: parallel retrieval workers over entitlements-filtered corpora, one synthesis agent writing the answer — not a swarm of writers editing policies concurrently.

The flows

A worked example

Deep research on internal docs for the governed enterprise platform:

"Summarize how change-management policy interacts with emergency production access across the last two years of runbooks and incidents."

Single-agent baseline: sequential search, context fills with raw chunks. Illustrative: ~4× chat tokens, long wall-clock.

Supervisor design (illustrative): strongest lead decomposes and writes; three cheaper workers search change-management runbooks, emergency-access incidents, and exception approvals — each returns a ≤2k summary plus doc ids. Brief with objectives, formats, and "do not write final prose." Parallel clean windows (wall-clock ≈ slowest worker). Up: ~6k of summaries, not 100k raw. Write: lead alone.

Anthropic-style economics (mid-2025, one research system): multi-agent can approach ~15× chat cost and still win when breadth is the bottleneck (90.2% gain; token usage ~80% of variance). Not universal constants — the mechanism (parallel token spend buys coverage) generalizes.

Production concerns

Cost and latency. ~15× chat means multi-agent only pays on high-value tasks. Use cheaper models for workers, a stronger model only for the lead and final write, prompt caching on shared prefixes, and strict summarization at boundaries. Claude's later guidance also cites multi-agent often running 3–10× a well-tuned single agent once you count duplicated context and coordination. Parallelism cuts wall-clock for breadth-first work, but the supervisor still waits for the slowest worker — set per-worker timeouts and degrade on partial results. Sync fan-out is what most systems ship first; async mailboxes unlock more parallelism but complicate state and errors. See cost and latency.

Coordination, laundering, and ops. Overlapping briefs, gaps, conflicting decisions, and stale shared state all come from bad information boundaries — log every brief and summary. A worker's confidently wrong summary becomes ground truth in the lead's context: validate at the boundary (schemas, citations, spot checks) before synthesis. A verification subagent (blackbox tests or policy checks with success criteria only) is one pattern that earns its isolation cost. One task spans N transcripts, so a run id across supervisor and workers is non-negotiable. Checkpoint supervisor state so a multi-minute run that dies at 90% does not re-run completed workers. See agent reliability, observability, orchestration, and reliability.

Common drill-downs

When do multiple agents beat one agent? When context, parallelism, or specialization is a real bottleneck. Otherwise a single agent with good tools and compaction wins on cost, latency, and coherence.

Supervisor vs handoff for a support bot? Handoff — sequential UX, one specialist at a time. Supervisor fits breadth-first work behind the scenes.

Steelman "Don't build multi-agents." Actions carry implicit decisions; parallel agents cannot see each other's; conflicts produce incoherent output. Share full context in one thread and compact when the window fills. Strongest for write-heavy work; bends for read-heavy parallel research.

Boundary contracts and model mix. Down: objective, schema, tools, scope limits. Up: condensed summary with citations/ids; artifacts by reference. Validate before the lead treats a summary as fact. Strongest model for supervisor and final write; cheaper models for high-volume workers.

Test yourself

Go deeper

• How we built our multi-agent research system — Anthropic — 90.2% gain, ~15× tokens, briefing the orchestrator (Jun 2025).
• Don't Build Multi-Agents — Cognition — share full traces; actions carry implicit decisions.
• How and when to build multi-agent systems — LangChain — parallelize reads, serialize writes; context engineering.
• When to use multi-agent systems — Claude blog — three criteria; context-centric decomposition (Jan 2026).
• Building more effective AI agents — Anthropic — Erik Schluntz on multi-agent patterns since the research essay.

Where this connects

• Agents vs workflows — same "simplest thing that works" test before multiplying agents.
• Orchestration — graph primitives (Send, Command, checkpoints) for supervisors and handoffs.
• Harness vs orchestration — why adding agents multiplies per-turn weaknesses.
• Agent reliability — coordination failures and error laundering across boundaries.
• Tokens and context — clean windows, summaries, and compaction are the real multi-agent design problem.