What you'll learn
When a task is too big or too varied for one agent, you can split it across several specialized agents — a planner that delegates, workers that each handle a piece, a critic that checks the result. Powerful, but easy to over-build. This module covers the patterns and, just as importantly, when a simple workflow beats a crowd.
By the end of this module you'll be able to:
- Explain when splitting into multiple agents helps
- Describe the planner / worker / critic roles
- Recognize common orchestration patterns
- Choose between a fixed workflow and autonomous agents
Why split into multiple agents
The same logic as decomposition (Module 11), one level up: a single agent juggling many kinds of work spreads itself thin, and its context fills with unrelated detail. Separate agents each get a focused role, their own tools, and a clean context — which usually means higher quality per piece and a system that's easier to reason about.
Planner, worker, critic
Most multi-agent systems are variations on three roles:
- Planner (orchestrator): breaks the goal into tasks and routes each to the right worker.
- Workers (specialists): each focused on one job — research, code, write — with just the tools it needs.
- Critic (reviewer): checks quality against the requirements — the reflection idea (Module 13) as its own agent.
Orchestration patterns
How the agents connect defines the system:
| Pattern | How it works | Good for |
|---|---|---|
| Pipeline | Agents in a fixed sequence, output → input | Well-understood, ordered stages |
| Orchestrator-workers | A planner delegates tasks to workers, then combines | Tasks that vary per request |
| Debate / critic | One agent produces, another critiques and it revises | Quality-critical output |
| Router | A classifier sends each request to a specialist | Mixed request types |
Workflows vs. autonomous agents
A key distinction: a workflow connects models and tools along paths you defined; an autonomous agent decides the paths itself. Workflows are predictable, testable, and cheaper — they cover the majority of real needs. Reserve full autonomy for tasks whose steps genuinely can't be known ahead of time.
Key idea
Cost, latency & failure modes
Multi-agent systems multiply everything — including the downsides:
- Cost & latency: every agent is more model calls; several in sequence can be slow and pricey.
- Error propagation: a bad hand-off early poisons everything downstream — validate between agents.
- Coordination overhead: agents can misunderstand each other; keep hand-offs structured (Module 14).
- Debugging difficulty: more moving parts means more places to inspect when something goes wrong.
Watch out
Recap & quick check
Key takeaways
- Split into multiple agents when one agent is stretched thin — each gets a focused role, its own tools, and a clean context.
- The common roles are planner (delegates), workers (specialists), and critic (reviews the result).
- Orchestration patterns include pipelines, orchestrator-workers, debate/critic, and routers — often combined.
- Workflows follow paths you defined (predictable, cheaper); autonomous agents choose their own paths — use autonomy sparingly.
- More agents multiply cost, latency, error propagation, and debugging difficulty — prefer the simplest design that works.
Quick check
1. When does splitting a task across multiple agents help most?
2. What does the 'critic' role do?
3. What's the difference between a workflow and an autonomous agent?
4. What's the recommended default when designing these systems?
You can now build systems that reason and act. The last two phases make them trustworthy and put them to work — starting with how to measure whether a prompt is any good. Next up: Phase 7, Module 26 — Evaluating & Testing Prompts.