Reasoning and Acting, The ReAct Loop Behind AI Agents
A language model that solves problems purely through reasoning has one fundamental limitation. Faced with a question that needs current information or specialized knowledge outside its training data, it has no choice but to answer confidently and wrongly, and once its reasoning drifts off course early on, nothing corrects that error before it reaches the final answer. On the other side sits a different approach entirely: an agent that tries to solve tasks purely by acting. Trained through reinforcement learning or imitation learning, this kind of agent decides what to do at every moment, but without a high-level plan behind those choices, or working memory to hold that plan across multiple steps, it loses the thread the moment a task runs even a little long and fails to reach the outcome it was after.
ReAct ties these two approaches into a single loop, letting one side's strength cover for the other's limitation. In this cyclical structure, reasoning (Thought) sets the plan for an action (Action), and the observation (Observation) that action brings back becomes the grounding for the next round of reasoning — letting the model actually interact with the outside world while keeping that interaction under deliberate control. First proposed in 2022, this loop remains, to this day, the first thing most people reach for when designing a single agent.
This post traces the problem ReAct was built to solve, breaks down its standard architecture, looks at what problem-solving abilities this cyclical loop actually produces, and finishes with how far the approach has come as of 2026.
Where ReAct Came From
The 2022 paper "ReAct: Synergizing Reasoning and Acting in Language Models," from a joint team at Princeton University and Google Research, set out from exactly this problem. Chain-of-Thought prompting, widely used at the time, had pushed accuracy up considerably by having models spell out their reasoning step by step in natural language — but that reasoning stayed strictly within whatever the model had already learned. Action-only agents built on reinforcement learning or imitation learning, on the other hand, could interact directly with an environment, but without an explicit reasoning process behind those actions, it was hard to say why they made the choices they did, and they drifted off course easily on any task that ran long.
The researchers' key insight was that these two could compensate for each other. Reasoning would take on the job of setting, maintaining, and revising an action plan ("reason to act"), while the outside information an action brought back would in turn update the grounds for reasoning ("act to reason") — with the two processes generated in alternation, within a single continuous flow.
The effect showed up clearly across several tasks. On HotpotQA, a multi-hop question-answering benchmark, ReAct on its own scored 27.4% exact match — slightly behind the 29.4% chain-of-thought managed alone — while combining the two as ReAct→CoT-SC reached 35.1%, ahead of both. On ALFWorld, an embodied decision-making task, it beat imitation learning by 34 percentage points in absolute success rate, and on WebShop, a web-navigation task, it beat reinforcement learning by 10 points. What drew even more attention was that all of this was achieved with no fine-tuning at all — just one or two few-shot examples and a prompt. At the time, that upended the assumption that building an agent meant training a dedicated model, and it helped set off the rapid spread of prompt-based agent design that followed.
The Standard ReAct Architecture
What the ReAct paper proposed wasn't a specific implementation but an interaction pattern — but as people actually built it out, a handful of components became the de facto standard.
| Component | Role |
|---|---|
| LLM reasoning core | Takes the trajectory accumulated so far as context and generates the next Thought and Action |
| Action (tool) executor | Converts the Action the model generates into an actual tool call or API request and executes it |
| Trajectory / memory | The accumulated record of Thought, Action, and Observation in sequence, which becomes the context for the next Thought at every step |
| External environment | The actual target the executor calls — a search engine, an API, a code executor, a database — whose result comes back as an Observation |
The standard components of a ReAct agent
Of the four, the trajectory and memory component is the one whose role gets underestimated most often. It isn't just a log — it's the context that itself governs the model's next decision. The longer the trajectory grows, the more grounding the model has to work with, but context length and cost grow right along with it, a point this post comes back to later.
How Reasoning and Acting Cycle Together
How these four components actually mesh together in practice comes down to the following cycle.
The basic ReAct cycle
This cycle repeats until a stopping condition is met — either the model has produced a final answer or has decided no further action is needed. Every turn through the loop adds one more step to the trajectory, so the longer the loop runs, the longer the context grows — a point that connects directly to the practical limitations covered later in this post.
What the Loop Actually Improves
The first is grounding. Faced with a question about information that isn't in its training data, reasoning alone can only produce an answer that sounds plausible but has nothing backing it. The ReAct loop handles this by running a search Action, taking the actual search results back as an Observation, and building the next Thought on top of that. The answer ends up built on information that was actually verified, not guessed at.
The second is self-correction through feedback. If a search Action comes back with irrelevant results, a single-pass approach just accepts that and stops there. In a loop, by contrast, the next Thought can evaluate those results, reason about why they missed the mark, and move on to a new Action — narrowing the search terms or trying a different approach entirely. An error becomes something the agent can recover from on the spot, rather than something it has to live with.
The third is gradual, multi-step information gathering. In multi-hop tasks that require pulling from several documents or making several queries to answer one question, each Observation becomes a clue for what to check next. Much of the gain that showed up when ReAct was combined with CoT on multi-hop benchmarks can be traced back to this incremental-gathering ability.
The fourth is dynamically revising the plan. The environment doesn't always respond the way you planned for. When a tool call fails or returns a state you didn't expect, being able to change course on the spot is what lets an agent actually finish the task. ReAct's large margin over imitation-learning baselines on embodied, multi-step tasks like ALFWorld is good evidence that this kind of improvised replanning genuinely works in practice.
All four, at bottom, come from one property: every step's judgment gets updated based on what actually happened in the step before it. That capacity to update is what turns ReAct from a mere prompting technique into something that meets the minimum bar for what it means to be an agent at all.
In 2026: Still the Default, With Real Limits
Several 2026 agent-architecture guides still point to ReAct as the first thing worth trying when designing a single agent. The approach that's taken hold in practice is to build the ReAct baseline first, measure success rate, tool-call accuracy, latency, and cost, and only then decide whether another pattern belongs on top of it.
At the same time, real production limits have surfaced. According to one 2026 agent-architecture guide, long runs past roughly 50 steps tend to see coherence break down as the trajectory grows too long, and without some kind of reflection mechanism in place, agents tend to repeat the same mistakes. The same source reports that prompt-cache invalidation, more frequent the longer a loop runs, can drive costs up five to tenfold.
A handful of combinations have become the de facto standard for managing this. Pairing the loop with a reflection mechanism like Reflexion — something that looks back at its own past failures — can cut repeated mistakes by 10 to 30%. Re-anchoring the context every 30 to 40 steps heads off the cost spikes that come from cache invalidation. And for high-stakes output where accuracy or compliance matters, a separate verifier-critic gets paired in for a second check. Of these, ReAct paired with Reflexion has become the de facto standard for a production-grade single-agent stack as of 2026.
In Summary
ReAct's core comes down to one idea. Generate reasoning and action in alternation, and the result an action brings back becomes the grounding for the next round of reasoning, which in turn sets the direction for the action after that. The LLM reasoning core, the action executor, the trajectory and memory, and the external environment are the minimum set of parts that make up this cycle, and grounding, self-correction, incremental information-gathering, and dynamic replanning are all downstream of this one cycle.
That's also why ReAct has held its place as the starting point for single-agent design since it first appeared in 2022. That said, the longer a loop runs, the longer the trajectory it has to manage grows — and that can start to erode consistency. Which is why using ReAct in practice today increasingly means pairing it with reflection, context re-anchoring, and verifier pairing together, and that combination is where the technology is headed to make it more stable.