TL;DR
- Multi-agent systems are agent frameworks composing two or more LLM-driven agents that interact via shared state, message passing, or explicit handoffs.
- Five recurring patterns dominate practical designs: single agent with tools, supervisor, hierarchical, network, and swarm (handoff). Each has different control, observability, and cost characteristics.
- Multi-agent designs are not automatically better than well-instrumented single agents. They add coordination cost — extra LLM calls, longer traces, more failure modes — and only pay off when the task genuinely benefits from role specialisation or parallelism.
- Patterns are described and implemented in LangGraph, AutoGen, CrewAI, and the OpenAI Agents SDK with broadly compatible semantics; the choice of framework is usually independent of the choice of pattern.
Why Multiple Agents#
A single LLM with the right tools can solve most production tasks. Multiple agents earn their keep when one or more of the following is true: the task decomposes into roles with distinct prompts and tool sets, role specialisation improves accuracy more than the cost of extra calls, the workflow has natural parallelism, or auditability requires separating responsibilities (a generator and a critic, for example).
When none of these is true, multi-agent designs add latency, cost, and failure surface without proportional benefit. Start with one agent and split when measurement shows a specific reason to.
The Five Patterns#
| Pattern | Topology | Control | Best for |
|---|---|---|---|
| Single agent | One agent + tools | Implicit (model loop) | Most tasks |
| Supervisor | Manager routes to workers | Centralised | Heterogeneous task mix |
| Hierarchical | Tree of supervisors | Centralised, nested | Complex multi-domain tasks |
| Network | All-to-all messaging | Distributed | Free-form collaboration |
| Swarm / handoff | Agents pass control via tool calls | Distributed, sequential | Triage and routing |
Supervisor Pattern#
A supervisor (also called orchestrator or router) is an LLM-driven agent whose job is to decide which worker agent should handle the current state. Workers are specialists with focused prompts and tools. The supervisor inspects the state, picks a worker, the worker acts, and control returns to the supervisor for the next decision.
This is the most common production pattern because it concentrates decision-making in one place — easy to instrument, easy to constrain — while still benefiting from worker specialisation. AutoGen's `SelectorGroupChat`, LangGraph's supervisor template, and CrewAI's hierarchical process all implement this pattern.
Hierarchical Pattern#
Hierarchical multi-agent systems are supervisors of supervisors. A top-level supervisor routes to mid-level supervisors who route to leaf workers. Each level focuses on its scope: the top level decides domains, mid-levels decide sub-tasks, leaves execute.
This is appropriate for very heterogeneous problem spaces — a software engineering assistant with separate sub-teams for code generation, testing, deployment, and documentation, for example. The cost is added latency and a more complex trace, so reserve it for tasks that genuinely span multiple domains.
Network Pattern#
Network topologies allow any agent to send messages to any other. This is the most flexible and the least predictable. AutoGen's group chat with no fixed speaker order is a classical network pattern; the framework's role is to decide who speaks next when ambiguity arises.
Network designs can produce emergent collaboration patterns that fixed-topology designs miss, but they are notoriously hard to instrument, evaluate, and constrain. Use them for research and exploration; prefer supervisor or swarm for production.
Swarm / Handoff Pattern#
Swarm patterns express control flow as explicit handoffs: Agent A calls a special tool whose effect is to transfer control to Agent B. The conversation continues under B's instructions and tool set. No centralised supervisor exists — the agents themselves know when to hand off.
Popularised by OpenAI's Swarm and now supported in AutoGen (Swarm team), CrewAI, and LangGraph, this pattern is a natural fit for triage and routing — a customer-service triage that hands off to billing or technical specialists, an assistant that hands off to a coding sub-agent for code-related questions.
Swarm patterns produce the most legible traces of any multi-agent design: control changes are explicit tool calls, so a trace tree clearly shows who handled what. If observability matters, this is the pattern to start with.
Choosing a Pattern#
- Default to a single agent until measurement shows a specific reason to split.
- Choose supervisor when you have 3-7 distinct specialists and want centralised routing.
- Choose hierarchical when distinct domains nest naturally and you accept higher latency.
- Choose network when collaboration patterns are genuinely emergent and you can afford the observability cost.
- Choose swarm when handoffs are the natural control structure and trace legibility matters.
References
- LangGraph Multi-Agent Concepts · LangChain
- AutoGen AgentChat Tutorials · Microsoft
- Anthropic — Building Effective Agents · Anthropic Research