AGENTIC ARCHITECTURE
Agent Design Patterns
The composable building blocks behind production agent systems — from simple prompt chains to orchestration, reflection and multi-agent coordination.
Agent Design Patterns Learning Path
Follow the modules in order to move from why patterns exist to routing, planning, reflection, multi-agent coordination and choosing the right pattern for production systems.
Why Agent Design Patterns Exist
Why the most successful production agent systems in 2026 aren't built on complex frameworks but on simple, composable patterns — the real research finding that started this field, and why patterns, frameworks, and protocols are three genuinely different things.
Prompt Chaining and Sequential Pipelines
The simplest agent design pattern — breaking one task into staged LLM calls with validation gates between them. Real 2026 benchmark data showing exactly when chaining wins, when it loses, and the honest cost overrun risk of overusing it.
The Routing Pattern
Classifying a request before deciding how to handle it — five real routing strategies, a real research result improving accuracy and cutting latency simultaneously, and an honest failure story about routing costing more than no routing at all.
The Parallelization Pattern
Running independent subtasks simultaneously instead of one after another — a real research finding more than doubling accuracy through parallel attempts alone, a concrete rate-limit failure story, and why naive aggregation quietly breaks on long-horizon tasks.
The ReAct Pattern
The reasoning-acting loop that made tool-using agents practical — its real 2022 research origin, a fully quantified real production case study showing exactly where it succeeds and where it degenerates, and the three named failure modes worth designing against.
The Plan-and-Execute Pattern
Separating the thinking from the doing — three real, academically-cited variants, a precise benchmark showing exactly how badly stale plans degrade accuracy, and the real fix that took a production refund agent from 87% to 95% clean resolution.
The Reflection Pattern
Teaching an agent to critique its own work before shipping it — the precise, quantified cost of each reflection iteration, an exact diminishing-returns curve, and the honest structural bias that makes self-critique fundamentally different from independent review.
The Evaluator-Optimizer Pattern
Replacing subjective self-critique with an objective quality gate — Anthropic's own primary guidance on when this pattern fits, and the honest research finding that even test-passing code can still be genuinely wrong.
The Iterative Refinement Pattern
The honest relationship between this pattern and the two you just learned — real academic lineage showing Evaluator-Optimizer is literally 'the multi-agent generalisation' of the same underlying idea, plus Reflexion's genuinely distinct addition of episodic memory.
The Orchestrator-Workers Pattern
The other pattern Anthropic's own research names as top-tier — confirmed running inside Anthropic's own production Research system, a real dated 2026 product built on it, and the precise three-term cost formula that makes it the most expensive pattern in this course.
The Supervisor Pattern
The genuinely confused terminology around Supervisor, Router, and Orchestrator, addressed honestly — real cost comparison data, a concrete rule for when NOT to build one first, and the actual test that distinguishes them.
The Handoff Pattern
Genuinely transferring ownership of a conversation, not just delegating a subtask — grounded in OpenAI's official Agents SDK, where a handoff is literally implemented as a tool call, plus the real distinction between handoff and delegation.
The Agents-as-Tools Pattern
Hiding a specialist agent's entire internal loop behind a simple tool interface — a real source-code comparison across five named coding agent products, and the precise three-way test for choosing between this pattern, a handoff, and a plain function.
The Map-Reduce Pattern
Processing genuinely large volumes of independent data at scale — a real, dated production deployment achieving 97% automation and an estimated 70% FTE reduction, the honest limitation of naive chunking, and a genuinely fresh security benefit this pattern provides.
The Planner-Executor-Reviewer Pattern
A real composition of two patterns you already know — Plan-and-Execute plus Evaluator-Optimizer — and the honest reveal that your Multi-Agent Systems coursework's recurring example was exactly this composition all along.
The Generator-Critic Pattern
The critic's own fallibility, examined in depth — five precisely measured LLM-judge biases, a real narrative production failure where a silent judge-model version bump corrupted a CI gate for months, and why stronger models show more self-preference bias, not less.
The Multi-Agent Debate Pattern
Rigorous, peer-reviewed proof that debate alone doesn't improve expected correctness — and the precise condition, confirmed by a real controlled experiment, that determines whether adding agents helps dramatically or drives accuracy below random chance.
The Voting and Consensus Pattern
The real theoretical foundation for why voting works, a formally proven and named phenomenon showing exactly when it breaks, and precisely measured evidence that role-prompted agents produce far less real diversity than they appear to.
The Hierarchical Agents Pattern
Layered manager-and-worker structures, with a real named company's blunt warning against building this too early, a technical explanation for why hierarchy genuinely scales, and a direct reconnection to this course's own measured collapse data.
The Blackboard Pattern
Coordinating agents through shared state instead of direct messages — a precise real illustration of the stale-read hazard, a named open-source implementation's propose-validate-commit mechanics, and concrete production guidance on locking.
The Event-Driven Agents Pattern
Agents reacting to asynchronous events rather than direct calls — grounded in a genuine distributed-systems theorem explaining why exactly-once delivery is impossible, a detailed real production case study on deduplication, and a real patent on AI agent event architecture.
The Human-in-the-Loop Pattern
Pausing an agent for genuine human approval before high-stakes actions — real regulatory grounding from the EU AI Act, a concrete five-category escalation protocol, and the honest warning that human oversight can silently degrade into rubber-stamping.
The Fallback and Recovery Pattern
What happens when the primary strategy fails — grounded in a real distributed-systems origin, precise retry-count data from real production systems, and the honest, memorable warning that the worst AI failures arrive with a confident tone and a 200 status code.
The Checkpoint and Resume Pattern
Why a genuinely durable agent needs more than saving state — a precise four-guarantee framework distinguishing real durable execution from mere checkpointing, and a real, current statistic showing why this infrastructure dominates production agent codebases.
The Bounded Agent Loop Pattern
Why 'continue until solved' is dangerous production architecture — a precise, dated real incident where two agents ping-ponged for 11 days and burned $47,000, and the architectural principle that budget enforcement has to live outside the agent entirely.
Memory and State Patterns
The architectural decisions behind agent memory, not what memory is — a real, current production system's ephemeral/persistent split, the fails-open-versus-fails-closed security principle, and the honest deletion problem most memory systems get wrong.
Pattern Composition
How production systems actually combine multiple patterns into one architecture — a real, precise cost-accuracy-latency matrix across three patterns, a real named company's 6x speedup from composition, and the honest warning about trusting an agent's own self-reported confidence.
Choosing the Right Agent Pattern
The final module: a complete decision framework synthesizing all twenty-seven patterns in this course, four worked scenarios, and this course's closing principle — there is no best agent design pattern, only the pattern that fits a specific problem's real requirements.
WHY PATTERNS?
Production agent systems are built on simple, composable patterns
Instead of complex frameworks, the most reliable agent systems combine a small set of well-understood patterns — chaining, routing, reflection, orchestration — to control cost, latency and failure modes while solving real problems.