Why architecture matters here
ReAct matters because it's the pattern that makes reasoning useful for real tasks. Chain-of-thought improved reasoning by making the model think step by step, but the steps were internal — the model reasoning from what it knows, which for anything factual, current, or requiring action is insufficient (it can't know your data, today's information, or take actions). ReAct grounds the reasoning in reality: by interleaving actions (tool calls that fetch real data or perform real operations) with reasoning, the model reasons about actual observations rather than its priors. This is the difference between an assistant that confidently invents an answer and one that looks it up, reasons about what it found, and answers correctly. For any task requiring external information, computation, or action — which is most real tasks — ReAct is the pattern that connects the model's reasoning to the world, and it's why it became the foundation of agents.
The grounding mechanism is the architectural core, and it's what distinguishes ReAct from both pure CoT and naive tool use. Pure CoT reasons without grounding (internal only). Naive tool use might call a tool but not reason about the result (call, get answer, done — no reasoning loop). ReAct's power is the loop: the observation feeds back into the next thought, so the model reasons about what it learned, decides the next action based on it, and builds toward the answer through grounded steps. A research task: think ('I need to find X'), act (search X), observe (results), think ('the results suggest Y, but I should verify Z'), act (search Z), observe, think ('now I can conclude'), answer — each step grounded in the previous observation, the reasoning and acting interleaved so each informs the other. This interleaving — reasoning guiding actions, observations informing reasoning — is what makes ReAct capable of multi-step grounded problem-solving.
And the evolution from prompt pattern to native tool calling reflects a maturation worth understanding. Original ReAct was a text-based prompt format: the prompt taught the thought/action/observation structure with examples, and the system parsed the model's text output to extract actions (fragile — parsing free text for tool calls). Modern models have native function calling: the model emits structured tool calls directly (reliable, no parsing), and the ReAct loop is implemented by the agent framework (feed the tool result back, let the model reason and call again). The pattern is the same (reason, act, observe, repeat), but the implementation is more robust (structured tool calls versus text parsing). For anyone building agents today, ReAct is the conceptual foundation, native tool calling is the implementation, and understanding the pattern (the grounded reasoning loop) matters more than the specific format — because the loop is the essence of agentic behavior, whether expressed as parsed text or native function calls.
The architecture: every piece explained
Top row: the loop. A thought is the model's reasoning about the current state — what it knows, what it needs, what to do next ('I need to find the customer's order status, so I should look up their order'). An action is a tool call — the concrete operation the thought decided on (look_up_order(id)). An observation is the tool's result — the real data returned (the order status, the search results, the calculation). The loop repeats: the observation informs the next thought, which decides the next action, until the model has enough to produce a final answer — the grounded, multi-step reasoning that ReAct enables.
Middle row: the mechanics and comparisons. The prompt format (in text-based ReAct) structures the interaction: a prompt teaching the thought/action/observation template with examples, so the model produces outputs in that structure — or, in modern ReAct, native tool schemas defining the available actions. Tool grounding is the key property: the reasoning incorporates real observations, so the model reasons about actual data rather than priors — the anti-hallucination mechanism. vs pure CoT: pure chain-of-thought reasons internally (no grounding, no actions) — good for reasoning that doesn't need external data (math, logic), insufficient for tasks needing facts or actions; ReAct grounds reasoning in tool results. Termination: the model must signal when it has the answer (a 'Final Answer:' marker in text ReAct, or simply responding without a tool call in native) — the loop ends when the model produces a final answer rather than another action.
Bottom rows: robustness and modernity. Error recovery: when an action fails (a tool errors, returns nothing useful, or the wrong result), the observation of the failure feeds back into the next thought, and the model can rethink — try a different tool, different arguments, or a different approach — the loop's resilience to failed actions. Native tool calling is modern ReAct: structured function calls (reliable, no text parsing) implementing the same reason-act-observe loop, with the agent framework managing the loop (feed tool results back, continue until final answer). The ops strip: loop limits (max iterations to prevent infinite loops — a model that keeps acting without converging must be bounded), trajectory evaluation (assessing not just the final answer but the reasoning-action path — did it take sensible steps, use the right tools?), and prompt design (the thought/action format, tool descriptions, and examples that make the model reason and act well).
End-to-end flow
Trace a ReAct trajectory on a real task: 'what was our revenue growth from the product launched in Q2, and how does it compare to the previous product?'. The model reasons and acts: Thought ('I need to identify the Q2 product first'), Action (search_products(quarter=Q2)), Observation (Product X launched Q2). Thought ('now I need Product X's revenue'), Action (get_revenue(Product X)), Observation ($2M). Thought ('I need the previous product and its revenue to compare'), Action (get_previous_product(X)), Observation (Product W), Action (get_revenue(Product W)), Observation ($1.5M). Thought ('now I can compute growth: X is $2M vs W's $1.5M, 33% higher'), Final Answer (grounded in the real data gathered). Each step grounded in the previous observation, the reasoning guiding which tool to call next, the answer built from real data rather than invented — the ReAct loop solving a multi-step task that pure CoT (no data access) couldn't.
The error-recovery vignette shows the loop's resilience. In one trajectory, an action fails: Action (get_revenue(Product X)), Observation (Error: product not found). Rather than failing the whole task, the failure observation feeds into the next thought: Thought ('the product name might be wrong; let me search for the exact name first'), Action (search_products(name~X)), Observation (exact name is 'Product X Pro'), Action (get_revenue(Product X Pro)), Observation ($2M). The model recovered from the failed action by rethinking — the loop's ability to incorporate failures and adapt, versus a rigid pipeline that would have failed. This error recovery is a key ReAct strength: actions fail, and the reason-about-the-failure-and-retry loop handles it gracefully.
The termination and modern-implementation vignettes complete it. A termination issue: a model that keeps acting without converging (searching repeatedly, never deciding it has enough) — the loop limit (max 10 iterations) bounds it, and if hit, the model is prompted to answer with what it has or the task escalates. The team's implementation uses native tool calling: the model emits structured tool calls (reliable, no text parsing of 'Action: ...'), the framework executes them and feeds results back, and the model responds without a tool call when done (termination) — the modern, robust ReAct. They evaluate trajectories (not just final answers): eval cases assert the model took sensible steps (used the right tools, didn't loop unnecessarily, recovered from errors) — because a right answer from a bad trajectory (lucky, or inefficient) is fragile, and trajectory evaluation catches reasoning-path problems the final answer hides. The consolidated discipline: structure the reason-act-observe loop (native tool calling for reliability), ground reasoning in real observations (the anti-hallucination core), handle failed actions via rethinking (error recovery), bound the loop (iteration limits), and evaluate trajectories not just answers — because ReAct is the foundation of agentic reasoning, connecting the model's thinking to the world through grounded action loops, and its power (and its failure modes) live in the loop.