L3 · Multi-Agent

Specialists. Who decides who works next?

The point where coordination becomes the system's hardest problem. Supervisors, handoffs, swarms, blackboards — twelve canonical answers to the same question.

Open Supervisor, the canonical pattern See the three coordination archetypes

Anatomy

What an L3 system is made of.

Five parts compose every multi-agent system: a Coordinator that decides who acts, Specialists with their own tools and prompts, Channels that move work between them, Memory that holds what they share, and Boundaries that bound what each can touch.

Coordinator · Who decides next
Supervisor, leader, or self-organizing rule.
The piece of the system that picks the next agent to act. Can be a model, a deterministic rule, or absent (peers self-route).
Specialist · The bounded role
A sub-agent with its own prompt and tools.
A scoped agent with its own system prompt, tool set, and memory. Small enough to reason about; large enough to do one job.
Channel · How they talk
Handoff, blackboard, or message bus.
The mechanism that moves work between specialists. Direct handoffs are loud and traceable; shared workspaces are quiet and concurrent.
Memory · What they remember
Shared scratchpad vs. per-agent state.
Some L3 systems share one running context across agents; others give each agent its own. The choice shapes both consistency and bleed risk.
Boundary · Where an agent ends
Tool surface, role, and trust scope.
The agent's effective perimeter — what tools it can call, what data it can see, what it is permitted to claim about its work.

When this rung fits

Multi-agent is enough when…

Multi-agent earns its name when specialists are genuinely separate — distinct prompts, tools, and trust scope — and the question of who works next is the actual problem to solve.

Multi-agent is enough when…

Specialists genuinely differ in prompt, tools, memory, or trust scope — not just in names.
Which agent should speak next is itself the decision the system has to make.
The set of next steps cannot be enumerated at authoring time, but the set of roles can.
Failures should localise to a specialist or a handoff, not to a single monolithic agent.

…and not enough when

A single ReAct loop or a workflow DAG would already suffice — drop to L1 or L2.
Specialists don't actually carry distinct tools, prompts, or scope. You're naming roles, not separating them.
The next failure you can't debug is operational — memory bleed, runaway loop, missing trace. That is L4.
Auditability requires deterministic steps end-to-end; the model should never pick the next node.

The three archetypes

Twelve patterns, three shapes of control.

Every multi-agent pattern answers “who decides who works next?” one of three ways — and each answer trades control for autonomy differently.

Centralized control
A supervisor decides.
One agent — model, rule, or hierarchy — picks who works next. Every handoff passes through the centre.
Trade-offClean control plane and a single end-to-end trace, in exchange for a single point of coordination, failure, and privacy exposure.
- Supervisor
- Hierarchical
- Magentic
- Agents-as-Tools
- Graph-based
Decentralized handoff
Peers route directly.
No coordinator. Specialists hand off via named edges or local rules; the execution path emerges at runtime.
Trade-offMaximum autonomy and no central bottleneck, at the cost of a trace that is hard to reconstruct when something goes wrong.
- Handoff
- Swarm
Shared workspace
Agents share a common space.
A blackboard, shared conversation, or market mediates work. Specialists read and write the surface; coordination is by what is on it, not by who said what to whom.
Trade-offStrong observability of state, weaker observability of causation. You can see what is true; not always who made it so.
- Blackboard
- Contract Net
- Group Chat
- Debate

What it runs on

How an L3 system holds together.

Multi-agent systems run on the L4 operational layer the same way single agents do — they just lean harder on the layers that handle memory partitioning, message transport, human approval, and trace stitching across specialists.

Memory Architecture
Conversational · Episodic · Semantic · Working
Memory Architecture
How conversation history, completed episodes, and long-term knowledge are stored and retrieved per agent and per session.
Why for L3L3 systems leak across sessions without it. The choice between shared scratchpad and per-agent state is decided here.
See in L4
A2A Protocol
Agent-to-Agent · Cross-Framework Messaging
Tool Integration
An open protocol from Google (2025) for agents in different frameworks to discover each other and exchange messages.
Why for L3The Handoff and Swarm patterns become portable once A2A handles the transport. Without it, every cross-framework handoff is custom.
See in L4
HITL Gate
Human-in-the-Loop · Approval Step
Governance & Safety
A node that pauses for human review before the next specialist acts. Pause can last seconds or weeks.
Why for L3L3 systems make autonomous decisions about who works next. HITL is where a human signs off on those decisions before they cascade.
See in L4
Distributed Tracing
Agent Tracing · Run Trees · Span Trees
Observability & Evaluation
Every handoff, tool call, and message recorded as a span in a single trace tree across all specialists.
Why for L3Without it, a multi-agent failure is archaeology. Trace legibility is the difference between debuggable L3 and an L3 you can only rerun.
See in L4

