
Ten Agents, One Task: What Multi-Agent Orchestration Is Actually Good For
Multi-agent systems are the most oversold and most genuinely useful idea in applied AI right now, and the two facts are related. The pattern works well for a specific set of problems and badly for everything else, and the marketing does not distinguish between them.
Gartner projects that up to 40 percent of enterprise applications will include task-specific AI agents by 2026, up from under 5 percent in 2025. Vendors report multi-agent adoption surging by well over a thousand percent. Some of that is real. A substantial portion is a single agent with a fan-out loop, described in language that implies more.
Worth separating the two.
The patterns that exist
Orchestration is the coordination layer managing multiple specialised agents on a task no single agent handles well. In practice, a handful of topologies cover nearly everything.
Sequential (pipeline). Each agent's output feeds the next. Research, then draft, then review, then format. Simple, debuggable, and the failure mode is obvious. An error in step two poisons everything downstream.
Supervisor with subagents. A manager agent decomposes the task and delegates to specialists, then assembles the results. This has become the default first-class pattern, and it is the shape most "agent teams" features implement. Anthropic documented parallel subagent orchestration in Claude Code as a research preview in February 2026.
Map-reduce / parallel fan-out. Split work into independent units, run them concurrently, merge. Where the real wall-clock wins live, and the easiest to reason about because the units genuinely do not interact.
Debate or ensemble. Several agents attempt the same task independently and a judge selects or synthesises. Expensive, occasionally worth it, frequently just a costly way to average.
Event-driven. Agents react to events on a bus rather than being called directly. Scales best for long-running enterprise workflows and is the hardest to debug, since there is no single call stack to inspect.
The five topologies side by side. Diagram: Big Matrix Solutions, based on Fourney et al., Magentic-One (arXiv:2411.04468) and the patterns described above.
Where multi-agent genuinely wins
Three situations, and they share a property worth naming up front.
1. Independent parallel work
If a task decomposes into pieces that do not need to know about each other, running them concurrently is a straight wall-clock win with no coordination cost. Reviewing forty files for a specific issue. Researching twelve unrelated questions. Migrating twenty independent modules.
This is the strongest case and it is barely "multi-agent" in any deep sense. It is parallelism. Which is exactly why it works: there is no coordination problem to get wrong.
2. Genuine context isolation
Long agent runs degrade as context fills with exploration debris: files read and discarded, commands that failed, dead ends. A subagent that investigates a question in its own context and returns a two-paragraph summary keeps that debris out of the main thread.
This is the most underrated benefit. The subagent is not smarter; it is a context boundary. The supervisor gets the conclusion without paying for the search, which is often the difference between a run that holds coherence and one that unravels at hour three.
3. Different tools or permissions per role
A researcher agent with web access and no write permissions, and an implementer with repository write access and no network egress. Splitting by privilege is a security control that happens to be implemented as multi-agent architecture, and a good one, since it means a hijacked researcher cannot commit code.
Where it fails
More common than the successes, and the failures are systematic rather than incidental.
Coordination overhead exceeds the work. Two agents that must agree on an interface spend more tokens negotiating than one agent would spend just writing both sides. If the pieces are coupled, splitting them adds a communication problem that did not previously exist.
Errors compound silently through the chain. In a four-stage pipeline where each stage is 90 percent reliable, end-to-end reliability is about 66 percent. Worse, stage three cannot tell that stage two's output was subtly wrong. It treats input as given. This is the single biggest reason ambitious multi-agent pipelines underperform expectations.
No shared understanding of the goal. Each agent has a slice of the picture. The one writing the tests does not know why the one writing the code chose that structure. You get locally sensible, globally incoherent output: technically complete work that a reviewer can tell was not built by one mind.
Debugging becomes archaeology. When a single agent fails you read its trajectory. When a system of eight agents produces a wrong answer, you are reconstructing which agent misunderstood what, from logs that were not designed to be read together. Research on multi-agent evaluation converges on the point that log analysis is necessary rather than optional, and most teams have not built for it.
Cost multiplies faster than quality. Five agents cost roughly five times as much. They rarely produce five times the value, and often produce less than one careful agent with a good harness.
The convergence problem
Here is the argument that has reshaped how people think about this, and it comes from an uncomfortable direction.
The original case for specialist agents rested on capability differences. A weaker, cheaper model for simple subtasks; a stronger one for hard reasoning; specialists genuinely better at their niche. Under those conditions, decomposition and routing pay for themselves.
But frontier model performance has converged. The gap between tiers narrowed, and the gap between a "specialist" prompt and a general one narrowed further. Work on task-adaptive orchestration in the era of LLM performance convergence argues this directly: as models converge, the benefit of elaborate multi-agent topologies shrinks, because you are coordinating agents that are not meaningfully different from each other.
What survives convergence is not capability specialisation. It is the three structural benefits above (parallelism, context isolation, and permission separation) none of which depend on the agents being different in ability.
That is a useful filter. If your justification for splitting a task is "this agent is better at that," be sceptical. If it is "these run at the same time," "this keeps that out of my context," or "this one must not have those credentials," you are on solid ground.
The arithmetic of pipelines
Worth making explicit, because it is the single most useful calculation in this area and almost nobody runs it before designing a pipeline.
If a stage succeeds with probability p and you chain n stages, end-to-end success is p^n:
| Per-stage reliability | 3 stages | 5 stages | 8 stages |
|---|---|---|---|
| 95% | 86% | 77% | 66% |
| 90% | 73% | 59% | 43% |
| 80% | 51% | 33% | 17% |
An eight-stage pipeline of individually decent agents is a coin flip at best. This is why ambitious multi-agent architectures demo well on the happy path and disappoint in production. The demo showed one successful run, and the distribution is what matters.
Two ways out, and only two.
Raise per-stage reliability, usually by adding validation at each boundary so a stage's bad output is caught rather than passed on. A validated stage that fails loudly is far better than one that succeeds 90 percent of the time and degrades silently.
Reduce the number of stages. Frequently the right answer, and the one people resist because the elaborate architecture feels more sophisticated. Three well-chosen stages usually beat eight granular ones.
The same arithmetic explains why parallel fan-out is safer than sequential chaining. Independent parallel units do not multiply. One failing unit costs you that unit, not the whole run. If you can restructure a pipeline as a fan-out with a merge, the reliability profile improves dramatically for free.
Design guidance
What holds up in production.
Start with one agent and a good harness. Most teams reaching for multi-agent have not yet exhausted what one agent with proper tools, a fast test suite, and a well-written brief can do. Adding agents to compensate for a weak harness makes the problem worse and less legible.
Split on genuine boundaries only. Parallelism, context, or permissions. If your split does not fall on one of those, it is probably adding coordination cost for no return.
Make interfaces explicit and validated. Agent-to-agent handoffs should be structured data against a schema, not prose. A validation step at each boundary catches the compounding-error problem early, where it is cheap.
Keep the supervisor thin. Its job is decomposition, dispatch, and assembly. Supervisors that also do substantive work end up with the context pollution the architecture was supposed to prevent.

