Multi-Agent Systems

Several agents with different roles, coordinating. Sometimes better than one, often just a more expensive way to fail.

The appeal is obvious: give each agent a role, let them collaborate, and complex work becomes tractable. A researcher, a writer, a critic.

The reality is that multi-agent systems fail more often than single agents, for a reason worth stating up front: reliability compounds downward, and coordination adds steps. Three agents at 90% each, in sequence, gets you 73%.

They are still worth building in specific circumstances. Knowing which ones saves a great deal of wasted effort.

What actually justifies more than one agent

Context isolation. The strongest reason. Each agent gets its own short transcript rather than one loop accumulating everything. This directly attacks the quadratic context growth that limits long single-agent runs — and it is the only justification that scales.

Genuine parallelism. Five independent subtasks running concurrently is five times faster. Real, and only applies when the subtasks truly do not depend on each other.

Independent perspectives. A critic that has not seen the writer’s reasoning catches things the writer cannot. Fresh context is what makes the critique valuable, and it cannot be simulated by asking one agent to check its own work.

Different tool sets. An agent with database access and an agent with deploy access, kept separate so neither can do the other’s job. This is a security argument as much as a capability one.

What does not justify it

Role-playing for its own sake. Prompting one model to “act as a project manager” and another to “act as an engineer” adds calls, not capability. The same model is behind both.

Making a hard task easier. Splitting a task the model cannot do produces several subtasks it also cannot do, plus coordination overhead.

Because it sounds sophisticated. A single agent with good tools beats an agent committee for most work.

Patterns

Supervisor. One agent decomposes work and delegates to specialists, then assembles results. Clear control flow, and the supervisor becomes a bottleneck and single point of failure.

Pipeline. Fixed sequence, each agent transforming the output of the previous. Predictable and debuggable. Note that if the sequence is genuinely fixed, this is a workflow and does not need agents at all.

Parallel fan-out with synthesis. Several agents work independently on separate pieces, one agent combines. The pattern with the clearest payoff, because parallelism is real and coordination is minimal.

Debate or critique. One produces, another critiques, iterate. Works when the critic has independent context; degenerates into mutual agreement when it does not.

Where they break

Information loss at boundaries. Agent A knows something relevant that never makes it into the message to agent B. Each handoff is a lossy compression, and the loss is invisible.

Error propagation. A wrong result passed downstream gets built upon. Later agents have no way to know their input was wrong, and confidently elaborate on it.

Coordination overhead. Handoff messages are tokens. Multi-agent systems are frequently several times more expensive than a single agent for the same task.

Diffused responsibility. When the output is wrong, which agent was at fault? Debugging requires reading every transcript.

Convergent agreement. Agents built on the same model share its blind spots. A critic and a writer that are the same model with different prompts do not provide genuinely independent judgment.

Making them work

Explicit, typed handoffs. Define exactly what passes between agents — structured output, not prose. This is the single highest-value practice, because it makes information loss visible.

Validate at boundaries. Check each agent’s output before the next consumes it. Catch errors where they happen rather than three steps later.

Keep the graph shallow. Two levels of delegation, not five. Depth multiplies both cost and failure probability.

Give each agent a narrow tool set. Fewer tools means better tool selection, and it limits blast radius.

Log every message. The inter-agent transcript is the only debugging artifact you will have.

Cap total work globally, not per agent. Otherwise five agents with ten iterations each becomes fifty model calls.

The honest recommendation

Start with one agent. Add a second when you can name the specific thing it does that the first cannot — usually context isolation or real parallelism.

Most successful production systems are a single well-scoped agent with good tools, or a fixed pipeline with model calls at defined stages. Elaborate agent societies remain mostly demonstrations.

What to remember

• Reliability compounds downward and coordination adds steps — multi-agent systems fail more than single agents.
• The strong justifications are context isolation, genuine parallelism, independent perspective, and tool separation.
• Role-playing and task difficulty are not justifications.
• Failures cluster at handoffs: information loss, error propagation, cost, and diffused responsibility.
• Use typed handoffs, validate at boundaries, keep the graph shallow, and cap total work globally.

Next: Agent Memory