Patterns · 12 on this rung

12 coordination patterns on this rung.

Each card is a recurring answer to "who decides who works next?" Scan use-when / don't / trade-off; open one to deep-dive.

Centralized control

A single decider — or a developer-wired graph — routes the work.

Supervisor
aka Manager Agent · Coordinator Agent · Central Controller
Open
A central agent dynamically decides which specialized agent or tool works next.
Use when
- Central control and traceability are essential.
- Multiple specialists must be coordinated.
- Tasks are dynamically delegated.
Don't
- Fully decentralized cooperation is needed.
- The supervisor risks becoming a single point of failure.
- Delegation is static enough for simple routing.
Trade-off
Clear operational control is maintained at the cost of a potential coordination bottleneck.
LangGraphCrewAIMicrosoft Agent FrameworkGoogle ADK+1
Anthropic (2024) — Building Effective Agents § Orchestrator-Workers
Hierarchical Supervisor
aka Multi-Level Supervisor · Manager Hierarchy · Hierarchical Teams
Open
Multiple supervisors organize agents in hierarchical layers, delegating responsibility for larger teams or complex domains.
Use when
- The number of agents is large.
- Domains must be organized into sub-teams.
- Local decisions need to be aggregated centrally.
Don't
- A small number of agents suffices.
- Communication paths must remain short.
- Responsibilities cannot be cleanly separated.
Trade-off
Scalable organizational structure is achieved against higher complexity and longer decision paths.
CrewAILangGraphGoogle ADKMicrosoft Agent Framework
Wu et al. (2023) — AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation
Magentic
aka Magentic-One Style Orchestration · Generalist Multi-Agent Team
Open
An orchestra of specialized agents combines planning, a task ledger, delegation, and replanning for long-running, complex goals.
Use when
- Tasks are open-ended, multi-step, and tool-intensive.
- Multiple specialists must operate with high autonomy over long horizons.
Don't
- A simple workflow suffices.
- Auditability requires deterministic steps.
- Operating costs are strictly limited.
Trade-off
Massive task coverage is gained against exceptionally high operational and orchestration complexity.
Microsoft Agent FrameworkAutoGen / AG2LangGraph
Fourney et al. (2024) — Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks
Agents-as-Tools
aka Agent Tools · Callable Agents · Specialist-as-Tool
Open
One orchestrating agent calls other agents exactly like tools, hiding their internal logic and coordination behind a standard tool interface.
Use when
- Specialists must be encapsulated.
- The main agent must retain absolute control.
- Security boundaries must be strictly separated.
Don't
- Equal cooperation is needed.
- Specialists require long-term autonomy.
- Interface contracts are unstable.
Trade-off
Excellent encapsulation is achieved against limited independence for the sub-agents.
AWS StrandsOpenAI Agents SDKLangGraphMicrosoft Agent Framework+1
OpenAI (2024) — Agents SDK § Tools and Handoffs
Graph-based Orchestration
aka Agent Graph · State Graph Orchestration
Open
Agent coordination, tools, and state transitions are modeled as an explicit, executable state graph consisting of nodes and edges. It composes the two workflow relaxations — conditional edges (Routing) and bounded cycles (Loop) — over a closed node set with a validated state schema.
Use when
- Coordination must be completely traceable and testable.
- Complex flows involving cycles and strict conditions must run stably in production.
Don't
- A linear workflow is sufficient.
- Graph maintenance outweighs the benefits.
- Autonomous emergence is preferred over explicit control.
Trade-off
Extreme predictability and controllability are gained against significant modeling overhead.
LangGraphAWS StrandsMicrosoft Agent FrameworkGoogle ADK
Zhuge et al. (2024) — GPTSwarm: Language Agents as Optimizable Graphs
Exploration & Discovery
aka Deep Research · Research Agent · Deep Research Agent
Open
A research agent maps a knowledge space, clusters findings, selects leads by novelty, impact, and feasibility, deep-dives into the promising ones, and synthesizes a cited report — coordinated as an orchestrator over parallel search and subtopic agents.
Use when
- The task is open-ended research, competitive analysis, or literature / R&D synthesis across many sources.
- Breadth and novelty matter more than a single lookup.
- Findings must be synthesized and cited, not just retrieved.
Don't
- The answer is a bounded lookup or a single retrieval.
- Cost and latency budgets are tight — this pattern is resource-intensive.
- The knowledge space is small enough for one pass.
Trade-off
Breadth, novelty, and synthesis quality are gained at a high token and latency cost; it needs strong stopping criteria to avoid unbounded exploration.
LangGraphOpenAI Deep ResearchPerplexity / Gemini Deep Research
Anthropic (2025) — How we built our multi-agent research system

