ReAct is the short name for the paper that taught language models to think out loud and act on the world in the same breath. Before the ReAct paper, an LLM either reasoned (chain of thought) or it acted (called a tool), but it did not do both inside one loop. After it, the agent loop as we now know it, thought then action then observation, became the default shape of almost every agent framework shipped since. This explainer unpacks what the paper actually says, why it mattered, and how to read it without a research background.
The paper, titled ReAct: Synergizing Reasoning and Acting in Language Models, was posted to arXiv in October 2022 by Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao, a Princeton and Google Brain team. It was not the first work to give an LLM tools, and it was not the first to ask an LLM to reason step by step. What it did was show that doing the two together, interleaved, beats either one alone, and that the resulting trajectory is readable by a human in a way that pure chain of thought is not. That single result reframed agent design, and its imprint is still visible in every tool-using agent built today.
The problem ReAct solves
Start with the two things the paper is joining. Reasoning, here, means chain of thought prompting, the technique where you ask the model to spell out its intermediate steps before committing to an answer. Acting means the model emitting an external action, like calling a search API, running code, or moving a character in a simulated room. Both worked, and both had a known weakness.
Pure reasoning, on its own, hallucinates. Ask a model to reason through a factual question with no access to a knowledge source, and it will produce a fluent, confident, internally consistent chain of thought that lands on a wrong fact. The chain looks correct because the model wrote it, and there is nothing in the loop to check it against the world. The paper calls this out directly as hallucination and error propagation, where one early mistake cascades through every later step.
Pure acting, on its own, is brittle. A model that only emits actions has no scratchpad to plan, to remember what it already tried, or to recover when a tool returns something unexpected. It fires an action, reads a result, fires the next action, and has nowhere to record why. When the environment gets even slightly complicated, an acting only agent loses the thread.
The ReAct paper’s core claim is that these two failure modes are mirror images, and that the cure for one is the other. Reasoning gives the acting loop a place to plan and recover. Acting gives the reasoning loop a way to check itself against real evidence. Interleave them, and each covers the other’s blind spot.
Reasoning traces
The first half of the method is the reasoning trace. In ReAct a trace is a short natural language note the model writes to itself before, between, and after its actions. The model decides what it needs to find, records what it has learned, and notes what to do next, all in plain text that a human can read.
This matters for two reasons. The first is correctness. Because the trace is written down, the model can refer back to earlier steps instead of recomputing them, which cuts the error propagation that kills pure chain of thought. The second is interpretability. A ReAct trajectory reads like a person’s working notes, so when the agent gets an answer wrong, a human can read the trace and see exactly which step went sideways. You cannot do that with a model that emits only a final answer, and you can barely do it with a black box tool call.
The trace also gives the model a place to handle exceptions. If a search returns nothing useful, the model writes that down and pivots to a different query. If two sources disagree, it notes the conflict and looks for a tiebreaker. None of this requires any new machinery, just the instruction to write out the reasoning and the space to do it.
Acting on the world
The second half is the action. In ReAct, an action is any step where the model reaches outside its own weights to get information or change something. In the question answering experiments that means searching a simple Wikipedia API. In the interactive experiments it means issuing commands to an environment, like moving a virtual agent through a household in ALFWorld or navigating a mock shopping site in WebShop.
The payoff of acting is grounding. When the model is uncertain about a fact, it does not have to guess, it can look it up. When it reasons through a chain, each link can be checked against fresh evidence before the next one is drawn. This is what lets ReAct beat chain of thought on factual tasks. The reasoning is no longer free-floating, it is anchored to the world it is reasoning about.
The interleaving is what makes it work as a loop and not as a one-shot plan. The model writes a thought, takes an action, reads the observation, writes another thought, and repeats until it is ready to answer. Each turn is small, and the next turn is chosen in light of the previous observation. This is the structure that every modern agent loop, from research assistants to coding agents to browser automation, still follows in spirit.
What the ReAct paper actually measured
The paper ran the method across four benchmarks, and the split between them tells you what ReAct is good at. Two are knowledge tasks. HotpotQA is multi-hop question answering, where the answer requires stitching together facts from more than one document. FEVER is fact verification, deciding whether a claim is supported, refuted, or not enough information. On both, ReAct queries a simple Wikipedia API to ground each reasoning step.
On HotpotQA and FEVER the result is qualitative rather than a single headline number. The key finding is that ReAct overcomes the hallucination and error propagation that plague pure chain of thought, by interacting with the Wikipedia API instead of trusting its own recall. The trajectories it produces are human readable, which the paper frames as improved interpretability and trustworthiness, not just accuracy.
The other two benchmarks are interactive decision making tasks. ALFWorld is a text-based household where an agent must carry out instructions like put a clean mug in the coffee machine, by moving between rooms and objects. WebShop is a simulated shopping site where the agent must find a product matching a detailed specification. These are the tasks where the paper reports hard numbers. ReAct beats imitation and reinforcement learning baselines on ALFWorld by an absolute 34 percentage points in success rate, and on WebShop by an absolute 10 percentage points, while being prompted with only one or two in-context examples. No fine-tuning, no trained policy, just a large language model and a short prompt.
That is the result that made people pay attention. A handful of in-context examples was enough to beat systems that had been explicitly trained for the task. If you want to understand why prompting research exploded in late 2022 and 2023, this is one of the data points.
One honest caveat the paper itself raises. On the knowledge tasks, pure chain of thought sometimes still wins on raw accuracy when the model happens to know the answer already, because it avoids the noise of imperfect retrieval. ReAct’s advantage there is robustness and readability, not always raw score. The headline win is on the interactive tasks, where acting is unavoidable.
Why ReAct launched modern agent design
The reason this paper aged so well is that the loop it describes is portable. It does not depend on a specific model, a specific tool, or a specific framework. Thought, action, observation. That three part cycle is the spine of nearly every agent system that followed. The function calling layer in OpenAI’s API, the agent runtimes in LangGraph and the Hugging Face smolagents course, the research and coding agents people use in production, they are all descendants of this pattern.
Two ideas from the paper turned out to be load bearing for everything after. The first is that reasoning and tool use should be interleaved, not staged. You do not plan the whole thing up front and then execute, you plan one step, act, observe, and replan. The second is that the reasoning should be external and inspectable. Hidden reasoning is hard to debug and hard to trust. A visible trace is something a human can verify, correct, or learn from.
It is worth being precise about what the paper did not invent. Tool use by language models predates ReAct, as does chain of thought prompting. The contribution is the synergy argument, the evidence that interleaving the two beats running either in isolation, and the demonstration that a prompting only approach with one or two examples can match or beat trained baselines on hard interactive tasks. That is a big claim, and the fact that it held up across four quite different benchmarks is why it stuck.
Read it today and you will recognize almost everything, because the field has converged on it. That is the best sign a foundational paper can give. When the loop it proposed has become the default, you are reading the source.
How to read the paper
The ReAct paper is short and unusually readable for a research paper, and you do not need a machine learning background to follow the core argument. Start with the abstract and the introduction, which together give you the synergy thesis and the four benchmark results. Then read Section 3, where the method is laid out with worked examples of thought, action, observation triples. The figures there show actual trajectories, and they are the clearest way to internalize what interleaving looks like in practice.
If you want the evidence, the experiments section walks through HotpotQA, FEVER, ALFWorld, and WebShop in order, with ablations comparing ReAct against pure reasoning and pure acting baselines. The ablations are the most important tables for a practitioner, because they isolate the contribution of each half of the method. Skip the related work and conclusion on a first pass, they are useful for context but not for understanding the idea.
The full paper is open on arXiv at the link below, and the original code is public on GitHub under the name ReAct. For most practitioners, reading the method section and one set of trajectories is enough to understand why every agent framework you use today is built the way it is.
Read the ReAct paper on arXiv (2210.03629)
Who should read the ReAct paper
You should read it if you build agents and have never read the source. You should read it if you learned agents from a framework and want to know why the framework’s main loop is shaped the way it is. You should read it if you write prompts for a living and have never seen the original thought, action, observation examples. And you should read it if you are evaluating or auditing agents, because the interpretability argument is the one that still pays off every time something goes wrong in production and you need to find where.
You do not need to read it if you only use agents casually and have no interest in how they work under the hood. The paper is short, but it is still a research paper, and the practical takeaways are well summarized here and in the later deep dives in this series. Treat it as a primary source, not a tutorial.
The ReAct paper is the single most cited influence on modern agent loops, and it rewards anyone who builds, prompts, or debugs agents. Read it for the synergy argument and the trajectory examples, and you will understand why every framework you use interleaves reasoning and acting the way it does. If you read one paper on agents, make it this one.