Loading...
System Design and AI Engineering, by Roni Das. 972 interactive lessons.
Start LearningAI Engineering · Intermediate · LLM and GenAI Ops
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.
In short
A ReAct agent is an AI agent that alternates reasoning and acting: it writes a short thought, takes one action such as a tool call, reads the result, and reasons again until the goal is met. The name means reason plus act, from Yao et al. (2022).
In short
A ReAct agent is an AI agent that alternates reasoning and acting: it writes a short thought, takes one action such as a tool call, reads the result, and reasons again until the goal is met. The name means reason plus act, from Yao et al. (2022).
This page is the free part.
₹999 in India$49 everywhere elseonce, for the whole course
The AI Engineering course covers ReAct Agent across a run of lessons, not one page. These 4 alone are about 247 minutes of step-by-step reading, every one with code you run in the browser, all with a quiz.
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.
Two small models, 60 requests, each offered 5 to 100 tools. Picking the right tool barely suffered until 100 tools, and look-alikes alone did no harm. The bigger problems were elsewhere: right choices written as broken JSON, valid calls that Ollama's chat API silently dropped, and replies that took 13 times longer with every tool on offer.
A model name is a spec sheet written in shorthand. Learn to decode publisher, family, version, parameter count, mixture-of-experts markers, post-training suffixes and numeric formats, and to predict from the name alone whether a model will fit on your GPU.
A filter that stops 95 percent of prompt injections still loses to twenty retries. The lethal trifecta is unsolved because detection is the wrong tool. Break it leg by leg instead.
all part of
AI Engineering
203 lessons · about 209 hours · 10 free to read
₹999in India, by UPI
$49everywhere else, by PayPal
You own this course
Continue with Agent Planning: ReAct vs Plan-and-Executepay once,
yours for life
An AI agent is a language model in a loop that can use tools. A tool is a function your code runs when the model asks, such as a web search, a database query or an API call.
A ReAct agent is one specific shape for that loop. Before every action, the model writes a short piece of reasoning, called a thought. Then it picks one action. Your code runs the action and returns the result, called an observation. The model reads the observation and writes its next thought.
The pattern comes from the paper "ReAct: Synergizing Reasoning and Acting in Language Models" by Yao et al. Its point is that the two halves help each other. Reasoning about what to do next leads to better actions. Seeing the result of an action corrects the reasoning.
One note on the name, because search results mix them up. ReAct is not React, the JavaScript library for building user interfaces. The two share only the spelling.
There are three states, and the loop cycles through them.
The loop stops when the model says the goal is met, or when a step cap or budget cuts it off. Always set that cap. A loop with no limit can run until the bill stops it.
Here is the strength in one example. The agent plans to call a search tool. The search returns nothing useful. On the next turn the model reasons about that empty result and tries a different query or a different tool. Nothing was committed in advance. The plan exists only one step ahead, and it is rebuilt from the latest evidence every time.
Adaptivity is not free. Two costs stack up.
First, the call count. A task of n steps needs n reasoning calls. Each one usually goes to a large, capable model, because the whole idea of ReAct is that a smart model reasons at every step.
Second, the growing context. The context is everything the model sees on a call. In ReAct, each call replays the whole transcript so far: every thought, action and observation. So the input tokens climb step after step. Late in a long task, one step reasons over far more text than the first step did, and pays full price to do it.
There is a latency cost too. Step k cannot start until the model has seen the result of step k minus one. So the steps run strictly one after another and cannot run in parallel.
Long transcripts also hurt quality, not just cost. A model reads a very full window worse than a short one. That effect is called context rot, and the context rot lesson measures it.
The same feature that makes ReAct adaptive makes it drift. Reasoning and acting share one stream, so a bad observation does not stay contained.
Picture a tool that returns a stale record, an ambiguous match, or an error message the model reads as data. In ReAct there is no separate plan to check that observation against. The model reasons forward from it. The flawed reasoning becomes part of the transcript, and the next step reasons from that.
On a three step task there is little room to drift. On a thirty step task, one misread observation early can send the rest of the run far from the goal, and nothing pulls it back. The model did not get worse. An improvised path simply has nothing to correct against.
The main alternative is plan-and-execute. One planning call writes the whole plan up front, as an ordered list of steps. Then a cheaper executor, often a smaller model, runs the steps with little or no reasoning. The plan is an object you can log, inspect, or reject before it touches anything.
The two shapes are mirror images. Whatever one is good at, the other is bad at.
Based on a figure in the lesson Agent Planning: ReAct vs Plan-and-Execute.
The lesson puts a price on the choice with a simple cost model. It counts one reasoning call as 1.00 and one cheap execution as 0.15. Those prices are made up for teaching. For a 12 step task, ReAct costs 12 calls. Plan-and-execute costs 2.8 when nothing goes wrong. Every time a step diverges from the plan, it must replan, which costs 1.9 calls in that model.
The two costs meet when about 40 percent of steps diverge. Below that, plan-and-execute is cheaper. Above it, the agent replans so often that reasoning at every step, which is ReAct, costs less. Swap in your own per-call prices and your own failure rate from logs before trusting the number.
Ask one question: how much of the path can you know before you start?
The choice is often made per step, not once. A rigid outer plan can contain one step, such as "find the cheapest compliant flight", that runs as a small ReAct loop inside because the search behaves unpredictably. For the wider family of patterns, see agentic design patterns.
To run the cost model and the plan-length math yourself, the ReAct vs Plan-and-Execute lesson is the next step.
LangGraph
Google's Gemini API documentation walks through building a ReAct agent from scratch with Gemini and LangGraph, the loop of thought, tool call and observation shown on this page.
Anthropic's Building Effective Agents
Advises starting with the simplest pattern that works. A ReAct loop is that simple starting point, and an upfront plan with replan triggers is the structure you add later.
No. ReAct stands for reason plus act and comes from a 2022 paper by Yao et al. on language model agents. React is a JavaScript library for building web interfaces. You can build a ReAct agent in any language, and it has nothing to do with React components.
Mostly for cost and long-task reliability. A ReAct agent makes one reasoning call per step, each replaying a growing transcript, and the steps cannot run in parallel. On long tasks a single bad observation can make it drift. Teams with predictable tasks move the known skeleton to plan-and-execute and keep ReAct for the steps that are truly exploratory.
Yes. It is still the default loop in most agent libraries because it is the simplest shape that adapts. It is the right choice for exploratory work where each observation changes the next action. What changed is that production systems usually wrap it in a plan with replan triggers instead of using it for everything.
ReAct makes a fresh reasoning call before every action, so it adapts at each step but pays for every step. Plan-and-execute makes one planning call up front and runs the steps with a cheaper executor, so it is cheaper and easier to audit, but it breaks when reality stops matching the plan unless replan triggers are added.
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.
Agentic Design Patterns
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.
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.
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.
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 "Agent Planning: ReAct vs Plan-and-Execute" 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 Agent Planning: ReAct vs Plan-and-Execute lessoncourse 2
Take models from notebook to production, with labs on real models.