Multi-Agent Systems: When Several Agents Beat One
Multi-agent diagrams are the most seductive artefact in this field. Boxes with job titles, arrows between them, a coordinator at the top — it looks like an organisation chart, and organisation charts feel like progress.
Then it reaches production and the questions start: which agent produced this wrong number, why did the coordinator accept it, and why does one request now cost eleven model calls. This guide is about the conditions under which the answer is still worth it, and how to build one that stays debuggable.
The three conditions#
Multiple agents pay off when all three hold. The subtasks are genuinely independent — neither needs the other’s output to start. Each needs a different tool set or a different model tier, so specialisation buys something real. And the work is slow enough that doing it in parallel changes the user experience. If only two hold, a single loop with more tools is almost always better, cheaper and easier to fix.
Two agents that must talk to each other repeatedly are one agent with an expensive message bus.
Topologies, and what each costs#
| Topology | How it works | Cost profile | Main failure |
|---|---|---|---|
| Supervisor | One agent delegates to specialists | N+1 loops | Supervisor misroutes |
| Pipeline | Fixed handoffs, each stage specialised | Predictable | A stage degrades silently |
| Parallel fan-out | Same task, several perspectives, merged | Highest | Merge step becomes the bottleneck |
| Debate or critic | One proposes, one challenges | 2× per exchange | Agreement without insight |
| Blackboard | Shared state, agents read and write | Unpredictable | Race conditions and loops |
Design rules that keep it debuggable#
- Give every agent a written contract: what it receives, what it returns, and what it must never do.
- Pass structured objects between agents, never free-form prose that the next agent has to re-interpret.
- Give the whole request one run identifier and attach it to every call from every agent.
- Cap the total across the system, not per agent, or costs compound quietly.
- Forbid cycles unless there is an explicit iteration counter and an exit condition.
- Make every agent able to return `I could not do this` and make the coordinator handle it.
The evaluation problem nobody plans for#
With one agent you evaluate outcomes. With several you must also evaluate the handoffs, because a system can produce a wrong answer with every individual agent behaving correctly — the router chose badly, or the merge dropped the important half. Build an evaluation set at both levels: end-to-end outcomes, and per-agent input-output pairs captured from real runs. Without the second, a regression tells you the system got worse and nothing about where.
A worked example that is worth it#
Competitive research is a task that genuinely fits: given ten companies, gather public information on each. The subtasks are independent, each is slow, and the merge is a straightforward aggregation into a table. Ten parallel research agents finish in the time one takes, and a single synthesiser produces the summary. Compare that with a support agent handling one customer question: the steps depend on each other in sequence, so splitting it across agents adds handoffs and latency for nothing at all.
Frequently asked questions
Does a supervisor agent improve accuracy?
Only if routing is accurate. A supervisor at 90% in front of specialists at 95% gives you about 85% end to end, and the loss is invisible unless you measure routing separately. Keep the number of specialists small enough to describe each in one sentence.
Is agent debate worth the cost?
Sometimes, for genuinely contestable judgements where you can give the critic evidence to check against. For factual lookups it mostly produces agreement, at double the cost. Measure it against a single-pass baseline before adopting it broadly.
How do I debug a multi-agent failure?
With a shared run identifier on every call, stored inputs and outputs per agent, and a rendering that shows the handoffs in order. If you cannot reconstruct who said what to whom, you cannot fix it, and you will end up rewriting prompts at random.
multi agent systemssupervisor agentagent collaborationparallel agentsagent handoff
