ReAct: Combining Reasoning With Actions
See why writing down reasoning between actions makes agents more reliable, and what ReAct looks like.
Imagine an agent asked: “Is the warehouse that ships order N-4471 open on Saturday?” It’s a two-hop question. First find which warehouse ships the order, then check that warehouse’s opening hours.
A model answering straight away, without tools, confidently invents something: “Yes, our warehouses open Saturdays 9 to 1.” An agent that acts without thinking does a bit better, calling tools, but it can lose the thread: look up the order, then check the hours of the wrong warehouse, because nothing connected the two steps.
ReAct, short for “reasoning and acting”, interleaves the two. Before each action, the model writes a short thought: what it knows, what it still needs, and why the next action helps. After each observation it reasons again. The thoughts work like the chain of thought from Track 2: they give the model room to plan, keep track of what it has learned, and notice when something doesn’t add up.
Written-down reasoning has two more benefits:
- Better plans: the model can break a goal into steps, and revise them when an observation surprises it.
- Visible reasoning: when an agent goes wrong, the trace shows where, which makes debugging far easier.
The original 2022 ReAct paper used written “Thought:”, “Action:” and “Observation:” lines in the prompt. Today the pattern is built into models: reasoning models think before calling tools, and APIs handle tool calls natively. The labels have gone, but the idea underneath every capable agent is the same: think, act, look, think again.
Key takeaways
- ReAct interleaves reasoning (thoughts) with actions (tool calls) and observations.
- Thoughts help the agent plan, track what it knows, and connect the steps of a multi-step task.
- Without tools, models guess; without reasoning, agents lose the thread.
- Modern models build this pattern in, but the idea is the same: think, act, look, think again.
Check your understanding
Go deeper (more technical)
ReAct was introduced by Yao and colleagues in “ReAct: Synergizing Reasoning and Acting in Language Models” (2022), which showed gains on question-answering and interactive tasks over reasoning-only or acting-only prompting.
Related patterns include plan-and-execute (write a full plan first, then carry it out), and reflection (after an attempt, critique it and try again). As Track 2 noted, a model’s written reasoning isn’t always a faithful account of how it decided, so traces are a guide, not proof.
The simulation’s warehouse scenario is made up.