Multi-agent systems are a coordination nightmare — here's when you actually need one

Everyone's building multi-agent systems now. Anthropic demos agents that hand off tasks seamlessly. Startups pitch "agent swarms" that coordinate like a hive mind. It looks magical.

Then you build one and realize you've created a $200/day API bill generator that can't decide who should send an email.

I've built multi-agent systems that worked and ones that burned money while accomplishing nothing. The difference isn't the technology — it's knowing when coordination overhead is worth it.

The coordination tax is real: Every handoff requires context transfer. Every decision needs a protocol. Every failure mode multiplies across agents.

Here's what actually happens when you split one agent into three:

• Context loss at handoffs — Agent A gathers requirements, Agent B loses the nuance, Agent C executes the wrong thing
• Unclear ownership — Who handles the edge case? Who retries the failed API call? Who tells the user what happened?
• Protocol overhead — You spend more tokens coordinating than working
• Debugging hell — Was it Agent B's logic or Agent C's input that broke the workflow?

I learned this the expensive way building a content pipeline. Three agents (research, write, publish) seemed logical. In practice:

Research Agent: "Found 12 relevant sources on AI agents"
Writing Agent: "What angle should I take?"
Research Agent: "You decide"
Writing Agent: "I need more context on the technical details"
Research Agent: "Which technical details?"
[6 more exchanges, $8 in API calls, no content]

One agent with a structured workflow would have shipped in 2 prompts.

So when do you actually need multiple agents?

When the coordination cost is less than the specialization benefit. Three scenarios where this math works:

1. Different models for different tasks
Use GPT-4o for reasoning, Claude for writing, and a local model for classification. The coordination is just input/output — no complex handoffs.

2. Truly independent workstreams
One agent monitors your servers, another handles customer emails. They don't need to coordinate, just coexist.

3. Human-in-the-loop checkpoints
Agent A drafts, human approves, Agent B publishes. The human is your coordination layer.

Everything else? Start with one agent and clear workflows. You can always split later when you hit real limits, not imagined ones.

The single-agent rule: If you can't clearly explain why Agent B can't do Agent A's job, you don't need Agent B.

Most teams building multi-agent systems should be building better single-agent workflows instead. Less coordination, more execution, lower bills.