Agentic Design Patterns: Reflection, Planning, and Routing
The handful of reusable patterns behind most successful agents — reflection, planning, routing, tool use, and delegation — and how to pick the right one.
Look inside enough successful agents and you start seeing the same few moves again and again. The agent drafts something, then critiques it and tries again. It writes a plan before touching anything. It sorts incoming requests and sends each one down a different path. It hands a messy chunk of work to a helper and gets back a clean summary. None of this is magic, and none of it depends on a particular framework. These are design patterns: reusable solutions to problems that every agent builder runs into.
Knowing the patterns by name gives you two superpowers. When an agent is failing, you can diagnose which missing pattern would fix it. And when you're designing a new one, you can assemble it from proven parts instead of inventing from scratch. In this lesson you'll learn the five core patterns (tool use, reflection, planning, routing, and delegation), see a working reflection loop in code, and get a practical guide to picking and combining them without overbuilding.
Where these patterns come from
Two pieces of writing shaped how most practitioners talk about agent design, and they're worth knowing.
In March 2024, Andrew Ng, the AI educator and founder of DeepLearning.AI, popularized a framing of four agentic design patterns in a series of letters in his newsletter, The Batch: reflection (the model critiques and improves its own work), tool use, planning, and multi-agent collaboration. His point was that wrapping a model in these patterns could improve results more than simply switching to a bigger model.
In December 2024, Anthropic published "Building effective agents", based on its work with teams building agents in production. It describes a basic building block, the augmented LLM (a model with access to retrieval, tools, and memory), and a set of workflow patterns built from it: prompt chaining, routing, parallelization, orchestrator–workers, and evaluator–optimizer. Its central advice is the one you met in Agents vs. Workflows: start with the simplest thing that works, and add complexity only when it measurably helps.
The two framings overlap heavily. This lesson uses five patterns that cover both:
| Pattern | The problem it solves | Ng's framing | Anthropic's framing |
|---|---|---|---|
| Tool use | The model can't see or change anything outside its context | Tool use | The augmented LLM |
| Reflection | First drafts have mistakes the model could catch | Reflection | Evaluator–optimizer |
| Planning | Complex tasks go off course without a roadmap | Planning | Orchestrator–workers (dynamic task breakdown) |
| Routing | Different inputs need different handling | (implicit) | Routing |
| Delegation | One context can't hold all the work, or work can run in parallel | Multi-agent collaboration | Orchestrator–workers, parallelization |
The previous lesson placed these on a ladder of autonomy. This one treats them as building blocks: what each one does, when it earns its place, and how they fit together.