Theme: The Craft
Length: ~800 words
Hook: Counterintuitive — challenge the multi-agent hype
The multi-agent hype is real. "Why use one agent when you can use five?" "Multi-agent systems are the future." "Agents that talk to each other will be more powerful than any single agent."
Maybe. But multi-agent systems also introduce problems that single-agent systems don't have. And most teams underestimate these problems.
Problem 1: Coordination overhead.
When you have one agent, it makes decisions. When you have five agents, they need to coordinate. Who does what? When? In what order? What if they disagree?
Coordination is communication. Communication is latency, cost, and failure points. Every message between agents is an LLM call (to understand the message) and another LLM call (to respond). Five agents coordinating on a task might make 20-30 LLM calls just for coordination — before any actual work gets done.
A single agent doing the same task might make 5-10 calls. The multi-agent system is 3x more expensive and 3x slower, just from coordination overhead.
Problem 2: Communication failures.
Agents communicate through text. Agent A sends a message to Agent B. Agent B interprets it. But Agent B's interpretation might not match Agent A's intent.
This is the same problem humans have, but worse. When a human says "send me the report," the other human knows what "the report" means from context. When Agent A says "send me the report," Agent B might ask: which report? In what format? To where? The clarification loop adds more calls, more latency, more cost.
And sometimes Agent B doesn't ask for clarification — it guesses. And it guesses wrong. Now Agent A is working with the wrong report, and the error propagates through the system.
Problem 3: Emergent behavior.
Multi-agent systems exhibit emergent behavior — behavior that wasn't designed but arises from the interaction of agents. Sometimes this is good. Often it's not.
Example: Agent A is told to "gather information efficiently." Agent B is told to "provide thorough responses." Agent A asks a question. Agent B provides a thorough (long) response. Agent A asks another question to clarify. Agent B provides another thorough response. The conversation continues for 15 exchanges before either agent realizes they could have resolved it in 2.
This is emergent verbosity. No one designed it. It arose from the interaction of two individually reasonable instructions. And it costs you 13 extra LLM calls.
Problem 4: Debugging complexity.
When a single agent makes a mistake, you trace its decision chain. One audit trail. One reasoning path. One set of tool calls.
When a multi-agent system makes a mistake, you need to trace:
- What did Agent A perceive?
- What did Agent A tell Agent B?
- What did Agent B think Agent A meant?
- What did Agent B do based on that interpretation?
- How did Agent C, who was also in the conversation, react?
- The task is genuinely parallelizable. Research tasks where multiple agents investigate different aspects simultaneously. Each agent works independently. Coordination is minimal.
- Different expertise is needed. One agent is good at coding, another at writing, another at analysis. Specialization improves quality. But the agents should be orchestrated, not free-chatting.
- The task is too complex for one agent's context window. If a single agent can't hold all the context, splitting across agents makes sense. But this is a context window limitation, not a fundamental architectural choice.
The audit trail is 3-5x longer. The failure might be in Agent A's output, Agent B's interpretation, or the interaction between them. Debugging this is significantly harder.
Problem 5: Cascading errors.
We covered this in our failure economics article, but it's worth repeating: in multi-agent chains, errors compound. Agent A's small error becomes Agent B's larger error becomes Agent C's significant error. By the time the output reaches the user, the error is amplified.
When multi-agent IS the right choice.
Multi-agent systems aren't always wrong. They're right when:
The alternative: orchestrated single-agent systems.
Before you build a multi-agent system, consider: can a single agent with good tools and good prompts do the job? A single agent that calls specialized tools (not specialized agents) can achieve most of what multi-agent systems achieve, without the coordination overhead.
The pattern: one agent, many tools. The agent decides which tool to call. The tools are deterministic. The agent is the only non-deterministic component. This is simpler, cheaper, faster, and easier to debug.
The practical takeaway.
Multi-agent systems are powerful but expensive. They add coordination overhead, communication failures, emergent behavior, debugging complexity, and cascading errors. Use them when the task genuinely requires multiple agents. Don't use them because "more agents = more powerful."
Sometimes, the best multi-agent system is a single agent with great tools.
Have you built a multi-agent system that was simpler than expected — or more complex than you anticipated?