ReAct — How AI Learned to Think AND Do Things ReAct — Synergizing Reasoning and Acting in Language Models ReAct: Synergizing Reasoning and Acting in Language Models ReAct: Synergizing Reasoning and Acting in Language Models — Technical Deep Dive

Why Thinking and Doing Separately Doesn't Work Well The Limits of Reasoning-Only and Acting-Only Approaches Why reasoning and acting were studied separately Limitations of Decoupled Reasoning and Action

For a long time, smart AI could do two things but not together: it could work through a problem step-by-step (like "let me think..."), OR it could do stuff like look things up (like "let me search"). But it didn't naturally weave them together.

Language models excel at reasoning — chain-of-thought prompting lets them explain their thinking. They can also act — call APIs, use tools. But most research treated these as separate. You either get a thinking-only model, or an action-only model.

Language models are strong at reasoning (chain-of-thought prompting) and action generation (API/tool calling), but research has largely studied them separately — reasoning techniques like CoT work within the model's knowledge, while action-based approaches ground the model in external tools but often lack reasoning traces to diagnose errors.

While LLMs demonstrate strong capabilities in both reasoning (chain-of-thought prompting) and action (API/tool invocation), the field developed these along largely orthogonal research tracks, with reasoning approaches constrained to model knowledge and action-based systems lacking explicit reasoning traces for error recovery.

Why This Matters for Real Problems Why this matters beyond toy tasks Why this matters beyond toy tasks Broader significance for real-world deployment

Many hard problems require both: you need to think (plan) and look stuff up (act). If you can do both, you can tackle things your AI never saw during training.

Many real problems are knowledge-intensive or interactive — they require access to external information or environment feedback that a training set alone can't provide. Interleaving reasoning with action is what humans actually do when solving hard problems.

Knowledge-intensive tasks (QA, fact verification) require access to information beyond the model's training data. Interactive tasks (shopping, navigation) require real-time feedback. Humans solve these by reasoning about what to do next, taking an action, observing the result, and adjusting — a pattern ReAct formalizes and enables in language models.

Real-world deployment of autonomous systems requires reasoning for plan formulation and diagnostics, plus action for grounding and information gathering; interleaving these is the cognitive pattern humans employ in knowledge-intensive and interactive settings, and the paper's empirical results suggest it's critical for LLM-based agents.

Words You Need to Know Vocabulary and prior techniques Background concepts you need first Formal Preliminaries

Building Blocks of the Think-Do-Learn Loop The ReAct System Design The ReAct system design Architectural and Interaction Specification

ReAct is simple: the AI model and the environment take turns. Model thinks/acts, environment observes, repeat until done. Three types of steps: Thought (the AI's reasoning), Action (the AI calling a tool), Observation (the environment's reply).

ReAct is straightforward: the model generates a trajectory (Thought → Action → Observation, repeated). At each step, the model can output a Thought (internal reasoning), an Action (tool call), or neither. The environment executes actions and returns Observations. This continues until the model outputs a final Answer.

ReAct operates via a simple interleaved loop: the model generates reasoning traces (Thought) and tool-use actions (Action). The environment executes actions and returns observations (Observation). The model's output is a trajectory of these three types of steps (Thought/Action/Observation), which it can then reason about and use to plan the next step, until it produces a final Answer.

The ReAct agent operates within a standard agent-environment feedback loop: at each step, the model generates text which can be parsed as Thought, Action, or Answer; Action is executed by the environment, which returns an Observation; the model then incorporates the Observation into its context window and generates the next step. Trajectories are naturally interpretable as language-based traces.

Task Input (Question / Goal)
         ↓
    ┌────────┐
    │ Model  │
    │ Output │
    └────┬───┘
         │
    ┌────▼─────────────────┐
    │ Parser               │
    │ ├─ is Thought?       │
    │ ├─ is Action(tool)?  │
    │ └─ is Answer?        │
    └────┬─────────────────┘
         │
    ┌────▼──────────────┐
    │ If Action:        │
    │  Env.execute()    │
    │  return Obs       │
    │                   │
    │ Else if Answer:   │
    │  return Result    │
    └────┬──────────────┘
         │
    Append to Context
         ↓
    [Repeat until Answer]
  

