ReAct is the prompting and agent-design pattern that made the language model’s reasoning loop explicitly interactive: instead of producing only a final answer or a hidden plan, the model alternates between verbal reasoning, tool or environment actions, and observations returned from the world. The original Yao et al. paper did not merely introduce a prompt template; it named and empirically validated the now-familiar agentic loop in which reasoning traces guide actions and actions ground subsequent reasoning. ([Yao et al. 2022][1]) arXiv
Coverage note: verified through May 18, 2026.
1. The core idea
ReAct stands for reasoning and acting. In its canonical form, a language model emits an interleaved trajectory:
| Step type | Function in the loop | Typical form |
|---|---|---|
| Thought | Verbal reasoning, decomposition, memory of subgoals, interpretation of prior observations | “I need to find where X was born, then compare it with Y.” |
| Action | A command to a tool, search API, browser, simulator, or environment | Search[entity], Lookup[keyword], Finish[answer] |
| Observation | The external result returned by the environment | Search result, page snippet, simulator state, product page, game feedback |
The original paper defines a task-solving trajectory as a sequence of thought-action-observation steps, with the important caveat that reasoning can be sparse on decision-making tasks where actions and observations dominate the trajectory. ([Yao et al. 2022][1]) arXiv
The conceptual move is simple but deep: Chain-of-Thought Prompting gives the model a place to reason, while tool use gives it a way to obtain new evidence or change the environment. ReAct fuses the two into a single trajectory: thoughts decide which actions to take, and observations update the thoughts. The Google Research summary phrases the bidirectional dependency as “reason to act” and “act to reason”: reasoning traces help choose useful actions, and actions supply information that improves later reasoning. ([Google Research ReAct summary][2]) Google Research
This is why ReAct matters beyond its exact prompt syntax. It turned “LLM plus tools” from a loose engineering intuition into a paper-level pattern: a language model can be prompted to behave as a closed-loop controller whose intermediate text functions as both scratchpad and policy state. The later ecosystem of react-agents, LangChain-style agents, LlamaIndex agents, Hugging Face agent tutorials, and tool-augmented reasoning systems repeatedly reuses this basic loop, even when implementations hide the literal word “Thought.” ([LangChain agents documentation][10]; [LlamaIndex ReActAgent documentation][11]; [Hugging Face Agents Course][12]) docs.langchain.com+2Developer Documentation+2
2. What ReAct synthesized
Before ReAct, two lines of work were already visible.
First, Chain-of-Thought Prompting showed that large language models could improve on multi-step reasoning tasks when prompted to emit intermediate reasoning steps. Wei et al. define a chain of thought as “a series of intermediate reasoning steps” and show that few-shot exemplars containing such steps improve performance on arithmetic, symbolic, and commonsense reasoning tasks, especially at large model scale. ([Wei et al. 2022][3]) arXiv
Second, tool-using and environment-interacting language systems were emerging. Systems such as WebGPT, MRKL-style modular systems, Toolformer, SayCan, and Inner Monologue explored retrieval, API calls, modular reasoning, embodied action, or feedback from an environment. The ReAct paper explicitly situates itself among these systems, while arguing that most prior language-agent work either emphasized acting without explicit reasoning traces or reasoning without grounded action. ([Yao et al. 2022][1]; [Toolformer][16]; [MRKL Systems][17]) arXiv+2arXiv+2
ReAct’s foundational contribution was to unify those strands into a general prompt-level and trajectory-level abstraction. In question answering and fact verification, the model can reason about what it needs to know, issue search and lookup actions, read observations, and decide whether to continue or finish. In interactive environments such as ALFWorld and WebShop, the model can use thoughts to maintain a plan across long horizons while actions manipulate or inspect the environment. ([Yao et al. 2022][1]) arXiv
That synthesis is not the same as inventing every component. ReAct did not invent search, retrieval, embodied control, scratchpads, or tool APIs. Its contribution was to make the interleaving the unit of analysis: reasoning is not a prelude to action, and action is not an opaque policy output; each step can inform the next. This is the pattern most people now mean when they describe a text-agent loop as Thought → Action → Observation. ([Yao et al. 2022][1]; [PromptingGuide ReAct overview][13]) arXiv
3. The canonical ReAct prompt
In the Wikipedia-style tasks in the original paper, ReAct used a deliberately simple action space:
| Action | Purpose |
|---|---|
Search[entity] |
Return the first few sentences from a corresponding Wikipedia page, or suggest similar entities if the page is missing |
Lookup[string] |
Find the next sentence on the current page containing the target string |
Finish[answer] |
End the episode with an answer |
The authors emphasized that this Wikipedia API was intentionally weaker than contemporary retrieval systems, making the setup a test of whether the model could use limited external evidence strategically rather than a retrieval benchmark optimized for state-of-the-art QA. ([Yao et al. 2022][1]) arXiv
A typical ReAct prompt supplies a few demonstrations containing multiple thought-action-observation steps. The language model then continues the trajectory for a new task. In the paper’s HotpotQA and FEVER setup, the demonstrations contained free-form thoughts for decomposition, commonsense inference, arithmetic, search guidance, information extraction from observations, and final answer synthesis. ([Yao et al. 2022][1]) arXiv
The important engineering point is that ReAct’s structure is textual but operational. Thought is natural language, but Action is parsed by the harness and executed against an external environment. Observation is then injected back into the model context. That makes ReAct a bridge between prompting and runtime orchestration: the prompt teaches the model a protocol, while the harness enforces the parts of the protocol that correspond to real operations.
4. ReAct versus nearby patterns
| Pattern | What the model emits | External world access | Main strength | Main failure mode |
|---|---|---|---|---|
| Standard prompting | Final answer | No | Simple and cheap | Brittle on multi-step tasks |
| Chain-of-thought prompting | Reasoning trace plus answer | No | Better decomposition and multi-step reasoning | Can hallucinate unsupported intermediate facts |
| Act-only agent | Tool/environment actions | Yes | Grounded interaction | Weak planning and poor interpretability |
| ReAct | Thoughts, actions, observations, answer | Yes | Combines decomposition with grounding | Can loop, make bad searches, or over-constrain reasoning |
| Native tool-use API agent | Structured tool calls, tool outputs, final answer; reasoning may be hidden | Yes | Safer parsing and cleaner integration | Less transparent if reasoning is not exposed |
| Reasoning model with tools | Internal reasoning tokens, tool calls, possibly summaries | Yes | Stronger internal planning and tool orchestration | Raw reasoning may be unavailable or unfaithful |
This comparison captures ReAct’s location in the design space. It is not merely chain-of-thought, because observations from external tools change the state of the reasoning process. It is not merely tool calling, because the intermediate reasoning trace is part of the policy that decides when and how to call tools. It is not equivalent to modern native function calling, because function calling specifies a structured interface, whereas ReAct specifies an agentic reasoning-control pattern. ([Yao et al. 2022][1]; [OpenAI function calling documentation][14]; [Anthropic tool-use documentation][15]) arXiv+2OpenAI Developers+2
5. Empirical evidence in the original paper
The original ReAct paper evaluated the pattern across two broad task classes:
-
Knowledge-intensive reasoning tasks: HotpotQA and FEVER.
-
Interactive decision-making tasks: ALFWorld and WebShop.
The evidence is useful but should be read carefully. The paper’s empirical results show that ReAct is a strong general pattern, not that the exact prompt dominates every specialized system on every benchmark. On HotpotQA, for example, plain ReAct underperformed chain-of-thought self-consistency, while ReAct combined with chain-of-thought self-consistency performed best among the prompting variants. ([Yao et al. 2022][1]) arXiv
5.1 HotpotQA and FEVER
HotpotQA is a Wikipedia-based multi-hop question answering benchmark requiring reasoning across multiple supporting documents. FEVER is a fact-verification benchmark in which systems classify claims as supported, refuted, or lacking enough evidence, using Wikipedia evidence. ([HotpotQA][18]; [FEVER][19]) arXiv
The paper reports the following PaLM-540B prompting results:
| Method | HotpotQA EM | FEVER accuracy |
|---|---|---|
| Standard prompting | 28.7 | 57.1 |
| Chain-of-thought | 29.4 | 56.3 |
| Chain-of-thought self-consistency | 33.4 | 60.4 |
| Act-only | 25.7 | 58.9 |
| ReAct | 27.4 | 60.9 |
| Chain-of-thought self-consistency → ReAct | 34.2 | 64.6 |
| ReAct → chain-of-thought self-consistency | 35.1 | 62.0 |
| Supervised state of the art reported in paper | 67.5 | 89.5 |
Source: Yao et al., Table 1. ([Yao et al. 2022][1]) arXiv
The result is often compressed into “ReAct improves QA,” but the actual pattern is more subtle. On FEVER, ReAct slightly beat chain-of-thought self-consistency in the reported table. On HotpotQA, plain ReAct lagged chain-of-thought self-consistency. Hybrid approaches did best among prompting methods, suggesting that reasoning-only sampling and action-grounded reasoning were complementary rather than mutually exclusive. ([Yao et al. 2022][1]) arXiv
The paper’s error analysis is also important. ReAct reduced hallucination relative to chain-of-thought because observations grounded factual claims, but it introduced search-result errors and more reasoning errors caused by the constraints of the action-observation loop. The authors report that among failed HotpotQA cases, chain-of-thought failures were dominated by hallucination, while ReAct failures included reasoning errors, search-result errors, and label ambiguity. ([Yao et al. 2022][1]) arXiv
5.2 ALFWorld and WebShop
ALFWorld is a text-based interactive environment aligned with embodied household tasks. WebShop is a simulated e-commerce environment containing 1.18 million products and 12,087 human-written shopping instructions, where agents navigate product pages and select items matching a user request. ([ALFWorld][20]; [WebShop][21]) arXiv
The paper reports that ReAct substantially improved over act-only baselines in these interactive settings:
| Benchmark | Baseline | ReAct result | Reported improvement |
|---|---|---|---|
| ALFWorld | Act-only best-of-6: 45% success | ReAct best-of-6: 71% success | +26 percentage points in the table; summarized by Google as a +34% success-rate improvement over prior baselines |
| WebShop | Act-only: 30.1% success | ReAct: 40.0% success | +9.9 percentage points |
| WebShop | Human expert: 59.6% success | ReAct: 40.0% success | ReAct remained far below expert human performance |
Source: Yao et al., Tables 3 and 4; Google Research summary. ([Yao et al. 2022][1]; [Google Research ReAct summary][2]) arXiv+2arXiv+2
The interactive results are the cleanest evidence for the value of explicit reasoning in a tool- or environment-using agent. In ALFWorld, the model must keep track of household goals over multiple steps, such as finding, moving, cleaning, heating, cooling, or placing objects. In WebShop, it must search, inspect, compare, and select products under noisy textual constraints. In both cases, act-only prompting can interact with the environment, but it lacks a stable natural-language plan. ReAct’s thoughts supply that plan. ([Yao et al. 2022][1]) arXiv
The result is not that ReAct solved interactive agents. WebShop ReAct remained below human expert success, and ALFWorld performance varied substantially across task types. The more defensible conclusion is that explicit reasoning traces can improve long-horizon interaction when a model’s next action depends on a partially observed state and a remembered goal. ([Yao et al. 2022][1]) arXiv
6. Interpretability and human correction
One reason ReAct became influential is that it produced inspectable trajectories. A developer or evaluator can read the thought-action-observation sequence and see whether the agent searched for the wrong entity, misread an observation, repeated an action, or jumped to an unsupported answer. The authors highlight interpretability and human alignment as advantages of the approach, and they show that humans can edit ReAct thoughts to steer a trajectory back on track. ([Yao et al. 2022][1]; [Google Research ReAct summary][2]) arXiv
This interpretability claim should not be overstated. A written thought trace is not guaranteed to be a faithful record of the model’s internal computation. Later work on chain-of-thought faithfulness argues that models do not always verbalize the real causes of their answers, and that visible reasoning can omit or rationalize parts of the computation. ([Anthropic chain-of-thought faithfulness research][22]) Anthropic
The more precise claim is operational: ReAct trajectories are debuggable artifacts. Even if a thought is not a perfect window into the model’s latent reasoning, the combination of declared intent, executed action, and returned observation gives engineers a useful trace for diagnosing agent behavior. That is weaker than mechanistic transparency but stronger than an opaque final answer or a bare sequence of tool calls.
7. Relationship to chain-of-thought prompting
ReAct is best understood as chain-of-thought plus external interaction, not as a replacement for chain-of-thought. Chain-of-thought prompting asks the model to solve the problem by elaborating intermediate reasoning steps in text. ReAct asks the model to alternate between such reasoning and actions that gather information or change state. ([Wei et al. 2022][3]; [Yao et al. 2022][1]) arXiv
The difference matters because chain-of-thought can improve reasoning while still hallucinating facts. A chain-of-thought answer to a HotpotQA question may invent a supporting fact if the model’s pretraining memory is wrong or incomplete. ReAct can search Wikipedia, read an observation, and update its reasoning. This is why the original paper frames ReAct as a way to overcome hallucination and error propagation in reasoning-only prompting. ([Yao et al. 2022][1]) arXiv
But ReAct also inherits and adds failure modes. The model can choose the wrong search query, misinterpret a retrieved passage, loop through unhelpful lookups, or let the rigid step structure interrupt a reasoning path that chain-of-thought would have handled more fluidly. The original results show exactly this: ReAct reduces certain hallucinations but can suffer from search errors and reasoning errors introduced by the action protocol. ([Yao et al. 2022][1]) arXiv
The practical lesson is that ReAct and chain-of-thought are complementary. The original paper’s best prompted HotpotQA result came from combining ReAct with chain-of-thought self-consistency, not from treating one as a universal replacement for the other. ([Yao et al. 2022][1]) arXiv
8. Relationship to native tool-use APIs
Modern tool-use APIs complicate the historical picture. In 2022, ReAct’s Action[...] syntax was a convenient way to teach a model to emit parseable commands. By 2026, major model APIs support structured tool calls directly: OpenAI exposes tool and function calling, Anthropic exposes client and server tools, and Gemini supports function calling with multi-turn and compositional tool use. ([OpenAI function calling documentation][14]; [Anthropic tool-use documentation][15]; [Gemini function calling documentation][23]) OpenAI Developers+2Claude+2
This does not make ReAct obsolete. It changes where the ReAct pattern lives.
| Layer | ReAct-era implementation | Native tool-use implementation |
|---|---|---|
| Tool selection | Model writes Action[...] in text |
Model emits structured tool call |
| Tool arguments | Parsed from text | Validated against schema |
| Tool execution | Harness executes command | Client/server tool executor handles call |
| Observation | Injected as Observation: text |
Returned as tool result message |
| Reasoning trace | Often visible as Thought: |
May be hidden, summarized, or policy-controlled |
| Agent policy | Prompt pattern | Prompt, system instructions, model training, runtime graph |
Native tool APIs are better at type safety, argument validation, separation of user-visible text from machine-readable calls, and integration with production systems. But they do not by themselves decide how an agent should decompose a problem, when it should search, how it should recover from failed calls, or when it should stop. Those are still ReAct-like control questions. ([OpenAI function calling documentation][14]; [LangChain agents documentation][10]) OpenAI Developers
Reasoning models push the distinction further. OpenAI documentation describes reasoning models as using internal reasoning tokens before responses, including to plan, use tools, inspect alternatives, recover from ambiguity, and solve multi-step tasks; it also notes that raw reasoning tokens are not exposed through the API, although summaries may be available. ([OpenAI reasoning models documentation][24]) OpenAI Developers
Anthropic similarly describes extended thinking with tool use, in which Claude can alternate between reasoning and tool use, and emphasizes preserving thinking blocks across tool calls for reasoning continuity. Anthropic’s separate “think tool” guidance also treats explicit thinking as useful in long chains of tool calls and sequential decisions, while warning that it is not a universal solution. ([Anthropic extended thinking documentation][25]; [Anthropic think-tool guide][26]) Claude
So the modern relationship is this: native tool APIs replace ReAct’s brittle text parsing, but not necessarily ReAct’s control logic. A production agent may no longer literally print Thought:, yet it may still operate as a ReAct descendant: reason, call a tool, observe, revise, continue.
9. ReAct versus react-agents
This article is about the foundational ReAct paper and the reasoning-acting synthesis it named. It is not identical to the broader engineering category of react-agents.
The distinction matters:
| Term | Meaning |
|---|---|
| ReAct | The Yao et al. paper and prompting paradigm: interleaved reasoning traces and actions |
| ReAct prompt | A prompt template that elicits Thought/Action/Observation trajectories |
| ReAct agent | A runtime agent that uses a ReAct-style loop, often with tools |
| react-agents | The broader family of agent harnesses and implementations inspired by ReAct, often using native tool calls, graphs, memory, retries, and observability |
LangChain’s older create_react_agent documentation explicitly describes creating an agent that uses ReAct prompting and points back to the paper. Newer LangChain agent documentation generalizes the idea into an agent loop in which a model reasons, decides which tools to call, executes tools, and iterates until it returns a final answer or hits a stopping condition. ([LangChain ReAct agent documentation][27]; [LangChain agents documentation][10]) LangChain Reference Docs
LlamaIndex similarly documents a ReActAgent that reasons step by step over tools and notes that it can work even with LLMs that do not support native function calling. Hugging Face’s agents course presents the Thought → Action → Observation cycle as the core AI-agent workflow. ([LlamaIndex ReActAgent documentation][11]; [Hugging Face Agents Course][12]) Developer Documentation
The broader react-agents category therefore includes many things that were not in the original paper: JSON-schema tool calls, graph runtimes, persistent memory, streaming traces, parallel tool use, guardrails, human-in-the-loop checkpoints, and model-native reasoning summaries. These are extensions of the pattern, not part of the original contribution.
10. Influence on later work
ReAct’s influence is easiest to see in later systems that modify one part of the loop while preserving the basic idea that language agents should reason across actions and observations.
10.1 Reflexion
Reflexion extends ReAct by adding a verbal self-improvement layer. Instead of updating model weights through reinforcement learning, Reflexion agents store reflective text in memory and use it to improve future attempts. The paper frames this as “verbal reinforcement learning”: the agent receives feedback, writes a reflection, and conditions subsequent behavior on that reflection. ([Reflexion][4]) arXiv
In ReAct terms, Reflexion adds a memory-bearing meta-loop around the trajectory. ReAct answers: “How should the agent interleave reasoning and acting during an episode?” Reflexion asks: “How should the agent learn from a failed episode without weight updates?” The result is a direct descendant rather than a replacement.
10.2 ReWOO
ReWOO, or “Reasoning without Observation,” critiques the cost and inefficiency of interleaving every reasoning step with tool observations. It decouples reasoning from external observations by having the model produce a plan with variable assignments, execute tool calls, and then synthesize an answer from the collected evidence. The authors report token-efficiency gains and improved robustness to tool failure on HotpotQA. ([ReWOO][5]) arXiv
ReWOO’s relationship to ReAct is especially revealing. It accepts ReAct’s premise that language agents need both reasoning and tools, but disputes the need for tight alternation at every step. This makes ReWOO a useful counterpoint: perhaps explicit Thought/Action/Observation is too chatty or serial for tasks where a plan can be compiled before execution.
10.3 Language Agent Tree Search
Language Agent Tree Search generalizes the ReAct trajectory from a single linear path into a search process. LATS integrates Monte Carlo tree search, language-model-generated actions, value estimates, self-reflection, and environment feedback across tasks such as programming, question answering, web navigation, and mathematics. ([Language Agent Tree Search][6]) arXiv
In ReAct, the model samples or follows one trajectory. In LATS, the agent can explore multiple candidate trajectories, evaluate them, and backtrack. That is a natural progression: once a ReAct trace is treated as a sequence of states and actions, search over traces becomes available.
10.4 Agent frameworks and tutorials
Modern frameworks absorbed ReAct as a default mental model. LangChain describes agents as systems that combine language models with tools and iterate until a final output or stopping condition. LlamaIndex exposes ReAct agents over tool sets. Hugging Face teaches agents through the Thought-Action-Observation loop. Anthropic’s cookbook includes a ReAct-agent example with LlamaIndex and shows the familiar sequence of thought, action, action input, observation, and answer. ([LangChain agents documentation][10]; [LlamaIndex ReActAgent documentation][11]; [Hugging Face Agents Course][12]; [Anthropic ReAct cookbook][28]) Claude+3docs.langchain.com+3Developer Documentation+3
This reception literature should be read as evidence of adoption, not as evidence that ReAct is always the best architecture. Tutorials tend to preserve simple canonical loops because they are teachable. Production systems often add planning, structured tool calls, hidden reasoning, retries, routing, memory, policy checks, and evaluation harnesses.
11. What ReAct did not settle
11.1 Faithfulness of reasoning traces
ReAct makes reasoning visible, but visible reasoning is not automatically faithful. Later research on chain-of-thought faithfulness argues that models may omit decisive information from their stated reasoning or produce explanations that do not reflect the true internal computation. ([Anthropic chain-of-thought faithfulness research][22]) Anthropic
For ReAct, this creates a distinction between trace usefulness and trace truthfulness. A trace can be useful for debugging even if it is not a complete cognitive transcript. The action and observation records are externally grounded; the thought fields are model-generated interpretations.
11.2 Robustness and looping
The original paper already showed that ReAct can get stuck in repetitive trajectories or fail because of bad searches. Later agent systems add iteration limits, stop conditions, planner-executor splits, reflection, tree search, retry policies, and structured tool schemas partly because the plain ReAct loop is not robust enough by itself. ([Yao et al. 2022][1]; [ReWOO][5]; [Language Agent Tree Search][6]) arXiv+2arXiv+2
11.3 Tool safety
The original paper’s environments were bounded: Wikipedia-style search, WebShop simulation, and text-game interaction. The authors explicitly note that their interactions did not involve dangerous actions. That limitation matters because modern agents may call file systems, code interpreters, databases, payment systems, browsers, email tools, or external APIs. ([Yao et al. 2022][1]) arXiv
ReAct’s loop is therefore not a safety architecture. It is a control pattern. Production agents need authorization boundaries, tool permissioning, sandboxing, audit logs, rate limits, and human approval for sensitive actions.
11.4 Evaluation
The paper’s benchmark suite was well chosen for its thesis: HotpotQA and FEVER test knowledge-grounded reasoning, while ALFWorld and WebShop test interaction. But the results do not prove that ReAct dominates across arbitrary real-world tasks. The strongest claim supported by the original evidence is narrower: interleaving reasoning and acting improves or complements baseline prompting on several representative tasks, especially interactive decision-making tasks. ([Yao et al. 2022][1]) arXiv
12. The open question: does explicit Thought/Action/Observation still matter?
The major open question is whether explicit ReAct structure remains useful as base models internalize the loop.
There are strong arguments that it does. Explicit Thought/Action/Observation makes the control flow inspectable, gives weaker or non-tool-native models a protocol, helps developers debug tool calls, and separates environment evidence from model inference. It is especially useful in teaching, evaluation, and simple agent harnesses where the whole trajectory should be legible. The continued presence of ReAct-style agents in LangChain, LlamaIndex, Hugging Face materials, and Anthropic examples shows that the pattern remains practical as a design vocabulary. ([LangChain agents documentation][10]; [LlamaIndex ReActAgent documentation][11]; [Hugging Face Agents Course][12]; [Anthropic ReAct cookbook][28]) Claude+3docs.langchain.com+3Developer Documentation+3
There are also strong arguments that the literal format will become less central. Native tool APIs remove the need for textual Action[...] parsing. Reasoning models can think internally across tool calls. API providers may expose summaries rather than raw reasoning tokens. Structured tool calls, hidden scratchpads, and model-native planning can preserve the ReAct control pattern without displaying every thought to the user or developer. ([OpenAI function calling documentation][14]; [OpenAI reasoning models documentation][24]; [Anthropic extended thinking documentation][25]) OpenAI Developers+2OpenAI Developers+2
The most likely outcome is not “ReAct disappears” or “ReAct remains unchanged.” The likely outcome is separation of concerns:
| Concern | Likely durable artifact |
|---|---|
| Tool execution | Structured tool calls and typed results |
| Environment grounding | Explicit observations or tool-result messages |
| Developer debugging | Traces, logs, spans, summaries, and selected reasoning |
| Model deliberation | Increasingly internal or summarized |
| Agent control policy | ReAct-like loop, planner-executor variants, search, reflection, or learned policies |
In that world, ReAct remains historically and conceptually central even if the literal prompt labels become optional. Its lasting contribution is the synthesis: language agents work better when they can both reason and act, and when each process can condition the other.
13. Practical implications for AI engineering
For engineering work, ReAct is best treated as a baseline architecture and diagnostic lens, not as a final production recipe.
Use an explicit ReAct loop when the task requires iterative information gathering, when the model must decide among tools, when observations materially change the answer, or when debugging traces matter. Avoid or compress it when the task is a single deterministic tool call, when native function calling can solve the problem directly, when verbose reasoning increases latency or cost, or when exposing chain-of-thought would create policy, privacy, or security issues.
A useful production decomposition is:
| Component | ReAct-era form | Production-oriented form |
|---|---|---|
| Prompt | Few-shot Thought/Action/Observation examples | System policy plus task instructions |
| Tool interface | Text command syntax | JSON schema, typed tools, MCP/server tools, or framework tools |
| Reasoning | Visible thoughts | Hidden reasoning, summaries, or selectively logged rationale |
| Observation | Raw text inserted into context | Structured tool result with provenance |
| Loop control | Model decides until Finish |
Runtime graph with iteration limits, validators, fallbacks |
| Debugging | Read the transcript | Trace spans, tool logs, observations, evals, replay |
The original ReAct paper is still worth reading because it isolates the minimal form of the idea. Many later systems add complexity, but the primitive remains the same: a model alternates between interpreting the state, acting on the world, and incorporating the result.
14. Reference map
| Label | Source | Role in this article |
|---|---|---|
| [1] | Yao et al., “ReAct: Synergizing Reasoning and Acting in Language Models” | Original paper, method, benchmarks, error analysis |
| [2] | Google Research ReAct summary | Official reception and high-level explanation |
| [3] | Wei et al., “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models” | CoT predecessor and comparison point |
| [4] | Shinn et al., “Reflexion: Language Agents with Verbal Reinforcement Learning” | ReAct descendant using verbal memory and self-reflection |
| [5] | Xu et al., “ReWOO: Decoupling Reasoning from Observations for Efficient Augmented Language Models” | ReAct counter-design that decouples planning from observation |
| [6] | Zhou et al., “Language Agent Tree Search” | ReAct-like trajectories generalized into tree search |
| [10] | LangChain agents documentation | Modern framework reception |
| [11] | LlamaIndex ReActAgent documentation | Modern implementation of ReAct-style agents |
| [12] | Hugging Face Agents Course | TAO loop as educational agent pattern |
| [14] | OpenAI function calling documentation | Native tool-use comparison |
| [15] | Anthropic tool-use documentation | Native tool-use comparison |
| [22] | Anthropic chain-of-thought faithfulness research | Caveat on visible reasoning traces |
Companion entries
Core theory: Chain-of-Thought Prompting, Agentic Loop, Reasoning Traces, Tool Use APIs, Language Agents, Scratchpad Prompting, Reasoning-Acting Synthesis
Foundational systems: ReAct Paper, MRKL Systems, Toolformer, WebGPT, SayCan, Inner Monologue
Benchmarks: HotpotQA, FEVER, ALFWorld, WebShop, Interactive Decision-Making Benchmarks, Knowledge-Intensive Reasoning
Descendants and variants: Reflexion, ReWOO, Language Agent Tree Search, Planner-Executor Agents, Tree Search for Language Agents, Self-Improving Agents
Engineering practice: react-agents, LangChain Agents, LangGraph, LlamaIndex ReActAgent, Function Calling, Structured Tool Calls, Agent Observability, Human-in-the-Loop Agents
Counterarguments and open problems: Chain-of-Thought Faithfulness, Hidden Reasoning Tokens, Agent Tool Safety, Agent Evaluation, Hallucination and Grounding, Do Agents Need Explicit Thoughts?