Multi-Agent Architectures
There's no single "multi-agent" design — there's a toolbox of architectures, each with a shape that fits some problems and breaks on others. Learn the five that matter, and how to pick.
🎯 By the end you'll understand
The five core multi-agent architectures — orchestrator–worker, pipeline, hierarchical, blackboard, and debate/critic — plus parallel fan-out/fan-in; how each is wired, what it's good and bad at, and a concrete example of each; and a practical guide for matching an architecture to the shape of your problem (with the honest caveat that you can combine them, and that simpler is almost always better).
KEY INSIGHTThe one idea to take away
"Multi-agent" isn't one design — it's a set of topologies. The skill isn't building agents; it's choosing the shape that fits the work.
In Lesson 2.7 you met the idea that one agent's tool can be another agent. That's the atom. This lesson is about the molecules: the recurring ways teams of agents get wired together. Each architecture is just a different answer to two questions — who decides what happens next, and how does work flow between agents.
Architecture is a shape that fits a problem, not a level you graduate to. A pipeline isn't "less advanced" than a hierarchy — it's the right answer when work is staged, and the wrong answer when it isn't. Pick by the shape of the task, not by sophistication.
FRAMEWORK1 · Orchestrator–worker — the workhorse
You already know this one from Lesson 4.8 and 2.7. A single lead agent — the orchestrator — receives the goal, decomposes it into sub-tasks, delegates each to a worker agent, then synthesizes the results into one answer. The orchestrator holds the plan; the workers hold the focus.
Good at: open-ended, decomposable tasks where you can't predict the sub-tasks in advance — the orchestrator figures out the breakdown at runtime. It's the default for a reason: flexible, and it subsumes most of the others.
Weak at: the orchestrator is a bottleneck and a single point of judgment — if its decomposition is bad, everything downstream is bad. It also adds a layer of cost (the lead agent's own loop), and it has to hold the whole plan in its context, so there's a ceiling on how big a job one orchestrator can manage before it starts losing track. That ceiling is exactly the problem the hierarchical architecture exists to solve.
"Produce a competitive briefing on three rivals." The orchestrator decides to spin up one researcher per rival, then a writer, then itself merges. The number and shape of workers is decided by the agent, not hard-coded.
FRAMEWORK2 · Pipeline / sequential — the assembly line
The simplest architecture there is. Output of agent A becomes input to agent B, whose output feeds C, and so on: research → write → edit. There's no orchestrator deciding anything — the wiring is the plan. Each stage does one transformation and passes the work along.
Good at: staged transformations with a known, fixed order — ETL-style flows, content production lines, anything where stage N genuinely needs stage N−1's output. It's cheap, predictable, and trivially easy to debug because you can inspect the hand-off between any two stages.
Weak at: errors cascade. A weak research bundle quietly poisons the writer, who poisons the editor — and because each stage trusts its input, nobody catches it. Pipelines are also rigid: if the work doesn't actually have a fixed order, you're forcing a shape that doesn't fit.
A blog-post factory: a researcher gathers facts → a writer drafts from those facts → an editor tightens prose and checks tone. Each runs once, in order, and hands its result forward.
FRAMEWORK3 · Hierarchical — managers of managers
Take orchestrator–worker and make it recursive. A top orchestrator delegates to mid-level managers, each of which is itself an orchestrator running its own little team. Teams of teams. The org chart can go several layers deep, with each layer decomposing its slice further.
Good at: genuinely huge decomposition — a task with so many sub-tasks that a single orchestrator's context would overflow just tracking them all. The hierarchy lets each manager hold only its own sub-tree. Think large codebases, multi-department workflows, big research programs.
Weak at: cost and latency explode. Every layer is another set of LLM loops, and the deepest worker's result has to travel all the way back up through every manager, each of which re-reads and re-summarizes. You also get "telephone game" distortion as intent passes down and results pass up.
"Migrate this 200-file service to a new framework." Lead splits by module → each module-manager splits by file → workers edit individual files and report up. Three layers, dozens of agents.
FRAMEWORK4 · Blackboard / shared-state — no boss
Here there's no central coordinator at all. Agents share a common workspace — a "blackboard" — that they all read from and write to. Each agent watches the board, and when it sees something it can contribute to, it does, writing its result back. Coordination is emergent: the shared state itself is the meeting point.
Good at: flexible, open-ended problems where you don't know in advance which agent will be useful when, and contributions build on each other opportunistically. It decouples agents — you can add or remove one without rewiring the others. (You'll go deep on shared state in Lesson 5.3.)
Weak at: coordination and conflicts. With no boss, two agents can overwrite each other's work, loop on the same sub-problem, or never converge. You need rules — locks, turn-taking, a "done" condition — or the board descends into chaos. It's the hardest to reason about and debug.
A collaborative design doc: a "requirements" agent, an "architecture" agent, and a "risk" agent all edit a shared spec, each reacting to what the others have added, until the doc stabilizes.
FRAMEWORK5 · Debate / critic — structured disagreement
One agent proposes an answer; a second is explicitly told "your job is to find what's wrong with this." The proposer revises; the critic challenges again; they iterate until the critic is satisfied or a round limit hits. This is reflection (Lesson 2.6) and review (Lesson 3.6) split across two agents — so the critic isn't grading its own homework.
Good at: judgment-heavy tasks where quality matters more than speed — arguments, plans, risky decisions, anything where a confident-but-wrong answer is costly. The adversarial pressure surfaces weak reasoning that a lone agent waves through.
Weak at: cost, and false comfort. Every round is another pair of LLM calls. Worse, debate does not guarantee correctness — two agents can confidently converge on the same wrong answer, and the polished back-and-forth can make a flawed conclusion feel rigorously vetted when it isn't.
"Is this legal clause enforceable?" A proposer argues yes; a critic hunts for counter-cases and ambiguity; after two rounds they hand a hedged, better-reasoned answer to the human.
COMPARISONAlso worth knowing: parallel fan-out / fan-in
Not quite a full architecture, but a pattern you'll reach for constantly — the agentic version of map-reduce. You fan out: split a task into independent chunks and run an agent on each at the same time. Then you fan in: a single step collects and merges all the results. It's usually the inside of an orchestrator–worker's delegate step, but it's worth naming because parallelism is where multi-agent systems earn back their latency cost.
If chunk B needs chunk A's output, you don't have a fan-out — you have a pipeline. The whole speed win comes from the pieces not depending on each other. Force-parallelizing dependent work just creates bugs.
Example: "Summarize these 40 documents." Fan out 40 summarizer agents in parallel; fan in one agent to merge the summaries into a single digest. Forty steps that would've been sequential collapse into roughly the time of one. The fan-in step is where the real work hides — a naive merge just concatenates, but a good one de-duplicates, resolves contradictions between chunks, and ranks what matters. Notice this is the same skeleton as orchestrator–worker; fan-out/fan-in is what that architecture's delegate-and-synthesize loop looks like when the sub-tasks happen to be independent.
SEE ITArchitecture Explorer
Pick an architecture. The diagram redraws to show its topology, and the readout below tells you how it works, what it's best for, where it's weak, and a concrete example. Everything here is hand-authored and deterministic — flip between them to feel how different the shapes really are.
PRACTICALChoosing one: match the shape to the problem
Don't start from "which architecture is best?" — there's no answer. Start from the shape of your problem and let it point at the architecture. Here's the decision the way an experienced builder actually makes it:
| Architecture | Best for | Main weakness | Example |
|---|---|---|---|
| Orchestrator–worker | open-ended, decomposable jobs; sub-tasks unknown upfront | orchestrator is a bottleneck & single point of judgment | competitive briefing on N rivals |
| Pipeline | staged transformations with a fixed, known order | errors cascade silently down the line | research → write → edit |
| Hierarchical | very large decomposition; too big for one orchestrator | cost & latency explode; telephone-game drift | migrate a 200-file service |
| Blackboard | flexible work; who-helps-when isn't known upfront | conflicts, loops, hard to coordinate & debug | collaborative shared design doc |
| Debate / critic | judgment tasks where quality > speed | cost; can converge confident-but-wrong | "is this clause enforceable?" |
| Fan-out / fan-in | many independent chunks; need speed | useless if chunks depend on each other | summarize 40 documents |
Two honest truths that override everything in that table:
You can — and usually do — combine them. Real systems are hybrids. The research-report team from 2.7 is an orchestrator overall, with a parallel fan-out for research, a pipeline from research → writing, and a critic step at the end. Architectures are ingredients, not rival cuisines.
Simpler is almost always better. The most common architecture mistake is over-engineering: reaching for a three-layer hierarchy when a flat orchestrator–worker would do, or a debate loop when a single self-correcting agent (2.6) is plenty. Each layer and each agent is real cost, latency, and a new place to fail. Start with the simplest shape that could possibly work, prove it's not enough, then add structure.
Ask: Is the order of work fixed? → pipeline. Are the pieces independent? → fan-out. Does quality need an adversary? → debate. Is it open-ended but decomposable? → orchestrator–worker. Is it so big one boss can't track it? → hierarchical. Is contribution opportunistic with no clear order? → blackboard. When two fit, pick the simpler one.
WEAKNESSCommon mistakes to avoid
There's no universal best shape. Forcing every problem into your favorite pattern — pipelining open-ended work, or orchestrating a strictly linear flow — fights the task instead of fitting it. Match the architecture to the shape of the problem, every time.
Don't reach for managers-of-managers when a single orchestrator–worker suffices. Each extra layer multiplies cost, latency, and intent-drift. Add a layer only when one orchestrator provably can't track all the sub-tasks — not because a deep org chart feels impressive.
It doesn't. A critic raises quality on judgment tasks, but two agents can confidently agree on something wrong — and the polished back-and-forth can make a flawed answer feel rigorously vetted. Debate reduces certain errors; it never certifies correctness. Keep a human in the loop for high-stakes calls (Stage 3).
KEY INSIGHTWhere this connects in your course
- Multi-agent systems (2.7) — the atom this lesson builds on: one agent's tool can be another agent. These architectures are the molecules.
- Choosing the right tool (4.8) — the "one agent or many, and which shape?" decision is a real architecture choice with a real bill.
- Reasoning & self-correction (2.6) — the debate/critic architecture is reflection split across two agents.
- Reviewing agent work (3.6) — the critic role is structured review, applied agent-to-agent instead of human-to-agent.
- Roles, communication & shared state (5.3) — next up: how agents in these topologies actually pass messages and share the blackboard.
- Build it in code (5.4) — you'll implement the orchestrator-worker + critic shapes from this lesson as one runnable program. (Each architecture's signature failure mode ties back to 2.9.)
Hold the frame: architecture = who decides next + how work flows. Five shapes, one fan-out pattern, infinite hybrids — and the real skill is picking the simplest one that fits.
GLOSSARYKey terms introduced
- Orchestrator–worker
- A lead agent decomposes a goal, delegates sub-tasks to worker agents, and synthesizes their results. The flexible default architecture.
- Pipeline
- Agents chained in a fixed order, each one's output feeding the next (research → write → edit). The wiring is the plan; no coordinator.
- Hierarchical
- Recursive orchestration — managers of managers, teams of teams — for decomposition too large for a single orchestrator to track.
- Blackboard / shared-state
- Agents read from and write to a common workspace with no central boss; coordination emerges from the shared state.
- Debate / critic
- One agent proposes, another challenges, and they iterate — structured disagreement that raises quality on judgment tasks.
- Fan-out / fan-in
- The agentic map-reduce: split a task into independent chunks run in parallel (fan-out), then merge the results in one step (fan-in).
- Topology
- The shape of a multi-agent system — who decides what happens next and how work flows between agents. Architecture is a choice of topology.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1What's the core difference between a pipeline and an orchestrator–worker system?›
In a pipeline the order is fixed and baked into the wiring — A → B → C — with no agent deciding the plan. In orchestrator–worker, a lead agent decides at runtime how to decompose the goal, who does what, and how to merge results. Pipeline = fixed structure; orchestrator = dynamic decomposition.
2When is a hierarchical architecture actually justified over a flat orchestrator–worker — and what does it cost you?›
Only when the decomposition is so large that a single orchestrator can't even track all the sub-tasks in its context — then sub-managers each hold their own sub-tree. The cost: every layer adds LLM loops (cost and latency explode), and intent/results drift as they pass up and down (telephone game). If one orchestrator can manage it, don't add layers.
3Why doesn't a debate/critic architecture guarantee a correct answer?›
Because two agents can confidently converge on the same wrong answer — shared blind spots don't get challenged. And the polished back-and-forth can make a flawed conclusion feel rigorously vetted. Debate raises quality on judgment tasks and catches some confident-but-wrong errors, but it certifies nothing. High-stakes calls still need a human.
4A teammate proposes a three-layer hierarchy for a job that's "research, then write, then review." What would you say?›
That's a pipeline, not a hierarchy — the work has a fixed three-stage order and no need for managers decomposing sub-tasks. A hierarchy here just adds cost, latency, and failure modes for zero benefit. Pick the simplest shape that fits the problem; a hierarchy is for decomposition too big for one orchestrator, which this isn't.