Deep Dive: Think-Do-Learn How Reasoning and Acting Interact Reasoning and acting in detail Formal Treatment of the Interleaved Reasoning-Action Trajectory

4.1 — What Reasoning Traces Do 4.1 — Reasoning traces 4.1 — Reasoning traces 4.1 — Reasoning traces (Thought steps)

Reasoning traces (Thoughts) help the model in several ways: (1) they help decide WHICH tool to call, (2) they let the model keep track of what it already learned, (3) when something goes wrong, reasoning can backtrack and try a different approach.

Reasoning traces serve three critical functions: Action planning — deciding what tool to use next; State tracking — keeping a record of what information has been gathered and intermediate conclusions; Error recovery — when a tool returns unexpected results, reasoning can diagnose the issue and revise the plan.

Reasoning traces (Thoughts) serve three critical functions: (1) Action induction: determining which tool to invoke next based on current understanding and goal; (2) State tracking: maintaining a coherent, updateable understanding of facts learned, intermediate conclusions, and remaining unknowns; (3) Exception handling: when a tool returns unexpected results or an action fails, reasoning can diagnose the failure and revise the plan rather than blindly continuing.

Reasoning traces (text-generated Thought steps) serve three key functions: (1) action induction — determining which tool invocation and arguments are appropriate given task context; (2) episodic state tracking — maintaining an updateable narrative of gathered facts and intermediate conclusions; (3) exception handling — diagnosing unexpected observations and recovering via trajectory replanning.

4.2 — What Actions Do 4.2 — Actions ground the model 4.2 — Actions ground the model 4.2 — Action execution (environment grounding)

Actions (tool calls) do the heavy lifting: they get real information (like searching Wikipedia), navigate environments (like clicking buttons in a game), and give the model fresh data to reason about — you can't get this info just by thinking.

Actions interface with external sources: APIs (Wikipedia search, calculators), environments (interactive games, simulators), websites (e-commerce search, checkout). This grounds the model in reality — it can no longer hallucinate facts because the action returns what's actually there.

Actions ground the model in reality by interfacing with external information sources (APIs, retrievers, simulators) that the model cannot access through internal reasoning alone. This prevents hallucination: if the model's reasoning would lead to an incorrect intermediate conclusion, an Observation from a later action can contradict and correct it.

