ReAct,
explained.

By 2022 there were two ways to get more out of a language model, and each broke in its own way. Reasoning-only (chain-of-thought) let the model think in steps — but with no access to the outside world, it would reason its way to a confident, wrong answer, hallucinating facts it had no way to check.

Acting-only approaches let the model call tools — search, APIs — but with no reasoning between calls, it flailed: it couldn't plan a sequence of lookups, recover from a dead end, or decide what to do with what it found.

ReAct — short for Reasoning + Acting — simply interleaves them. The model is prompted to alternate between thinking about what to do and doing it, feeding each result back into the next thought. Reasoning decides the next action; the action's result grounds the next round of reasoning.

It's how a person actually researches something: think about what you need, look it up, read what you found, adjust your plan, look up the next thing. Not pure thought, not blind clicking — a conversation between the two.

Concretely, the model cycles through three moves until it can answer:

The observation isn't the model's guess — it's a real result from a real tool. That's the whole point: each loop injects a fact from outside the model's memory.

No single fact was memorized. The model reasoned about what to fetch, fetched it, and let each observation steer the next step to the answer.

The magic is the synergy. Reasoning makes acting smarter — the model plans which tool to call and why, and recovers when a search comes back empty. Acting makes reasoning honest — every observation is a fact from the world, so the chain of thought can't quietly drift into fiction.

The whole method is one repeated step, and the arrow that matters is the last one — the observation feeds the next thought:

Strip the Observations out and you have plain reasoning — which, on a multi-hop question, has nothing to look up. The runnable version below solves the Apple Remote question both ways.

On knowledge-heavy question answering (HotpotQA) and fact verification (FEVER), ReAct beat acting-only agents and hallucinated less than reasoning-only chain-of-thought. On interactive decision-making benchmarks — ALFWorld and WebShop, where an agent must navigate an environment toward a goal — it outperformed imitation- and reinforcement-learning methods by large margins with just a couple of prompt examples.

A bonus the authors highlight: the interleaved trace is human-readable, so you can see why the agent did what it did — and even correct it mid-run.

ReAct is the conceptual backbone of the entire agent era. Function calling, web-browsing assistants, coding agents, research agents — nearly all of them run some version of the Thought–Action–Observation loop this paper named. Frameworks like LangChain and the tool-calling APIs of every major model provider are, at heart, machinery for running ReAct loops.

It gave the field its simplest, most general recipe for turning a next-token predictor into something that can pursue a goal: let it think, let it act, and let what it observes shape what it thinks next.

ReAct — Reasoning + Acting — is the pattern nearly every AI agent runs today. The model interleaves a thought (reason about what to do next), an action (call a tool), and an observation (read the result), then loops. Reasoning alone can't touch the world; acting alone can't plan; ReAct fuses them so the model thinks about what to do, does it, sees what happened, and thinks again.

The key win is grounding. A model reasoning in a vacuum drifts and hallucinates; ReAct forces it to check its thinking against real observations from tools — a search result, an API response, a file's contents. Each action injects fresh facts, so the reasoning stays anchored to reality instead of spiraling into plausible fiction. That feedback loop is what makes tool-using agents trustworthy enough to be useful.

It also makes the agent's behavior legible: the interleaved thoughts are a visible trace of why it took each action, which is invaluable for debugging and trust. And the pattern is general — the same thought/action/observation loop works for web browsing, coding, question-answering over tools, and multi-step task completion, regardless of the specific tools.

The line to today is as direct as it gets: this is the agent loop. Modern agent harnesses are ReAct with more engineering around it — structured tool schemas, error handling that feeds failures back as observations, memory, and stopping conditions — but the plan-act-observe core is exactly what ReAct named. If you understand ReAct, you understand the skeleton of every agent framework in use.