Loading...
System Design and AI Engineering, by Roni Das. 972 interactive lessons.
Start LearningAI Engineering · Intermediate · LLM and GenAI Ops
Reusable ways to structure an AI agent's work, such as ReAct, plan-and-execute, reflection and multi-agent setups. Each trades extra model calls for a chance at a better answer.
In short
Agentic design patterns are reusable ways to arrange an AI agent's work, such as tool use, ReAct, plan-and-execute, reflection, decomposition and multi-agent teams. Each one costs extra model calls, and each one only pays when the task has the shape it was built for.
In short
Agentic design patterns are reusable ways to arrange an AI agent's work, such as tool use, ReAct, plan-and-execute, reflection, decomposition and multi-agent teams. Each one costs extra model calls, and each one only pays when the task has the shape it was built for.
This page is the free part.
₹999 in India$49 everywhere elseonce, for the whole course
The AI Engineering course covers Agentic Design Patterns across a run of lessons, not one page. These 4 alone are about 230 minutes of step-by-step reading, every one with code you run in the browser, all with a quiz.
Self-critique alone barely helps and can hurt. Reflection works against a real check, and decomposition turns one long chain into short verified segments.
ReAct reasons before every action and pays for it; plan-and-execute thinks once and runs cheap. When each wins, and why replan-on-failure is the default.
Organize agent threats with the OWASP LLM Top 10 and Agentic guides, then red-team your own agent and run it as an attack-success-rate eval in CI.
One agent with good tools is the right default. When a team of agents actually helps, why adding agents usually lowers reliability, and the decision rule.
all part of
AI Engineering
203 lessons · about 209 hours · 10 free to read
₹999in India, by UPI
$49everywhere else, by PayPal
pay once,
yours for life
An AI agent is a language model in a loop. It reads the goal, decides on an action, calls a tool, reads the result and decides again. A tool is any function the model can ask your code to run, such as a search, a database query or a file write.
A design pattern is a shape for that loop that people reuse because it solves a known problem. Software engineers have patterns like the cache or the queue. Agents have their own set.
Why do agents need patterns at all? Because agents fail in a very specific way. A task only succeeds if every step succeeds, so the step success rates multiply. The agent loop lesson shows how fast this hurts: twenty steps at 0.95 each succeed only about 36 percent of the time. Most agentic design patterns are answers to that one number.
Here are the patterns you will meet most often. Each line says what the pattern changes.
The first four decide the order of steps. Reflection and decomposition are different: they are improvement loops you wrap around whichever order you chose. The rest of this page is about those two, because they are where most teams waste money.
The most common way to add reliability is to bolt a second call onto the end: ask the model to review its own answer and fix mistakes. It feels careful. It roughly doubles the token bill. On the failures that matter, it usually changes nothing.
The reason is simple. The model reviews with the same knowledge it wrote with. If it did not know a retry policy was needed, it will not notice that the retry policy is missing. Huang et al. at Google DeepMind studied this and called the paper "Large Language Models Cannot Self-Correct Reasoning Yet". They found that self-correction with no outside feedback often fails to improve reasoning, and sometimes makes the answer worse.
Reflection works when the critique rests on an external signal. That is information the model does not have, such as a failing unit test. Reflexion (Shinn et al.) reported 91 percent on the HumanEval coding benchmark, above GPT-4's reported 80 percent. The evaluator in that loop was unit tests, not the model's opinion of its own code.
So split reflection into two parts. The critique is a judgement. The check is an objective signal that grounds the judgement. The version that holds up runs the check, feeds the exact error back, and caps the number of retries.
Based on a figure in the lesson Reflection and Decomposition: Making Agents Check Their Own Work.
"External signal" is a range, not a switch. The lesson ranks checks from strongest to weakest:
This also explains why Self-Refine (Madaan et al.) and Huang et al. are both right. Self-critique improves qualities the model can perceive. It struggles with hidden correctness, which is where reasoning errors live.
Decomposition changes how many steps must be right in a row. Take the twenty step task at 0.95 per step, about 36 percent end to end. Split it into four segments of five steps, with a check at each boundary. When a segment fails and the check catches it, only that segment is retried.
With a strong verifier that catches 90 percent of bad segments, the lesson's model lifts the task from about 36 percent to roughly 75 percent. It costs about 1.4 times the tokens. A failure caught at a boundary also retries five steps instead of twenty.
The lift lives in the catch rate, not in the act of adding a check. With a catch rate of zero, which is roughly what a self-opinion gives on correctness, task success stays at the baseline. You still pay for every gate. The lesson calls this reflection theater.
More splitting is not always better. Every boundary adds a verifier call, extra context, and one more place where the split itself can be wrong. In the lesson's second model, success peaks at around four or five steps per segment and falls after that. Token cost is lowest at that same point. Split at the natural checkable seams, and stop.
Start from the task, not from the pattern list. A few questions cover most cases.
Anthropic's "Building Effective Agents" gives the same general advice: start with the simplest pattern that works, and add structure only when the task needs it.
To run the verifier and over-splitting models yourself and see the lift appear and vanish, the Reflection and Decomposition lesson is the next step.
Reflexion on HumanEval
Reported 91 percent on the HumanEval coding benchmark with a reflection loop whose evaluator was unit tests, an external check, not the model's own opinion.
Anthropic's multi-agent research system
Anthropic reported it used about fifteen times the tokens of a normal chat, which is why it suits only high-value work such as deep research.
Cognition
Their write-up "Don't Build Multi-Agents" argues that splitting a task across agents loses nuance between them, and that writes should stay single-threaded.
It is a reusable way to structure an AI agent's loop so it solves a known problem. Examples are tool use, ReAct, plan-and-execute, reflection, decomposition and multi-agent orchestration. Each pattern trades extra model calls or extra structure for better reliability, lower cost, or both, but only on tasks with the right shape.
The planning pattern has the agent decide its steps before acting. In plan-and-execute, one planner call writes the whole plan and a cheaper executor runs it. In production it is usually paired with replan triggers, so the agent writes a new plan when a step fails or an observation contradicts the old one.
Only when the critique rests on an external signal, such as a test suite, a schema validator, a compiler or a real tool error. Without one, the model reviews its work with the same blind spots it had when writing, so self-correction on reasoning often does not help and can make the answer worse.
Start with one agent, good tools and the simplest loop that works. Add a plan when the path is knowable, add reflection where a real check exists, and decompose at seams you can verify. Add more agents only when the work splits into independent parallel parts.
Checked against these on .
AI Agent
A language model placed in a loop: it decides an action, calls a tool, reads the result, and repeats until done. The hard part is that per-step errors compound over many steps.
ReAct Agent
An AI agent that alternates reasoning and acting: it writes a thought, calls a tool, reads the result, and repeats until it can answer. ReAct is short for reason plus act.
Multi-Agent System
A design where more than one LLM-driven loop works on one task, each with its own context, usually coordinated by an orchestrator that hands out parts and merges the results. It adds token cost and handoffs that can fail.
Tool Calling
When a model emits a structured request to run a function, and an orchestrator executes it and feeds the result back. The model never runs anything itself, so the orchestrator validates every call.
RAG (Retrieval-Augmented Generation)
A pattern that retrieves relevant text from an external index and puts it in the model's prompt so the answer is grounded in current, verifiable facts rather than the model's memory.
Embedding
A list of numbers that represents the meaning of a piece of text, so that similar meanings sit close together in vector space. The same model must embed both the corpus and the query.
This page explains the idea. The "Reflection and Decomposition: Making Agents Check Their Own Work" lesson builds it up step by step, with diagrams. It is part of the AI Engineering course, which has 203 lessons. 10 of them are free to read. You pay once and keep it for life, with no subscription.
Open the Reflection and Decomposition: Making Agents Check Their Own Work lessoncourse 2
Take models from notebook to production, with labs on real models.