What it is
ReAct is a prompting pattern — and the de facto scaffold for agentic LLM systems — that structures each agent step as a Thought → Action → Observation triple. The model writes a reasoning trace (Thought), issues a tool call or environment action (Action), receives the result (Observation), and repeats until the task is complete or a stopping condition is met. The loop is closed: the model's own reasoning is conditioned on real external feedback, not just its prior context.
This distinguishes ReAct from pure chain-of-thought prompting, which generates a reasoning trace but never queries external state. ReAct agents can search the web, execute code, call APIs, read files, and recover from errors mid-trajectory — capabilities that make them useful for multi-hop question answering, software engineering, legal research, cybersecurity, and retrieval pipelines.
How it works
`` ┌─────────────────────────────────────────────┐ │ Thought: "I need to look up case X..." │ │ Action: search("case X competition law") │ │ Observation: [retrieved document chunk] │ │ Thought: "The document says... I should…" │ │ Action: generate_citation(...) │ │ Observation: [citation string] │ │ Thought: "Task complete." │ │ Final Answer: ... │ └─────────────────────────────────────────────┘ ``
Each turn is a node in the agent's trajectory. The model's context grows with each Observation, giving it a running record of what it has tried and learned. This makes ReAct naturally suited to hierarchical tool orchestration: a single agent can chain retrieval, computation, and generation steps within one trajectory.
Why it matters
ReAct's simplicity is its durability. Because it requires no architectural change to the underlying model — only a prompting convention and tool-call infrastructure — it has become the default scaffold across open-weight and proprietary systems alike. Nvidia's NeMo Retriever topped the ViDoRe v3 retrieval leaderboard using a ReAct-based agentic loop. Maat, a domain-specific legal research assistant for competition law, uses ReAct to orchestrate RAG retrieval, web search fallback, and citation generation, outperforming general assistants (Claude, ChatGPT) and legal-specific models on case-specific tasks. Google's Aletheia math research agent, achieving 95.1% on IMO-Proof Bench Advanced, also operates in this paradigm.
Robustness: the stealth-divergence problem
A 2026 empirical study across 10 LLMs from 7 architecture families — validated on a held-out 11th model with 1,800 trajectories — quantified a critical failure mode: semantic perturbations (paraphrase, synonym substitution) cause final-answer inconsistency ~19.69 percentage points more often than surface-level perturbations (formatting, reordering) of comparable severity, across GSM8K, MATH, and HotpotQA. Trace-level analysis reveals a "stealth-divergence" pattern: the first action is typically preserved, but intermediate reasoning steps silently drift, producing a wrong answer with a plausible-looking trajectory. This is a harder failure to detect than an outright error, because the agent's scratchpad looks coherent.
The implication for practitioners: ReAct agents are more sensitive to input phrasing than surface-level robustness tests suggest, and evaluation suites that only perturb formatting will miss this class of failure.
Extensions: memory, RL training, and multi-agent delegation
Three active research directions extend the base ReAct loop:
Memory without retraining (FORGE). FORGE wraps a Reflexion-style inner loop where a reflection agent converts failed trajectories into textual heuristics or few-shot demonstrations, then propagates the best-performing instance's memory across a population of agents between stages — no gradient updates required. On CybORG CAGE-2, a stochastic network-defense POMDP, FORGE improves average return 1.7–7.7× over zero-shot ReAct and 29–72% over Reflexion across 12 model-representation conditions. Notably, weaker models benefit disproportionately, suggesting the method may help close capability gaps.
RL training over turns (TRACE). TRACE models each ReAct thought-action-observation turn as a distinct tree node, enabling reinforcement learning budget allocation across both prompt-level and turn-level prefixes rather than only at the prompt level. A shared predictor estimates conditional success probability at each anchor to guide sampling. Empirically, TRACE improves Qwen3-14B multi-hop QA accuracy by 2.8 points over baselines at equal sampling cost — a meaningful gain from better exploiting the tree structure that ReAct trajectories naturally form.
Multi-agent delegation (WebSwarm). Single-agent ReAct has known limits on tasks requiring simultaneous depth and breadth — exhaustive web research being the canonical case. WebSwarm addresses this with recursive multi-agent delegation: each agent node couples a local objective with a search mode and can either solve its task or spawn child agents, passing evidence upward for aggregation. It outperforms single-agent and flat multi-agent baselines on BrowseComp-Plus, WideSearch, DeepWideSearch, and GISA benchmarks.
Variants and alternatives
| Approach | Core mechanism | Key strength | Key limitation | |---|---|---|---| | ReAct (base) | Thought → Action → Observation loop | Simple, general, tool-agnostic | Single-agent; brittle to semantic perturbations | | Reflexion / FORGE | ReAct + failure reflection → textual heuristics; population broadcast | Improves weaker models most; no gradient updates | Requires multiple rollouts | | TRACE | ReAct turns as tree nodes; RL budget allocation per turn | +2.8 pts multi-hop QA at equal cost | Adds RL training complexity | | WebSwarm | Recursive multi-agent delegation; evidence aggregation | Handles deep-and-wide search | Higher orchestration overhead | | Chain-of-Thought | Reasoning scratchpad only; no tool calls | Robust for closed-book tasks | Cannot query external state |
When to use it — and when not to
Use ReAct when the task requires querying external state (search, APIs, code execution), when the number of steps is variable and unknown in advance, and when you want a human-readable audit trail of the agent's reasoning.
Watch for the stealth-divergence failure when input phrasing is not tightly controlled — evaluation suites should include semantic perturbations, not just formatting variants.
Consider FORGE or Reflexion when you need the agent to improve across episodes without retraining, especially with weaker base models.
Consider TRACE when you are training an agent with RL and want to exploit the turn-level tree structure of ReAct trajectories for better sample efficiency.
Consider multi-agent delegation (WebSwarm-style) when the task requires both deep and broad search simultaneously — the single-agent ReAct loop becomes a bottleneck there.
Evaluate beyond task success for personal or high-stakes deployments: the SovereignPA-Bench benchmark argues that agent evaluation must extend to privacy preservation, consent compliance, and manipulation resistance — dimensions the base ReAct loop does not address by design.
