Multi-agent orchestration

TL;DR

• Single agents hit limits at the context window boundary: they can't parallelize work or specialize by domain. Multi-agent systems break through both limits.
• The supervisor pattern: one orchestrator decomposes tasks and dispatches to specialized workers. The orchestrator coordinates; it doesn't do the work.
• Parallel workers: independent subtasks run simultaneously. Deep research agents spawn 5-10 subagents at once. Latency equals the slowest task, not the sum.
• Communication failure is the most common source of multi-agent bugs. Agents must communicate via structured messages with defined schemas, not free-text strings.
• State management for shared work must be explicit: a database, a message queue, or a shared store. Agents passing state through context chains are brittle.

---

The problem it solves

You're building a research agent that needs to: search for recent news on a topic, find academic papers, summarize each source, compare findings, and write a final synthesis. If one agent does this sequentially, it takes 60+ seconds and must hold all intermediate results in a single context window that rapidly fills up.

More fundamentally, the same LLM that searches academic databases isn't necessarily the best model for writing synthesis reports. A generalist model handles both but doesn't excel at either.

Multi-agent systems solve both problems simultaneously: parallel execution collapses the sequential latency, and specialist agents with purpose-built system prompts and targeted tools outperform generalists on narrow tasks.

What is it?

A multi-agent system is a collection of individual AI agents that collaborate to complete tasks that a single agent cannot handle well alone. Each agent has its own system prompt, tools, and context window. A coordination layer (the orchestrator) manages the flow of work between them.

The key architectural decision is how agents communicate and how the orchestrator manages state. Get this wrong and you end up with a system that's harder to debug than a single agent, not easier.

How it works

Supervisor (orchestrator + worker) pattern

The supervisor pattern is the standard architecture for most multi-agent systems. The orchestrator agent receives the top-level task, breaks it down into subtasks, routes each subtask to the appropriate specialist worker, collects the results, and synthesizes the final output.