ReAct Agent

What Is ReAct Agent?

A ReAct agent is an AI agent built on the Reasoning and Acting pattern: the model writes out a thought about what to do next, takes one action such as a tool call, observes the result, and repeats the cycle until the task is complete. Interleaving explicit reasoning with actions grounds each decision in real observations.

Key Takeaways

• The loop is thought, action, observation, repeated. Reasoning before each action and reading the result after it is what distinguishes ReAct from plan-everything-upfront designs.
• Grounding is the point. Because the agent observes real tool output between steps, it corrects course when reality disagrees with its assumptions instead of hallucinating forward.
• ReAct comes from a 2022 research paper by Yao and colleagues, and it became the default skeleton for tool-using agents. The original paper beat imitation- and reinforcement-learning baselines by 34% and 10% absolute success rate on ALFWorld and WebShop using only one or two in-context examples [1]. Modern native tool-calling loops are its direct descendants.
• Every iteration spends tokens and wall-clock time, so production ReAct agents need step caps, loop detection, and a clear stop condition.

How It Works

The agent receives a task and a description of available tools. On each turn, the model produces a reasoning trace, in the spirit of chain-of-thought prompting, that assesses the situation: what is known, what is missing, which tool would help. It then emits one action, a structured tool invocation with arguments. The runtime executes the action and appends the observation, meaning the tool's actual output, to the transcript. The model reads the updated transcript and reasons again. When it judges the task complete, it emits a final answer instead of another action. Pairing the loop with explicit reasoning also helps on knowledge tasks: Google Research reported that combining ReAct with chain-of-thought reached 35.1 exact match on HotpotQA versus 28.7 for standard prompting [2].

The original paper implemented this with plain text prompting, parsing lines labeled Thought and Action from the model's output. Even in that simple form, two-shot ReAct hit a 71% success rate on ALFWorld against 45% for act-only prompting and 37% for imitation-learning baselines [3]. Modern stacks achieve the same loop through native tool calling APIs, where the model emits structured function calls and reasoning may happen in dedicated thinking tokens rather than visible prose. The pattern survives because it is a robust control loop, whatever the transport. What has changed is that a reasoning model now handles much of the deliberation internally, so the verbose scaffolded prompts of early ReAct implementations are largely obsolete.

The failure modes are as characteristic as the strengths. Agents can loop, retrying a failing tool with tiny variations, or drift when a misleading observation sends the reasoning down a wrong path. Production implementations bound the loop with a maximum step count, detect repeated identical actions, and validate tool arguments before execution.

Example

An on-call engineer asks a diagnostics agent why checkout latency spiked at 14:00. The agent reasons that it should check deploy history first, calls the deployment API, and observes a payments-service release at 13:52. It reasons that the release is a suspect but wants corroboration, so it queries the metrics store for p99 latency by service and observes that only the payments service degraded. Next thought: check the release diff. It pulls the changelog, sees a connection-pool configuration change, and queries current pool saturation, which reads 100 percent. Having connected the change to the symptom through four grounded steps, it stops and reports: the 13:52 release shrank the pool, saturation is pinned, and rollback or a pool-size revert are the immediate options. Each step depended on the previous observation, which no pre-written plan could have anticipated.

What People Get Wrong

A surprisingly common confusion, worth clearing first: a ReAct agent has nothing to do with React, the JavaScript UI library. The name abbreviates Reasoning and Acting. The deeper technical mistake is treating the reasoning trace as ceremony and trimming it to save tokens, or letting it degrade into boilerplate. The thought step is the agent's error-correction mechanism; when it becomes an empty ritual, the agent stops updating on observations and plows ahead on its initial assumption. If traces read as filler, the fix is refining the prompt and the tools' output quality, since the loop is only as good as what the model reasons over.

FAQ

Is ReAct still relevant now that models have native tool calling? The prompt-parsing implementation is mostly historical, but the pattern is more alive than ever: every mainstream agent loop, from coding assistants to computer-use agents, interleaves reasoning, action, and observation. Understanding ReAct is understanding why those loops work and how they fail.

How does a ReAct agent differ from plan-and-execute agents? Plan-and-execute decomposes the whole task upfront and then runs the steps, which is cheaper and more predictable when the path is known. ReAct decides one step at a time, which wins when each step's outcome should shape the next, as in debugging or research. Many systems combine them: plan the phases, run each phase as a ReAct loop.

What do ReAct agents struggle with? Long tasks that overflow the transcript, since every thought and observation accumulates in the context window, and tasks with deceptive intermediate signals that send reasoning astray. Delegating subtasks to a fresh subagent and keeping tool outputs concise are the standard mitigations.

Sources

1. Yao et al. (arXiv). "ReAct beats imitation- and reinforcement-learning baselines by 34% and 10% absolute success rate on ALFWorld and WebShop." https://arxiv.org/abs/2210.03629. Accessed August 2026.
2. Google Research. "ReAct plus chain-of-thought reaches 35.1 exact match on HotpotQA versus 28.7 for standard prompting." https://research.google/blog/react-synergizing-reasoning-and-acting-in-language-models/. Accessed August 2026.
3. Google Research. "Two-shot ReAct reaches 71% success on ALFWorld versus 45% act-only and 37% imitation learning." https://research.google/blog/react-synergizing-reasoning-and-acting-in-language-models/. Accessed August 2026.