Multi-agent systems pay a coordination tax: routing tasks to the right agent, keeping shared state consistent, and message passing between agents, all of which a single sequential agent avoids.
Imagine one chef cooking a whole meal alone. The chef remembers exactly what is in every pot, so nothing gets out of sync. Now imagine a team of chefs sharing one kitchen. Someone has to decide who chops, who fries, and who plates. The chefs must shout updates to each other so nobody salts the soup twice. If one chef mishears another, the dish is ruined. The team can cook faster when tasks are truly independent, but they spend real effort just staying coordinated. Multi-agent systems are the team of chefs. The coordination, deciding who does what, keeping everyone's view of the meal consistent, and passing messages around, is pure overhead that the lone chef never pays.
Concept explanation~2 min read
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Concept explanation~2 min read
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
A multi-agent system runs several LLM agents on one task instead of a single agent in a loop. The intuition that more agents means more capability is seductive and usually wrong. The moment you split a task across agents, you take on a coordination cost that a single agent never pays, and that cost shows up as added latency, new failure surfaces, and compounding errors.
The question is asking for the primary thing you give up. The answer is coordination: routing work to the right agent, keeping shared state consistent across agents, and passing messages between them. A single agent sidesteps all of it because it holds the whole task in one transcript, with one consistent memory and no handoffs to drop.
Understanding why this tax exists, and when it is worth paying, is the core of good multi-agent design. The framing that follows treats the single agent as the baseline and asks what each extra agent actually buys you, because the honest accounting almost always favours simplicity until a concrete reason forces your hand.
The three components of coordination cost
Coordination cost breaks into three concrete pieces, and each maps to a real engineering problem.
The first is routing. In a multi-agent system, something has to decide which agent handles which sub-task. That decision can sit in a central orchestrator or be made peer to peer, but either way it is a decision the system pays for in latency and in the risk of routing to the wrong specialist. Routing is also a quality problem, not just a speed problem: a misrouted sub-task lands at an agent that lacks the right tools or context, and the result is a confidently wrong answer rather than a clean failure. A single agent never routes, because it does every sub-task itself.
The second is shared-state synchronisation. Each agent holds a partial view of the task. If two agents act on stale or conflicting views, they produce conflicting outputs. Keeping their views consistent means either serialising writes through one store or accepting eventual consistency, both of which add complexity. This is the same consistency problem distributed databases spend whole chapters on, now sitting inside your agent runtime where it is easy to underestimate.
The third is inter-agent message passing. When one agent finishes and hands its result to another, that handoff is a message. Messages add a round trip of latency, and they can be lost, reordered, duplicated, or simply misread by the receiving agent. Because the payload is natural language rather than a typed schema, a receiving agent can also silently misinterpret a correctly delivered message, which is a failure mode wire protocols do not have. A single sequential agent has no handoffs, so none of these failures can occur.
Situations where this technique stops working.
2–4 min · Everything important, quickly.
Real products, models, and research that use this idea.
- OpenAI's Swarm and the Agents SDK model handoffs explicitly, where one agent yields control to a specialist, making the routing and message-passing cost a first-class concept.
- LangGraph's supervisor pattern centralises routing in a coordinator node that dispatches to worker agents and reconciles their results in a shared typed state graph.
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does end to end success rate change as you add more agents in a handoff chain, and what does that imply for design?
Model per-step success as independent and multiply. If each of ten hops succeeds ninety percent of the time, end to end is roughly thirty-five percent. The implication is to minimise hop count, add verification gates, or keep the chain short and parallel rather than deep.
Red flags & common mistakes
The phrases that signal junior thinking. Click to expand.
Red flags & common mistakes
The phrases that signal junior thinking. Click to expand.
Assuming more agents means more capability. The default is the opposite. Coordination adds latency and failure surfaces, so a single agent wins unless the task has genuine parallelism or specialisation.
60 second bullets to scan on the way to the call.
Name the three components of coordination cost and what each one does.
Explain why a single sequential agent pays none of that cost.
Primary sources. Browse if you want the original framing.
Same topic, related formats. Practice these next.