The ReAct Pattern

This cover frames the entire day. The two failure modes named in the hook — a brilliant guesser and a blindfolded robot — are exactly what ReAct is designed to fix. An LLM reasoning in isolation produces fluent logic with no way to check its facts; an LLM calling tools without reasoning pokes at the world with no plan. ReAct fuses them so reasoning guides action and action grounds reasoning.

The goal of this post is to install one mental model before any code: ReAct is an interleaved loop of thinking and doing, narrated out loud. Everything else in the day builds on that loop.

The definition matters because ReAct is often described as something exotic when it is really a discipline imposed on the model's output. Instead of asking for an answer, you ask the model to alternate between reasoning in plain language and emitting concrete actions — almost always tool calls. The name is literal: Reason plus Act, interleaved rather than sequential.

The practical consequence is that the model is no longer a one-shot oracle. It becomes a controller that decides, step by step, whether it has enough information to answer or whether it needs to go get more. That shift from 'answer now' to 'decide what to do next' is the whole idea.

This slide names the three primitives every ReAct step is made of. A Thought is the model's private reasoning about what to do next. An Action is a concrete, executable tool call with arguments. An Observation is the result of that action, fed back into the transcript. The model cycles Thought, Action, Observation until a Thought concludes it can finally answer.

Keeping these three roles distinct is what makes ReAct legible. The Thought is where planning lives; the Action is where the model touches the world; the Observation is the world's reply. When an agent misbehaves, you can almost always point to which of the three went wrong.

The cycle diagram shows the loop that defines the pattern: Thought leads to Action, Action produces an Observation, and the Observation feeds the next Thought — repeating until the task is answerable. The arrows are the point. Each pass refines the model's understanding before it commits to the next move.

Reading it as a cycle rather than a line is important. A pure chain-of-thought is a straight line from question to answer with no feedback. ReAct bends that line into a loop so that reality can intervene between every reasoning step, which is precisely what stops the model from running confidently off a cliff.

This slide diagnoses the failure of reasoning alone. Chain-of-thought prompting makes a model reason in steps, which improves logic but does nothing to ground it in fact. Ask about something outside its training data and it will produce a confident, plausible, and wrong answer, because it has no mechanism to check itself.

The deeper point is that fluency is not truth. A model optimized to sound right will fill any factual gap with something that reads well. Pure reasoning amplifies this: the more elaborate the reasoning, the more convincing the eventual fabrication. ReAct's answer is to let the model verify against the world mid-reasoning rather than trusting its own recall.

Here is the mirror-image failure: acting alone. Hand a model tools but no room to reason and it calls them reflexively — the wrong tool, malformed arguments, no plan connecting one call to the next. When a result surprises it, there is no Thought in which to react, so it cannot recover.

The insight is that tools do not make an agent; deliberate tool use does. The explicit Thought before each Action is what turns a pile of available functions into a coherent strategy. Without it you get reflexive tool-poking that rarely converges on a correct answer, even when every individual tool works perfectly.

The comparison sets the three modes side by side so the value of interleaving is undeniable. Reason-only is fluent but ungrounded. Act-only is grounded but planless. Neither can recover from a surprising result. ReAct, by combining them, lets a Thought plan each Action and an Observation ground each subsequent Thought — and crucially, it can self-correct mid-task.

The column on the right is the whole thesis of the day. Self-correction is the emergent property you only get when reasoning and acting are interleaved. A surprising Observation becomes a new Thought instead of a blind retry, which is what separates an agent from a script.

This slide explains why interleaving specifically wins, beyond just having both ingredients. The mechanism is feedback: each Observation updates the model's reasoning before it commits to the next action. That feedback loop is what makes the difference between a plan that adapts and a plan that plows ahead regardless of reality.

The two crisp claims to remember are that reasoning makes actions deliberate and actions make reasoning honest. Deliberate, because every Action is preceded by a Thought that justifies it. Honest, because every Thought after the first is conditioned on real Observations rather than the model's imagination.

The trace makes the abstract loop concrete with a two-hop question that pure reasoning would likely fluff. The model can't reliably recall the director of a specific film and their exact age, so it decomposes the problem: find the director, then find their birth year, then do the arithmetic. Each Thought sets up an Action; each Observation feeds the next Thought.

Notice the final Thought does the math in the open before answering. This is the pattern's honesty on display — the reasoning and the grounded facts are both visible, so a reader can audit every step. That visible chain is exactly what the rest of the day exploits for debugging, grounding, and trust.

The recap compresses the post into a model you can recall instantly. ReAct equals Reasoning plus Acting, interleaved. The loop is Thought, then Action, then Observation, repeated. Thought plans, Action grounds, and you repeat until you can answer. Reasoning fixes blind tool use; acting fixes ungrounded reasoning.

Carry this into the rest of the day. The 'why' post argues why this pattern took over agent design, the 'how' post shows the loop and prompt in detail, the code post hands you a runnable agent, and the mistakes post shows how the same loop fails without guardrails.

The CTA points forward to the stakes. Knowing what ReAct is matters, but the next post explains why it became the default architecture for LLM agents — how it turns a chatbot that answers from memory into an agent that can go and find out.

Save this one as the conceptual anchor for the series. Every later post in the day assumes you already hold the Thought-Action-Observation loop introduced here.