A multi-agent system splits a job across several AI agents instead of running one. Usually a lead agent plans and delegates, workers handle pieces in parallel with their own context windows, and the lead assembles what comes back. The pattern is genuinely useful for a narrow set of problems and genuinely expensive for everything else, and telling the two apart is the whole discipline.
Updated September 2026. This area is moving quickly, so check the linked sources for the current position.
How the pattern works
The common shape is orchestrator and worker. Anthropic published an account of its research feature in June 2025: a lead agent analyses the query, forms a strategy and spawns subagents that explore different angles at once, each with a clean window, then compiles their findings. On its internal research evaluation, a lead model with subagents outperformed the same model working alone by 90.2 percent.
Other shapes exist. OpenAI’s guidance for building agents recommends exposing one agent as a callable tool for another, with memory shared by conversation, and is explicit that this should not be the default choice: reach for it when tasks do not overlap, instructions are too complex for one agent, or different steps need different models. Microsoft’s Agent Framework adds graph-based workflows so the execution path between agents is written down rather than improvised. Since January 2026 the Agent2Agent protocol has offered a standard way for agents from different vendors to talk, reaching version 1.0 with signed agent cards for verification.
What it costs
The bill is the first thing to understand. Anthropic reported that agents use around four times the tokens of an ordinary chat and multi-agent setups around fifteen times. Its later practitioner guidance puts the multiple at three to ten times a single agent for equivalent work, once context duplication and coordination messages are counted. Either way, you are paying several times over for parallelism, so the task has to be worth it.
Reliability costs too. Errors compound across steps, and a small misunderstanding early can reshape everything downstream. Evaluation is harder because there is no single correct path to compare against. Deployment is harder because updates have to land without disrupting processes already running.
5 times to avoid a multi-agent system
These come from published post-mortems rather than theory. Cognition’s engineering team argued in 2025 against the pattern for coding agents on the grounds that parallel workers make implicit decisions that never get reconciled, and in April 2026 still called unstructured swarms a distraction, while describing narrower patterns that do work.
- The work is mostly sequential. If step three needs the output of step two, parallelism buys you nothing and costs you handoffs.
- Every agent needs the same context. When workers must all know the same things, you are paying to copy the window repeatedly and still risking drift between copies.
- The output must be internally consistent. Writing code or a single document across parallel agents produces conflicting style and edge-case decisions that nobody resolves.
- You have split the work by task type, not by context. Dividing along job titles rather than information boundaries creates constant handoffs and burns tokens on coordination instead of progress.
- You cannot evaluate it yet. Without a test set and readable traces you will not be able to tell which agent caused a failure, and you will debug by guesswork.
Where a multi-agent system genuinely helps
- Wide, parallel search. Many independent lookups across more material than one window can hold, where results merge cleanly.
- Noise isolation. A sub-task that generates a lot of irrelevant output gets its own window and returns a short summary, keeping the main thread clean. This is a context engineering move as much as an architectural one.
- Specialisation. Focused toolsets avoid the confusion that sets in when one agent is handed too many similar tools.
- Independent verification. A reviewing agent that deliberately does not share the implementation history, and judges the result against stated criteria, is one of the few patterns that holds up consistently.
Why they fail when they fail
A Berkeley-led paper catalogued 14 distinct failure modes from traces across seven frameworks, sorted into three groups: specification problems, where instructions or architecture are wrong from the start; misalignment between agents, where communication breaks down; and weak verification, where nobody checks the output properly. The authors argue these are design faults requiring structural fixes, not things a better prompt will solve.
Security adds its own list. OWASP’s 2025 agentic risk categories include insecure communication between agents, cascading failures, and rogue agents that keep operating outside anyone’s view. More agents means more places for a hidden instruction to enter, which is why prompt injection scales badly here. Our overview of agentic AI covers the controls that apply across the board.
Coordination is the hidden work
The part teams underestimate is not spawning agents, it is everything around them: deciding what each worker is told, what it is allowed to return, how conflicting answers are resolved, and what happens when one worker stalls. Cognition’s stated principles are to share full traces rather than summaries and to track decisions so agents do not quietly contradict each other. Both are more engineering than they sound, and neither is supplied by a framework.
A sensible order of work
Start with one agent and good tools. Measure where it fails. Only split when you can name the specific bottleneck, usually a context window that overflows or a search that is too wide to do serially. Then add the smallest number of agents that removes it, and keep a verification step that did not participate in the work.
Common questions
What is a multi-agent system in AI? It is an arrangement where several AI agents divide a task, typically with a lead agent planning and delegating to workers that run in parallel with their own context, then combining the results.
Are multi-agent systems better than a single agent? Only for certain tasks. They help with wide parallel search and noise isolation, and hurt on sequential work, on tasks needing one consistent output, and wherever all agents would need the same context.
How much more do multi-agent systems cost? Anthropic has reported roughly fifteen times the tokens of an ordinary chat, and in later guidance three to ten times a single agent for equivalent work, before the extra engineering time.
Why do multi-agent systems fail? Research cataloguing 14 failure modes across seven frameworks points at flawed specifications, poor communication between agents and missing verification, rather than at model capability.
What protocol do agents use to talk to each other? Agent2Agent, now a Linux Foundation project, reached version 1.0 in January 2026 and added signed agent cards so an agent can verify who it is dealing with.
Sources and further reading
Where the figures and rules above come from, so you can check them:
- How we built our multi-agent research system (June 2025): Anthropic
- When to use multi-agent systems, and when not to: Anthropic
- Do not build multi-agents: Cognition
- Multi-agents: what is actually working (April 2026): Cognition
- Why Do Multi-Agent LLM Systems Fail? (MAST taxonomy): Cemri et al., arXiv
- A2A protocol reaches 150 organisations and version 1.0 (9 April 2026): Linux Foundation
- Agent Framework: agents, workflows and orchestration: Microsoft Learn
- Building agents, on agent-as-tool and when not to use several: OpenAI developer docs
Photo credits: Pope Field Air Traffic Control Tower (9206250542) by Tech. Sgt. Peter R. Miller / U.S. Air Force, CC BY 2.0, via Wikimedia Commons. Orchestra conductor in a chuj by Fotografiamerlin, CC BY-SA 4.0, via Wikimedia Commons.
Join the discussion