Multi-Agent Systems

Multi-agent systems split a task across several specialized agents that coordinate with each other. They can be powerful, but they're also where teams most often add complexity that didn't pay for itself.

When Multi-Agent Helps

• The task has clearly separable sub-tasks. A research agent, a writer agent, an editor agent each have meaningfully different jobs.
• You want isolated context. Spinning up a sub-agent gives it a fresh window for a focused task without polluting the main agent's context.
• You need parallelism. Independent sub-tasks can run concurrently for latency wins.
• You want different models per role. A reasoning model for planning, a fast model for execution, an embedding model for retrieval.

When It's Premature

• One model could do it just fine with better prompting or tool use.
• The "agents" are really just functions dressed up — you wanted a workflow, not a system.
• Coordination cost dominates. Token spend on agents talking to each other exceeds the work being done.

If a single agent with the same tools and prompt would also work, prefer it. Multi-agent earns its place when isolation, parallelism, or specialization actually matter.

Common Patterns

• Orchestrator + workers — a coordinator decomposes work and dispatches it to specialized workers. The most common pattern.
• Hierarchical — an orchestrator coordinates other orchestrators. Useful for genuinely complex tasks.
• Debate / critique — multiple agents argue or critique each other's outputs to improve quality.
• Pipeline — agents arranged in a fixed sequence, each handing off to the next.

The orchestrator + workers pattern covers most real cases.

Communication

Agents talk through some message format. Options:

• Free-form text — flexible but lossy.
• Structured messages — JSON with typed fields. Easier to debug.
• Shared scratchpad / memory — a shared workspace agents read and write.

Shared scratchpads are powerful but require care — race conditions and stale reads exist in agent systems too.

Failure Modes

• Cascading errors — agent A's small mistake becomes agent B's bigger mistake.
• Confused authority — when two agents disagree, who wins?
• Coordination loops — agents handing work back and forth without progress.
• Cost explosions — every coordination message is more tokens.

Hard limits — turn caps, cost caps, no-progress detection — matter even more than in single-agent systems.

A Pragmatic Default

Start with one agent and a focused tool set. Add a second agent only when you can name the specific reason it's better than just adding another tool to the first agent. That filter catches most premature multi-agent designs.