Multi-Agent Orchestration Patterns — 8 Proven Architectures
In This Article
Why Architecture Patterns Matter for Multi-Agent Systems
A single Claude agent can handle a surprising range of tasks, but it hits hard limits: context window saturation, lack of parallelism, and the inability to simultaneously hold the role of specialist and orchestrator. Multi-agent systems break through these limits — but only if the coordination architecture is chosen deliberately.
The wrong pattern is expensive in every dimension. A fan-out where a pipeline was needed produces incoherent outputs that require expensive re-runs. A supervisor where a simple pipeline would suffice adds latency overhead and doubles the token cost. An ad-hoc architecture with no clear topology is the worst outcome — unpredictable, hard to debug, and impossible to scale.
The eight patterns below cover the full space of multi-agent coordination. Each has a well-defined topology, characteristic latency and cost profile, and a class of tasks it is optimally suited for.
Interactive Pattern Selector
Click any pattern below to see its animated architecture diagram, complexity/cost profile, use cases, and a ready-to-use Python code template.
Pattern Selector
Click a pattern to see its architecture diagram, metrics, and code template.
Side-by-Side Pattern Comparison
| Pattern | Topology | Latency | Token Cost | Best For |
|---|---|---|---|---|
| Fan-Out | 1 → N → 1 | Low (parallel) | N× single | Parallel independent subtasks |
| Pipeline | A → B → C → D | High (serial) | Low | Sequential transformation chains |
| Supervisor | Hub & spoke | Medium | Medium | Routing to specialists |
| Consensus | N agents, 1 vote | Low (parallel) | N× single | High-stakes accuracy tasks |
| Blackboard | Shared state store | Async | Low per-agent | Long-running knowledge tasks |
| Event-Driven | Pub/sub channels | Very Low | Low | Reactive, trigger-based workflows |
| Map-Reduce | Map N → Reduce 1 | Low (parallel) | N× + reduce | Large dataset summarization |
| Hierarchy | Tree of orchestrators | High | High | Enterprise-scale complex tasks |
Combining Patterns in Production
Most production systems layer two or three patterns. The most common combinations observed in open-source repositories are:
- Supervisor + Fan-Out: The supervisor decides which tasks can run in parallel, then fans them out. Workers return to the supervisor for synthesis. Used in research assistants and multi-source data gathering.
- Pipeline + Map-Reduce: Early pipeline stages normalize and chunk input data; the map-reduce stage processes all chunks in parallel and reduces them into a final report. Used in document processing and large codebase analysis.
- Hierarchy + Blackboard: Top-level orchestrator decomposes the task and writes partial results to a shared blackboard; lower-level agents read from the blackboard and post their contributions. Used in long-running autonomous agents and research workflows.
- Event-Driven + Supervisor: Events trigger the supervisor, which dispatches specialist agents. The supervisor posts results back as new events. Used in monitoring, alert response, and continuous integration pipelines.
Common Orchestration Pitfalls
Context Propagation Failures
The most common failure mode in any multi-agent system is losing context between handoffs. Each agent receives only a slice of the original task, and critical constraints or user preferences embedded in the original request fail to propagate downstream. Fix this by including a shared context block in every agent prompt — a concise summary of the user goal, constraints, and key decisions made so far.
Infinite Retry Loops
Supervisor and event-driven patterns are prone to retry loops when an agent repeatedly fails a task. Always implement a max_retries parameter and a dead-letter queue where failed tasks are stored for human review rather than retried indefinitely.
Result Fanout Without Merge Strategy
Fan-out and map-reduce patterns require an explicit merge strategy defined before the fan-out begins. Without it, the merge agent must infer how to reconcile conflicting outputs, which produces inconsistent results. Define merge criteria upfront: concatenation, voting, scoring, or hierarchical priority.
Underspecified Agent Roles
In supervisor and hierarchy patterns, vague role boundaries cause agents to duplicate work or produce conflicting outputs. Each agent should have a one-sentence role definition, explicit input format, explicit output format, and a list of tools it is permitted to use.
How to Choose the Right Pattern
Use this decision tree to select a starting pattern:
- Can all subtasks run independently? Yes → Fan-Out or Map-Reduce. No → continue.
- Does each step depend on the previous step's output? Yes → Pipeline. No → continue.
- Do you need a specialist for each subtask type? Yes → Supervisor. No → continue.
- Is accuracy more important than cost? Yes → Consensus. No → continue.
- Are agents long-running and asynchronous? Yes → Blackboard. No → continue.
- Are tasks triggered by external events? Yes → Event-Driven. No → Hierarchy.