ReAct,
explained.

Rung 1, and the comparison is against reasoning in a closed loop. A model reasoning step by step with no access to anything outside itself can reason fluently from a false premise — each step follows plausibly from the last, and nothing in the process can discover that the second step was wrong. The failure is confident and internally consistent, which is the worst combination.

The change is to interleave reasoning with actions that return results: a thought, then an action in the world, then the observation it produced, then the next thought conditioned on that observation. The loop runs both ways, and both directions matter. Reasoning makes the action better — the model decides what to look up rather than searching blindly. And the observation makes the reasoning better, because a claim that contradicts what just came back from a tool is corrected against something external rather than elaborated.

Stated in the units the ladder cares about: acting without reasoning gives a model no way to plan a sequence of lookups, and reasoning without acting gives it no way to be wrong about facts. The pattern is grounding — every few steps, the chain is anchored to something that was not generated. And it costs nothing to adopt, because like rung 1 of the reasoning ladder it is a prompting pattern rather than a model: no training, no parameters, no gradient.

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.

Being a prompting pattern is also the limitation. Reliability is entirely the underlying model's, and the characteristic failures were visible immediately: agents that loop, repeating the same search with the same query and the same result; agents that take an action whose observation they then ignore; agents that stop early. Nothing in the pattern prevents any of these, because the pattern is a suggestion about output format.

It is also memoryless across episodes. Whatever the agent works out is lost when the task ends, so the same mistake is available to be made again tomorrow. Rungs 3 to 6 are each an answer to that one sentence.

How it held up: this is the agent loop. Every framework, every tool-calling API, every deployed agent on this site runs thought, action, observation, repeat — sometimes with the labels hidden inside a structured tool-call interface, which is the same loop with better plumbing. Its adoption was so complete that the paper's contribution is easy to understate: before it, "language model uses a tool" and "language model reasons" were separate research directions, and the useful observation was that each one repairs the other's main weakness.

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.

Answer each one out loud before you open it. Recalling an answer is what makes it stick; recognising one you have just read is not. Your score is kept on this device.

Give the model a tool, then a loop, then a memory, then a world. Ends on the 2026 paper measuring how badly the whole stack degrades over many turns.

1. 1ReAct2023
2. 2Toolformer2023
3. 3Reflexion2023
4. 4Voyager2023
5. 5Generative Agents2023
6. 6MemGPT2023
7. 7LLMs Get Lost in Multi-Turn Conversation2026

All 110 papers, in 19 ladders →