Decentralized handoff

Peers route to each other without a central authority.

Handoff
aka Transfer of Control · Agent Transfer · Delegated Turn
Open
An agent completely transfers control and relevant context to another specialist.
Use when
- Responsibility clearly shifts between specialists.
- User interactions must switch to the appropriate agent.
- Security boundaries apply per agent.
Don't
- Multiple agents must contribute simultaneously.
- Control must remain with a central supervisor.
- Context transfer cannot be reliably bounded.
Trade-off
Clear transfer of responsibility is achieved at the risk of losing vital context during the handoff.
OpenAI Agents SDKMicrosoft Agent FrameworkLangGraphGoogle ADK
OpenAI (2024) — Swarm: Lightweight Multi-Agent Orchestration
Swarm
aka Decentralized Agents · Peer Agent Swarm · Emergent Coordination
Open
Agents coordinate decentrally via local rules, messages, and handoffs, allowing the execution path to emerge at runtime.
Use when
- Decentralized exploration is desired.
- Tasks can be adaptively distributed.
- Central control would be too rigid.
Don't
- Strict traceability is required.
- Message floods must be prevented.
- Clear accountability outweighs emergent behavior.
Trade-off
High adaptability is gained at the cost of lower predictability and difficult debugging.
LangGraphAWS StrandsMicrosoft Agent FrameworkAutoGen / AG2
OpenAI (2024) — Swarm: Lightweight Multi-Agent Orchestration

Shared workspace & markets

Coordination through a shared workspace, conversation, or bidding mechanism.

Blackboard
aka Shared Workspace · Blackboard Architecture · Shared State Coordination
Open
Agents coordinate indirectly via a shared state surface where results, hypotheses, and tasks are deposited rather than using direct chat.
Use when
- Many agents contribute asynchronously.
- Shared state is more important than direct conversation.
- Intermediate results must remain persistent.
Don't
- Strict linear control is required.
- State consistency cannot be guaranteed.
- A simple chat context suffices.
Trade-off
Highly decoupled collaboration is achieved against demanding state management and consistency requirements.
LangGraphAWS StrandsMicrosoft Agent FrameworkAutoGen / AG2
Engelmore & Morgan (1988) — Blackboard Systems
Contract Net
aka Task Bidding · Auction-based Agents · Price-based Coordination
Open
Coordination occurs via bidding or price signals, where an agent broadcasts a task and others bid based on their capabilities, cost, or utility.
Use when
- Tasks must be distributed dynamically.
- Agents possess varying capacities or costs.
- Prioritization relies on utility signals.
Don't
- Delegation is fixed.
- Bidding creates more overhead than value.
- Compliance dictates strict rule-based allocation.
Trade-off
Scalable and flexible resource allocation is gained against the difficult design of incentive and auction structures.
LangGraphAutoGen / AG2AWS Strands
Smith (1980) — The Contract Net Protocol
Group Chat
aka Multi-Agent Chat · Round-Robin Conversation · Shared Conversation
Open
Agents communicate in a shared conversation space, building upon each other's inputs in a round-robin, random, or simultaneous manner.
Use when
- Perspectives must be visibly merged.
- Discussion is part of the solution process.
- Roles need to interact flexibly.
Don't
- A deterministic flow is required.
- The token budget is heavily restricted.
- Responsibilities must remain strictly isolated.
Trade-off
Rich interaction is gained against high token costs and difficult flow control.
AutoGen / AG2Microsoft Agent FrameworkGoogle ADKLangGraph
Wu et al. (2023) — AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation
Multi-Agent Debate
aka Debate · Adversarial Agents · Deliberation
Open
Agents represent different positions and critically negotiate outcomes before a final decision is synthesized.
Use when
- The problem allows for controversial assessments.
- Counterarguments help expose logical flaws.
- Decisions require rigorous verification.
Don't
- Facts are easily verifiable.
- Debate would create artificial conflicts.
- Latency budgets are tight.
Trade-off
Rigorous verification of difficult decisions is achieved against increased effort and the risk of over-arguing.
AutoGen / AG2LangGraphMicrosoft Agent FrameworkGoogle ADK
Du et al. (2023) — Improving Factuality and Reasoning in Language Models through Multiagent Debate

