Multi-Agent Systems: When One Agent Is Not Enough
On this page
A research agent is asked to compare twelve competitors' pricing and features. One agent does it all in one loop: it carries 30 tool definitions, notes on every competitor and 40 search results in a single context. It works through the competitors one by one, takes 25 minutes, and by competitor nine it has started mixing up details from competitor two. The task is naturally parallel, but one agent can only do one thing at a time and keep so much in its head. Multi-agent systems split work across several agents, each with its own focused context.
How it works

Orchestrator–workers
The most useful pattern in practice:

- A lead agent (orchestrator) reads the task, makes a plan and splits it into independent sub-tasks with clear instructions: goal, scope, expected output format, and limits.
- Worker agents (sub-agents) run in parallel, each with its own context and only the tools it needs. They explore deeply, then return a condensed result, not their whole transcript.
- The lead combines the results, checks for gaps or contradictions, and either spawns follow-up work or writes the final answer.
Why it helps: parallel work cuts wall-clock time; each worker's context stays small and focused; the lead's context holds summaries instead of raw material.
Other shapes
- Pipeline (assembly line): agent A's output is agent B's input (research → write → review). Simple, but really a workflow with model steps.
- Specialists behind a router: a router sends each request to the agent built for it (billing, technical, sales), each with its own prompt and tools.
- Debate or review: several agents propose or critique answers; useful for high-stakes judgments, expensive.
- Peer-to-peer hand-offs: agents pass control to each other. Flexible, but hardest to predict and debug.
Communication and shared state
- Clear task specs from the lead are critical; vague delegation causes duplicated or missing work.
- Shared artifacts (files, a database, a scratchpad) let workers hand over large outputs by reference instead of copying them through messages.
- Structured results (a schema for each worker's output) make combining reliable.
Trade-offs and costs

- Tokens: every worker re-reads instructions and builds its own context, so a multi-agent run often costs several times a single-agent run for the same task. Worth it only when the task's value justifies it.
- Coordination failures: two workers researching the same thing, a sub-task nobody covered, or conflicting edits to the same file.
- Debugging: failures hide in hand-offs. You need traces across all agents with a shared run ID.
- Tightly coupled tasks (each step depends on the previous one, like most coding changes to one file) gain little from parallelism and suffer from coordination overhead.
In production
- Bound fan-out: cap the number of workers and their steps, tokens and time; the lead must handle a worker that fails or times out.
- Isolate side effects: workers usually read and research; writes go through the lead or one designated agent.
- Trace everything under one run with parent/child spans for each agent.
- Evaluate end to end and per role (was the plan good, did each worker answer its sub-task).
- Failure modes: the lead spawning too many workers for a simple question; workers returning raw dumps that overflow the lead's context; contradictory findings merged without notice; runaway costs.
When to reach for it
Broad tasks that split into independent parts: research across many sources, analysing many documents or repositories, checking many items against the same rubric. Stay with a single agent (or a workflow) when steps depend tightly on each other or when cost matters more than speed.
Example
The competitor research was rebuilt with a lead agent that splits the 12 competitors into 4 groups of 3 and gives each worker a schema to fill (pricing tiers, key features, source URLs). Workers run in parallel with search and browse tools only; each returns about 500 tokens of structured findings. The lead checks for missing fields, sends one follow-up task for two gaps, and writes the comparison. Wall-clock time dropped from about 25 to about 7 minutes; token cost rose about 3×, which the team accepted for a report used in sales meetings (example numbers).
Common mistakes
- Going multi-agent first, before a single agent or workflow is shown to fail.
- Vague delegation ("research competitors") instead of scoped tasks with output formats.
- Workers returning full transcripts instead of condensed results.
- Letting several agents write to the same resource.
- No caps on fan-out and spend.
Say this in the interview
"I'd use multi-agent only for broad, parallelisable work. The common pattern is orchestrator–workers: a lead plans and delegates scoped sub-tasks with clear output formats, workers run in parallel with their own focused context and tools and return condensed structured results, and the lead combines and checks them. The costs are several times the tokens, coordination failures and harder debugging, so I cap fan-out and spend, keep writes in one place, and trace all agents under one run."
Interview questions on this
- When does multi-agent beat a single agent? When the task splits into independent parts and speed or context size is the bottleneck.
- Why do workers return summaries? To keep the lead's context small and focused on combining results.
- How do you avoid duplicate work between workers? Clear, non-overlapping task specs from the lead, and shared state of what's assigned.
- What new failure modes appear? Gaps and overlaps between sub-tasks, conflicting results, runaway fan-out, and hard-to-trace hand-offs.
- How would you control cost? Cap workers, steps and tokens; use cheaper models for workers; skip multi-agent for simple requests.
Used in
- AI Engineering: Agent Patterns; Agent Memory and State; Making Agents Reliable; Evaluating Agents; LLM Observability and Tracing.
- AI System Design: Design Deep Research; Design Cursor.