Actions provide ground truth feedback: environmental responses (search results, state transitions, success/failure signals) are factual (conditioned on the environment's dynamics), not model-generated hallucinations, enabling the closed-loop feedback essential to dynamic planning and error recovery.

4.3 — The Synergy: Reasoning Helps You Act Better 4.3 — Synergy: how they combine 4.3 — Synergy: how they combine 4.3 — Emergent synergies of interleaving

Reasoning lets you pick the RIGHT action (instead of just guessing), and Observations let you adjust your reasoning. Together, you get a smart loop: think about what info you need → call the right tool → learn something new → think again based on what you learned.

Because the model reasons before acting, it selects more relevant tools and arguments. Because it reasons after observing, it can recover from tool failures and adapt its plan. This creates a virtuous cycle that neither pure reasoning nor pure action can achieve.

Reasoning before action leads to more deliberate tool selection; reasoning after observation enables adaptive planning. The resulting closed-loop trajectory is more interpretable (humans can read the Thoughts and understand the reasoning), more recoverable from errors (Observations that contradict prior Thoughts trigger replanning), and more capable of handling novel tasks (the interleaving pattern generalizes across different tool sets and task structures).

This creates a form of online learning: Observations perturb the model's context window, conditioning subsequent reasoning on actual ground-truth information rather than prior knowledge alone — functionally equivalent to in-context learning over a task-specific retrieval set, which substantially improves zero-shot performance on knowledge-intensive tasks.

Teaching the AI the Think-Do Pattern Prompting strategies for ReAct Prompting and in-context learning Prompting, In-Context Learning, and Trajectory Demonstration

Did It Work? Yes — By A Lot! Empirical results across four tasks Empirical results Quantitative Results and Comparative Analysis

The ReAct approach beat the old methods on ALL four tasks. On QA, it got more answers right. On the shopping game, it made better purchases. It worked across the board.

ReAct with text-davinci-003 achieved significant improvements over prior state-of-the-art and strong baselines on all four benchmarks — knowledge-intensive (HotpotQA, FEVER) and interactive (ALFWorld, WebShop) tasks. The gains are substantial and consistent.

ReAct with text-davinci-003 significantly outperformed prior SOTA and reasoning-only (CoT) and action-only baselines across all four benchmarks, with improvements ranging from +7% to +34% depending on the task.

ReAct demonstrated consistent and substantial improvements over reasoning-only (CoT), action-only (RL/imitation baselines), and hybrid baselines across all evaluated task distributions, with task-specific improvements ranging from 7.3 (FEVER) to 34.3 (ALFWorld) percentage points depending on baseline and setting.

Accuracy = success rate on each task. CoT baseline = same model with chain-of-thought prompting but no action. Prior SOTA = best prior published result.

6.1 — Breaking Down the Gains 6.1 — Component analysis 6.1 — Component analysis 6.1 — Ablation: Reasoning vs. Acting

The paper tested: ReAct with both thinking and doing, just thinking (CoT), and just doing (action-only). Result: doing both beats doing either alone. On QA, ReAct was 6.5% better than just thinking. On the shopping game, it was 43.5% better!

The paper compares ReAct (Thought + Action) against: CoT-only (same model, same reasoning, no actions); Action-only (tool calls without reasoning traces). ReAct consistently outperforms both.

Ablation results show that interleaving is critical: Thought-only (CoT) fails on tasks requiring grounding; Action-only fails due to lack of planning and recovery mechanisms. The full Thought-Action-Observation loop is necessary for best performance.

Empirical ablation demonstrates that neither pure reasoning nor pure action dominates: Thought-only performance is constrained by hallucination and the model's training-data knowledge; Action-only performance is constrained by lack of planning and adaptive recovery. Interleaving combines their complementary strengths.

6.2 — Different Task Types Show Different Gains 6.2 — Task-specific improvements 6.2 — Task-specific improvements 6.2 — Task-dependent performance patterns

QA tasks (asking for facts) got moderate gains. The shopping game got HUGE gains — because it's more interactive and you really need to think AND act.

Knowledge-intensive tasks (HotpotQA, FEVER) show 6-8% gains over CoT — reasoning helps, but these tasks still primarily benefit from accurate retrieval. Interactive tasks (ALFWorld, WebShop) show 34-43% gains — these tasks critically depend on planning (Thought) and adaptation to environment feedback (Observation).

Knowledge-intensive tasks (HotpotQA, FEVER) show 6-8% gains over CoT because the main challenge is finding the right information; some reasoning helps but retrieval accuracy dominates. Interactive tasks (ALFWorld, WebShop) show 34-43% gains because the agent must plan (Thought), adapt to unexpected outcomes (Observation feedback), and recover from failures — all impossible without interleaved reasoning-action-observation.

Gains are task-dependent: knowledge-intensive tasks show moderate improvements because the bottleneck is retrieval accuracy (and information is deterministic); interactive tasks show dramatic improvements because the bottleneck is planning/adaptation under uncertainty (non-deterministic environment feedback necessitates responsive re-reasoning).

The Secret Sauce Behind the Gains Why interleaving helps Why interleaving works Mechanistic Understanding of ReAct Advantages

Reason 1: Eliminates Hallucination Hallucination avoidance Hallucination avoidance Constraint-based hallucination mitigation

If the model starts with a wrong assumption (guessing wrong about a fact), a pure CoT approach will build on that lie. But ReAct can correct it: when the Action returns real data, the model can see it was wrong and change course.

CoT hallucinates because reasoning is confined to training knowledge. ReAct grounds reasoning in actual tool outputs. If an early Thought is incorrect, a later Observation contradicts it — the model detects the contradiction and adjusts.

CoT hallucination occurs because reasoning is confined to training knowledge, which is incomplete and can be incorrect. ReAct grounds reasoning in tool outputs (facts from Wikipedia, outcomes from environments), which are ground truth. Observations provide error signals that cause the model to revise incorrect earlier Thoughts.

Hallucination in CoT is a consequence of the model reasoning solely from its learned knowledge, which is incomplete and sometimes incorrect. ReAct mitigates this by grounding intermediate reasoning in environment-provided ground truth (search results, state observations), creating feedback loops that contradict and force revision of hallucinated intermediate states.

Reason 2: Better Planning & Adaptation Planning and adaptive recovery Planning and adaptive recovery Closed-loop planning and failure recovery

Pure action (just calling tools) is reactive — the agent doesn't think about why. ReAct lets the model think first ("What info do I need?"), then act ("Call this tool"), then think again ("Does this answer my question or do I need more info?"). This is smarter.

Thoughts allow the model to plan which actions to take, in what order, toward a goal. When an action fails or returns unexpected results, Thoughts allow the model to diagnose the issue and try a different approach — closed-loop adaptive planning.

Thoughts enable planning: the model can express a goal, decide which tool is most relevant, and execute a deliberate sequence toward that goal. When an action fails or returns unexpected results, Thoughts allow diagnosis and replanning — e.g., "That search didn't return what I needed; let me try a different query."

Interleaved Thoughts enable hierarchical planning and failure diagnosis: goal decomposition (Thought), action selection (Action), and trajectory adaptation (Thought in response to Observation) form a closed-loop where failures trigger replanning rather than cascading error.

Reason 3: More Interpretable & Trustworthy Interpretability and transparency Interpretability and transparency Trajectory transparency and human interpretability

You can READ ReAct trajectories like a story: "I thought X, I did Y, I learned Z, so I did W." You can't do that with action-only robots — they just execute commands. You also can't do it with CoT if the reasoning is wrong — you don't know to distrust it.

ReAct trajectories are human-readable narratives. You can inspect the reasoning, see which tools were called and why, and verify that tool outputs support the conclusion. This is vastly more interpretable than black-box action sequences or unsupported reasoning chains.

ReAct trajectories are natural-language narratives interleaving reasoning and grounded actions, making them interpretable to non-experts. You can trace the agent's reasoning, see which information it gathered, and verify that conclusions follow from observations. This is critical for trustworthiness in high-stakes domains.

Natural-language reasoning traces create explainability: intermediate steps (Thoughts) are human-readable, tool calls and results are verifiable (grounded in environment), and the trajectory from problem to answer is explicit — improving human interpretability and enabling stakeholder auditing relative to opaque RL agents or hallucination-prone CoT-only approaches.

What Doesn't Work Yet Limitations and challenges Limitations and challenges Limitations, Challenges, and Open Problems

8.1 — Future Directions Directions for future work Directions for future work Open research questions and extensions

The paper mentions several directions: (1) making longer trajectories work (token limit), (2) applying ReAct to new domains, (3) handling noisy tool outputs better, (4) improving tool selection automatically.

Future work includes: improving robustness to noisy observations, extending to new task domains, methods to manage long trajectories, and automatic tool selection/optimization.

Future work directions noted by the authors: (1) extending ReAct to additional domains (visual reasoning, multi-modal QA, code generation, scientific reasoning); (2) robustness improvements for noisy tool outputs and partially observable environments; (3) automatic tool selection/APIs given task descriptions; (4) trajectory compression/summarization to fit longer reasoning paths within context limits.

Open directions explicitly or implicitly identified: (1) robustness to adversarial/noisy observations; (2) techniques for extended reasoning (trajectory summarization, memory-augmented agents, hierarchical task decomposition); (3) scalability to larger tool sets and action spaces; (4) evaluation on domains requiring multi-step planning, structured knowledge (relational reasoning), or real-time interactive environments.

Where ReAct Could Change Things Practical applications Practical applications Deployment Scenarios and Use Cases

Practice Questions 60 practice questions Practice interview questions Structured interview prep

Click a question to reveal the answer.

Beginner (20)

Intermediate (20)

Advanced (20)

Test Your Understanding Quiz time Self-assessment quiz Self-graded comprehension check

Answer the questions below. Feedback appears instantly; results don't save.

Word Bank (A–Z) Terminology reference Terminology reference Technical Reference (A–Z)

If You Remember Five Things... Five core ideas Five core takeaways Five Fundamental Insights

1. Thinking and doing are both necessary.Interleave reasoning and action.Interleaving reasoning and acting is more powerful than either alone.Interleaved reasoning-action cycles are superior to decoupled reasoning-only or action-only approaches. Robots that can think (reason step-by-step) AND do (call tools, interact) beat robots that do only one. Pure reasoning (chain-of-thought) hallucinates. Pure action (tool-calling) lacks planning. Together, they're stronger. Chain-of-thought-only approaches risk hallucination (reasoning unsupported by facts); tool-only approaches lack planning and recovery mechanisms. Interleaving provides grounding and adaptivity. Decoupled reasoning-only methods (CoT) suffer from hallucination over training-data knowledge; decoupled action-only methods (RL/imitation learning) lack explicit planning and interpretability. Interleaved reasoning-action cycles combine error correction (Observation feedback) and adaptive planning (Thought-driven adaptation).
2. You don't need to retrain the model.Prompting is enough (few-shot learning).ReAct requires only prompting, not retraining.ReAct operates as a pure prompting-based framework with zero parameter updates. Just show the model a few examples of "think, do, learn, think again," and it learns to follow that pattern. Few-shot in-context learning is sufficient — examples in the prompt teach the model the Thought-Action-Observation pattern without any gradient-based finetuning. The prompting strategy (system instructions + 1-3 example trajectories) is sufficient to enable ReAct behavior in pre-trained models, without requiring task-specific finetuning. The approach relies entirely on pre-trained model in-context learning ability (few-shot adaptation from demonstration trajectories in context), enabling zero-shot and few-shot task deployment without parameter updates.
3. Reasoning helps you act better, and acting gives you data to reason about.Synergy: reasoning guides action; action informs reasoning.Reasoning guides action selection and planning; action feedback enables adaptive reasoning.Bi-directional feedback: Thoughts induce Actions; Observations condition subsequent Thoughts in a closed-loop cycle. Thinking helps you pick the right tool to call. Seeing the results of that tool helps you think better next time. Thoughts are more focused because the agent reasons about what to do. Actions return information that corrects or refines reasoning. This virtuous cycle doesn't exist in pure CoT or pure action. Deliberative Thoughts lead to better-targeted Actions (higher precision tool use). Observations directly improve subsequent Thoughts by providing ground-truth feedback. This creates a dynamic planning loop unavailable in forward-only systems. The closed-loop creates online learning dynamics: Thoughts (state representation) → Actions (information gathering) → Observations (ground truth) → revised Thoughts, enabling iterative refinement and failure recovery without parameter updates.
4. The gains are biggest on tasks that need both planning and real info.Interactive tasks benefit most from ReAct.Interactive/complex tasks show larger gains (34-43%) than knowledge-lookup tasks (6-8%).Performance gains scale with task complexity and environment interactivity (non-deterministic feedback). If you're shopping or navigating a game, ReAct helps WAY more than if you're just looking up a fact — because you need to act and adapt. Knowledge-intensive tasks (QA, fact verification) show 6-8% gains over CoT. Interactive tasks (shopping, household simulation) show 34-43% gains because adaptation to environment feedback is critical. Knowledge-intensive task gains (6-8% over CoT) are moderate because retrieval accuracy still dominates. Interactive task gains (34-43%) are dramatic because the bottleneck is closed-loop planning/adaptation under uncertainty — the key strength of ReAct. Empirically, improvements scale with task complexity and uncertainty: deterministic information-lookup tasks show modest gains (ground truth from tools is primary benefit); non-deterministic interactive tasks show dramatic gains (closed-loop planning becomes essential), supporting the hypothesis that ReAct is most valuable for high-complexity, high-uncertainty problem spaces.
5. This pattern (think-act-learn-think) is how humans actually solve hard problems.ReAct mirrors human problem-solving.ReAct formalizes the cognitive pattern humans use: reason → act → observe → reason again.The Thought-Action-Observation cycle formalizes human expert problem-solving, enabling autonomous agents to employ human-like diagnostic reasoning and adaptive planning. When you solve a hard problem, you think, try something, see what happened, then think again — you don't just think, and you don't just act blindly. ReAct does what you naturally do. The interleaved pattern reflects how humans approach knowledge-intensive and interactive tasks: reason about next steps, take action, interpret results, adapt reasoning. ReAct makes this natural pattern available to language models. Expert problem-solving in knowledge-intensive (research, diagnosis) and interactive (navigation, negotiation) domains naturally follows Thought-Action-Observation cycles: experts reason, act, interpret feedback, and adjust plans. ReAct formalizes this pattern for AI agents. The interleaved reasoning-action cycle reflects demonstrated expert cognition in complex problem domains; formalization as a language-model prompting pattern enables transfer of human-like problem-solving strategies to AI without explicit instruction in domain reasoning or task structure.