When multi-agent underperforms
Scenario
A developer splits a data formatting task into a 5-agent pipeline, expecting it to be highly accurate.
Will 5 agents format the data better than 1 agent?
Mental model
More cooks in the kitchen don't make a better meal if they keep dropping the ingredients.
We assume splitting a task among many specialists is always better. But in AI, every time you hand a task to a new agent, there is a chance it misunderstands the data. If 5 agents each have a 95% success rate, the total system success rate drops to 77% because the errors multiply.
Deep dive
The industry hype says you should build teams of AI agents. But empirical evidence shows that multi-agent systems often **increase latency** and **decrease accuracy**. Why? Because errors compound sequentially.
Multi-agent systems often fail because errors multiply at every handoff step.
If you use a single agent, it maintains a unified, uncorrupted context. It knows everything it has done so far. If you split the task across 5 agents, they have to constantly read and write to the shared state. This causes massive **serialization overhead** (using 15x more tokens) and creates 5 different chances for an agent to hallucinate.
Single agents maintain perfect context; multi-agents lose context and waste tokens.
A multi-agent framework (like LangGraph or CrewAI) is just a router. It cannot make a dumb model smart. If your underlying LLM is failing to reason through a problem, wrapping it in a complex 4-agent hierarchy will just make it fail harder and slower.
Frameworks route logic, but they cannot compensate for a model's inability to reason.
Prediction: A developer spends three days rewriting a failing single-agent script into a complex multi-agent graph, only to find the exact same logical errors occur at the end. The framework didn't fix the model's limitations.
Never use a multi-agent framework to 'fix' a model that is failing at basic reasoning.
Code examples
The math behind compounding errors
def calculate_pipeline_success(agent_success_rate, num_agents):
# Errors multiply sequentially in a pipeline
total_success = agent_success_rate ** num_agents
return total_success
# Single agent doing the work:
print(calculate_pipeline_success(0.95, 1)) # Output: 0.95 (95% success)
# 5-agent pipeline doing the work:
print(round(calculate_pipeline_success(0.95, 5), 2)) # 0.77 (77% success)Because each handoff requires the next agent to correctly parse the previous agent's output, a 5% error rate quickly destroys the reliability of the system. This is why simpler single-agent loops often win.
Common mistakes
- Assuming more agents equals more accuracy: It mimics human organizational logic (specialized teams are smarter). But in agent architectures, a 5% error rate across multiple handoffs drastically reduces the final pass rate compared to a single model maintaining an uncorrupted context.
- Using frameworks to solve model limits: Framework marketing suggests that orchestration unlocks 'emergent intelligence'. In reality, the underlying LLM is the primary driver of capability. Extensive diagnostics prove agents sharing the same LLM perform similarly regardless of the framework.
Glossary
- cascading error
- When a small mistake made by one agent is passed to the next agent, causing a massive failure at the end.
- serialization overhead
- The time and token cost of constantly translating state data back and forth as agents hand off to one another.
Recall questions
- Why does a 5-agent pipeline often have a lower success rate than a single agent?
- If your AI model is constantly failing a specific reasoning task, will wrapping it in a multi-agent framework fix the issue?
- What is the token overhead of using a multi-agent system compared to a single chat?
Questions & answers
When would you choose a single ReAct loop over a multi-agent framework?
You should use a single ReAct loop when the task has highly interdependent steps that benefit from a single, unbroken context window, and to avoid the compounding error rates of multiple handoffs.
Approach: Identify the latency, cost, and reliability trade-offs of multi-agent orchestration.
A team decides to use 5 specialized agents to process data sequentially. Why might this increase latency and token costs compared to a single agent?
Each handoff between agents requires the entire shared state to be serialized, passed as context, and parsed by the next agent. This serialization overhead heavily increases token consumption and network latency.
Approach: Discuss the serialization overhead and context window duplication inherent in multi-agent handoffs.
Continue learning
Previous: Multi-agent orchestration patterns