Reasoning & the ReAct Pattern

Give a model a hard question and you can do one of two things. You can let it reason — "think step by step" — but pure reasoning runs on whatever is in its head, so it confidently invents facts. Or you can let it act — call a search tool, run code — but pure action with no reasoning is blind: it can't plan, can't recover from a surprise, and you can't see why it did anything.

ReAct's insight is that you should not choose. You interleave them. The model thinks a little, takes one action, looks at what actually came back, then thinks again with that new fact in hand. Reasoning decides the next action; the observation grounds the next thought.

That single move — closing the loop between thinking and the real world on every step — is what makes an agent an agent. The reasoning keeps the actions purposeful and recoverable. The observations keep the reasoning honest, because each thought is now built on a real result rather than a guess. ReAct (Reasoning + Acting), introduced by Yao et al. at ICLR 2023, is the canonical name for this loop, and it is the backbone of essentially every tool-using agent you will build.

The mechanics are simple. The agent repeats three moves until it can answer:

1. Thought — a free-form reasoning trace: what do I know, what's missing, what should I do next?
2. Action — an invocation of a tool or the environment, with arguments (Search["..."], calculator(2+2), a database query).
3. Observation — the result the tool or environment returns, fed straight back into the next Thought.

The loop runs Thought → Action → Observation → Thought → ... until the model decides it's done and emits a Final Answer. A controller (your code, or a framework) drives it: it sends the running transcript to the model, executes whatever action the model emits, appends the observation, and asks the model again.

The original ReAct paper grounded reasoning in a Wikipedia API and beat strong baselines exactly where grounding matters: on interactive decision-making it improved over imitation- and RL-trained baselines by 34% absolute on ALFWorld and 10% on WebShop using only 1–2 in-context examples, and it cut hallucination on knowledge tasks (HotpotQA, FEVER) by anchoring each step in a real lookup instead of the model's memory.

The pattern is easiest to grasp as a transcript. Here a multi-hop question forces the agent to gather a fact, then use it:

Question: Who is older, the director of "Oppenheimer" or the director of "Dune"?

Thought: I need the directors of both films, then their birth years.
Action: Search["director of Oppenheimer (2023 film)"]
Observation: Christopher Nolan directed Oppenheimer (2023).

Thought: Now I need the director of Dune.
Action: Search["director of Dune (2021 film)"]
Observation: Denis Villeneuve directed Dune (2021).

Thought: I need both birth years.
Action: Search["Christopher Nolan birth year; Denis Villeneuve birth year"]
Observation: Nolan born 1970; Villeneuve born 1967.

Thought: Villeneuve (1967) is older than Nolan (1970).
Final Answer: Denis Villeneuve, the director of Dune, is older.

Notice three things. Each Thought narrates the plan, so the transcript is self-documenting. Each Action is concrete and parameterized. Each Observation is a real fact that the next Thought reasons over — the agent never has to recall Nolan's birth year from memory, so it can't hallucinate it. This visible, step-by-step trace is why ReAct agents are far more debuggable and auditable than black-box approaches: every reasoning step and tool call is right there to inspect.

Here's the punchline first: every time you use a tool-calling API, you are already running ReAct — you just don't see the labels. The original paper parsed actions out of text like Search["query"], which was brittle. Modern agents skip the parsing and use function calling instead, and that is simply ReAct with a reliable wire format. The mapping is exact:

The orchestration loop is the same one the paper describes (shown here using the OpenAI Python SDK idiom):

import json

messages = [{"role": "user", "content": question}]
for _ in range(MAX_STEPS):
    resp = client.chat.completions.create(
        model="gpt-4o", messages=messages, tools=tools
    )
    msg = resp.choices[0].message
    if not msg.tool_calls:
        break  # no Action -> this is the Final Answer
    messages.append(msg)                         # the model's Thought + Action
    for call in msg.tool_calls:                  # execute each Action
        args = json.loads(call.function.arguments)
        result = TOOLS[call.function.name](**args)
        messages.append({"role": "tool",         # the Observation
                         "tool_call_id": call.id,
                         "content": str(result)})
final = msg.content

LangGraph's create_react_agent (from langgraph.prebuilt) is this loop, productionized: call model → if tool_calls present, run the tools and append results, repeat; if none, return the response. Same Thought/Action/Observation semantics — now with structured JSON, type safety, and tracing.

Think of two ways to take a road trip. ReAct is driving with live traffic: decide each turn only after seeing what's ahead — it's reactive. The main alternative, plan-and-execute, is mapping the whole route before you leave: a planner LLM writes the full sequence of steps up front, then an executor runs them one by one (often with a smaller, cheaper model).

The trade-off is adaptability versus predictability:

Use ReAct when intermediate results change what's needed next — research, debugging, anything in a messy or partially observable environment. Use plan-and-execute when the whole step sequence is knowable in advance and you want cost predictability or a human checkpoint before anything runs. Neither is strictly better: if the environment shifts mid-task, plan-and-execute pays for a costly re-planning call, while ReAct simply adjusts on its next thought.

ReAct is foundational, not flawless. Its core weakness: the generated thoughts aren't guaranteed to be grounded in the agent's real history or goal. In complex, partially observable tasks a thought can drift from what actually happened, and because each step builds on the last, that misalignment compounds. The 2025 ReflAct framework (arXiv:2505.15182) targets exactly this, replacing action-prediction thoughts with explicit goal-state reflection at each step.

There's also a subtler shift. With modern reasoning models — OpenAI o3/o4-mini, DeepSeek-R1, Claude extended thinking — the Thought step is handled internally by an RL-trained reasoning process before the model emits its action. You usually should not hand-write Thought: scaffolding in the prompt for these models; explicit thought prompts are often unnecessary and can hurt performance. The ReAct loop is unchanged — Action and Observation still flow through tool calls — but the Thought has moved inside the model.

Finally, remember ReAct doesn't always win. On some pure-QA tasks plain chain-of-thought-with-self-consistency was competitive. ReAct's edge is specifically tasks needing external information or action; if no tool is involved, it has nothing to ground on.