A thin supervisor in practice: Magentic-One's Orchestrator plans, tracks progress in two ledgers, dispatches four specialist agents and replans when progress stalls. Source: Fourney et al., Magentic-One (arXiv:2411.04468), CC BY 4.0.
Budget and cap everything. Token limits and step limits per agent, and a global ceiling. Agent systems without caps find creative ways to spend money, and a subagent that spawns subagents is a genuinely expensive bug.
Instrument for cross-agent debugging from day one. Correlate every tool call, message, and decision to a trace id, with the full trajectory queryable. Retrofitting this after your first inexplicable failure is painful and you will need it.
Prefer stateless agents. An agent that receives everything it needs and returns a result is restartable, cacheable, and testable. Agents holding conversational state across a workflow are none of those things.
The infrastructure decision
As agentic systems move from pilot to production, the orchestration layer becomes one of the more consequential architecture choices a platform team makes. It determines coordination complexity, state management, recovery behaviour, latency, cost exposure, and long-term scalability.
The build-versus-buy question comes down to something fairly simple. Frameworks give you topologies, state handling, and retry semantics you did not have to write. They also give you an abstraction that will not match your requirements in some specific way, at which point you are fighting it.
The pragmatic split most teams land on: use a framework for the coordination plumbing, keep your own agent definitions and tool implementations, and make sure you could replace the framework without rewriting the agents. Orchestration frameworks are churning fast, and a hard dependency on one is a bet on a young ecosystem.
What I would actually tell you
Multi-agent orchestration is a real technique with a narrower application than its coverage suggests.
It reliably helps when work is genuinely parallel, when context needs isolating, or when privileges need separating. It reliably hurts when tasks are coupled, when errors can propagate unnoticed, or when it is being used to paper over a weak single-agent setup.
The convergence argument sharpens this. As models get more similar to each other, the capability case for specialist agents weakens and the structural case is all that remains. Which means the right question is no longer "which agents should I have" but "what are the actual boundaries in this problem", and if you cannot name one, one agent is the better answer.
Media credits:
- Hero image: Figure 1 from Fourney et al., "Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks", arXiv:2411.04468, licensed CC BY 4.0. Placed on a white 16:9 canvas; figure unaltered.
- Orchestrator diagram: Figure 2 from the same paper, CC BY 4.0, unaltered.
- In-body diagram: Big Matrix Solutions.