Honest framing first
Multi-agent systems are fashionable, and fashion produces over-engineering. A team of five chatting agents makes a compelling demo, but in production each extra agent adds latency, cost and a new place for things to go wrong. Our default position is that you should earn the right to add an agent by showing, on a test set, that it beats the simpler design.
That said, some problems really do benefit. When a job spans many sources, demands different expertise at different stages, or is simply too large for a single context window, splitting it among specialists — with a clear coordinator — produces better results and is easier to maintain.
Patterns we use
- Planner–executor. One agent drafts a plan of steps; executor agents carry them out with narrow tools; the planner revises when results come back. Good for research and data-gathering tasks.
- Supervisor with specialists. A routing agent decides which specialist — billing, technical, legal — should handle each part of a request. Good for broad internal assistants.
- Generator–critic. One agent produces, another reviews against explicit criteria and sends it back with specific objections. Good for proposals, reports and code.
- Pipeline with checkpoints. Fixed stages with an agent at each, and validation between stages. The most predictable pattern and often the right one.
We implement these as explicit graphs in code, not as open-ended conversations. Each node has typed inputs and outputs, the shared state is a defined schema, and every transition is logged.
What we watch in production
Multi-agent failures tend to be quiet: a hand-off loses a key detail, a reviewer approves something it shouldn’t, a loop burns tokens for minutes. We instrument each agent separately so you can see quality per step, and we set budgets so that a run that exceeds its allowance stops and escalates instead of carrying on. Over time the traces show which agents add value and which can be merged or removed — and we act on that.