Anthropic put out research this week on multi-agent systems—what happens when you connect multiple AI agents together instead of running one big model. It’s worth reading if you’re building anything in this space, because they’re not selling a product. They’re documenting what actually breaks.

The core insight: multi-agent systems aren’t just a scaling trick. They let you specialize agents for different tasks, run them in parallel, and compose them in ways that a single model can’t match. But they also introduce new failure modes that don’t exist in single-agent setups.

What actually works

Anthropic tested multi-agent approaches on software engineering tasks, the kind where you need to plan, search a codebase, write code, and verify it works. Single agents struggle here because they try to do everything at once. Multi-agent systems can split the work.

The patterns that showed results:

Delegation hierarchies. One orchestrator agent routes subtasks to specialist agents. Works well when tasks are clearly separable. Breaks when the orchestrator makes bad routing decisions or when agents need to share context that doesn’t fit in a handoff.

Debate and verification. Multiple agents propose solutions, then critique each other’s work. This catches errors that a single agent would miss, especially on tasks where verification is cheaper than generation. The downside is cost—you’re running multiple inference passes on the same problem.

Parallelization. Split independent subtasks across agents, run them simultaneously, merge the results. Obvious win for latency when you have work that doesn’t depend on other work. Less obvious: it also improves quality on tasks like research, where you want multiple perspectives before synthesizing.

What breaks

The problems are more interesting than the patterns.

Context fragmentation. When agents hand off work, they lose context. Agent A reads a file and passes a summary to Agent B, but the summary drops details that matter later. You can fix this by passing full context, but then you’re paying to re-process the same information across agents. Anthropic doesn’t have a clean answer here—it’s a tradeoff between cost and quality.

Coordination overhead. Agents need protocols to communicate. Who talks to whom? When? What format? If you hardcode it, you lose flexibility. If you let agents figure it out, they spend tokens negotiating instead of working. The research shows this overhead can dominate runtime on small tasks.

Cascading failures. One agent makes a mistake, passes bad information to the next agent, which compounds the error. Single-agent systems fail locally. Multi-agent systems fail globally. Anthropic tested error recovery strategies—retries, redundancy, verification loops—but they all add cost and latency.

Emergent behavior. Agents sometimes develop strategies that work but aren’t what you intended. In one experiment, agents started caching information in filenames to pass state between tasks, because it was cheaper than using the coordination protocol. Clever, but brittle.

What this means if you’re building

If you’re using multi-agent systems in production, the research has specific recommendations.

Start with single-agent. Only go multi-agent when you have a clear reason: you need parallelization for latency, specialization for quality, or you’ve hit context limits. Don’t do it because it sounds cool.

Design for observability. You need to see what each agent is doing, what information it’s passing, and where failures happen. Anthropic built custom logging for this. You’ll need to as well.

Test failure modes explicitly. Multi-agent systems fail differently than single-agent systems. Your tests need to cover coordination failures, context loss, and cascading errors, not just task success.

Measure cost. Multi-agent systems can easily run 3-5x the inference cost of single-agent systems, even when they’re faster or better. Know the tradeoff.

The meta point

This research matters because Anthropic isn’t trying to sell you on multi-agent systems. They’re documenting the problems they hit while building them. That’s more useful than a demo.

The big open question: are multi-agent systems a workaround for current model limitations, or a fundamental architecture that scales beyond single models? Anthropic doesn’t answer this. But the fact that they’re publishing issues, not just wins, suggests they don’t know yet either.

If you’re experimenting with agents talking to other agents, read the full research. It won’t tell you whether to build multi-agent systems, but it’ll tell you what breaks when you do.