Anti-patterns

Ways this rung goes wrong.

#06
God Orchestrator
SymptomSingle point of coordination, single point of failure, single point of privacy exposure.
FixA thin hub with strong specialists. Keep the orchestrator's prompt and tools small; push work into specialists.
- supervisor
#07
Cascading Security Failures
SymptomA poisoned doc in a shared index contaminates every downstream consumer. Prompt injection propagates via handoffs.
FixTreat every agent-to-agent message as a trust boundary. Partition knowledge bases by trust level.
#02
Hidden State in Prompts
from L1
SymptomBehaviour drifts over long conversations. Bugs reproduce only intermittently.
FixPydantic v2 state at every node boundary. Forbid extra attributes. State belongs in code.
#04
Tool Explosion
from L1
SymptomTool selection accuracy collapses. The model hallucinates calls and parameter names.
FixLeast privilege per role. Gate large catalogues behind a Tool Registry plus capability routing.

Frameworks

What you build this on.

LangGraphpython

from langgraph.graph import StateGraph, END

def supervisor(state):
    # LLM picks the next agent by name — or "done"
    choice = llm.choose_next(
        history=state["messages"],
        options=["shipping", "refunds", "tech", "done"],
    )
    return {"next": choice}

graph = StateGraph(State)
graph.add_node("supervisor", supervisor)
graph.add_node("shipping", shipping_agent)
graph.add_node("refunds", refunds_agent)
graph.add_node("tech", tech_agent)

graph.add_conditional_edges("supervisor",
    lambda s: s["next"],
    {"shipping": "shipping", "refunds": "refunds",
     "tech": "tech",   "done": END})

# Each specialist returns control to the supervisor:
for spec in ["shipping", "refunds", "tech"]:
    graph.add_edge(spec, "supervisor")

graph.set_entry_point("supervisor")

Deep dive

Who decides who works next?

The defining question of L3 is coordination, not capability. Each specialist can do its job; the system's behavior depends on how they're sequenced and what they share. Three canonical answers recur: centralized (a supervisor or hierarchy decides handoffs), decentralized (peers hand off directly via named edges or self-organizing rules), and shared workspace (a blackboard, shared conversation, or market where agents post and consume work). They differ in where the single point of failure lives and how legible the resulting trace is.

The choice is rarely about technology and almost always about which failure mode you can tolerate. A supervisor gives you a clean control plane and a single bottleneck. A swarm gives you no bottleneck and no clear story when something goes wrong. A blackboard gives you observability of state at the cost of observability of causation. Pick by which question you most need to answer at 2am.

You outgrow L3 when the next failure is operational, not coordinational — a memory bleed across sessions, a runaway loop you can't checkpoint out of, a missing trace that turns triage into archaeology. At that point the question stops being "who decides who works next" and starts being "how does the system run on Tuesday." That is L4.

The mirror image sits one rung down. Orchestrator-Workers (L2) also has a central node that delegates — but there the fan-out is an authored code structure over ephemeral workers. What makes Supervisor L3 is that the coordinator is itself a persistent agent routing persistent specialists, and which agent works next is decided at runtime, not drawn as an edge in advance.

When to climb

The next failure you can't debug is operational.

Coordination works — but memory bleeds across sessions, a loop runs away, a trace is missing, a tool leaks. Those aren't coordination bugs; they're the operational layer every rung was already standing on. That layer is L4.

Climb to L4 — Production

References

Where this rung was first written down.

1980Smith — The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver
1988Engelmore & Morgan — Blackboard Systems
2009Wooldridge — An Introduction to MultiAgent Systems (2nd ed.)
2023Wu et al. — AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversationsource
2023Du et al. — Improving Factuality and Reasoning in Language Models through Multiagent Debatesource
2023Liang et al. — Encouraging Divergent Thinking in Large Language Models through Multi-Agent Debatesource
2023Hong et al. — MetaGPT: Meta Programming for a Multi-Agent Collaborative Frameworksource
2024Fourney et al. — Magentic-One: A Generalist Multi-Agent System for Solving Complex Taskssource
2024Anthropic — Building Effective Agentssource

Specialists. Who decides who works next?

A supervisor decides.

Peers route directly.

Agents share a common space.

Memory Architecture ★

A2A Protocol

HITL Gate

Distributed Tracing

The next failure you can't debug is operational.

Search

Memory Architecture