ReAct Pattern

ReAct: Reasoning + Acting in One Loop

The 2022 paper that had models think between tool calls, and the pattern that tool-use APIs later built in. What it showed, what a trace looks like, and how it fails.

One episode, line by line

ReAct started as a prompting format: labelled lines in one growing transcript. The model writes a Thought and an Action; the runtime runs the action and appends the Observation.

Adapted from the paper’s opening HotpotQA example; observations abridged.

Why interleaving works

The paper’s claim is a two-way benefit. Neither half does the job alone, which is what its reason-only and act-only baselines were built to show.

What the paper showed

Yao et al., ReAct: Synergizing Reasoning and Acting in Language Models (posted October 2022, ICLR 2023). The main results prompt PaLM-540B with a handful of worked examples and no fine-tuning, and give it a simple Wikipedia API (search, lookup) for the knowledge tasks.

The honest reading: on HotpotQA, ReAct alone did not beat chain-of-thought. It failed differently: chain-of-thought mostly by inventing facts, ReAct through unhelpful searches and repeated steps that show up in the trace. Combining the two scored best.

On ALFWorld and WebShop the prompt held only one or two examples, yet it beat methods trained on the task.

The text loop and the stop-sequence trick

Before native tool calling, the runtime parsed actions out of text. One line did the safety work: stop generation at the word Observation, or the model writes its own observations and reasons over fiction.

SYSTEM = """Interleave Thought, Action and Observation lines. Write one Thought
and one Action, then stop. Actions: search[entity], lookup[keyword], finish[answer]."""
ACTION = re.compile(r"Action \d+: (\w+)\[(.*?)\]")

def react_text(question, llm, tools, max_steps=8):
    transcript = f"Question: {question}\n"
    for n in range(1, max_steps + 1):
        out = llm(SYSTEM, transcript, stop=[f"\nObservation {n}:"])  # the trick
        transcript += out
        m = ACTION.search(out)
        if m and m.group(1) == "finish":
            return m.group(2)
        tool = tools.get(m.group(1)) if m else None
        obs = tool(m.group(2))[:1500] if tool else "Invalid action. Use search, lookup or finish."
        transcript += f"\nObservation {n}: {obs}\n"
    return None                       # step cap hit: report it, do not guess

Still the pattern for models without native tool calling. The loop mechanics and guards are the same as in The Agent Loop.

How ReAct became native

Tool-use APIs absorbed the pattern. You no longer prompt for labelled lines or parse them; each piece has a structured home.

One difference matters for audits. On current Claude models the raw reasoning is never returned: thinking text is omitted by default, and display: "summarized" gives a summary. Pass thinking blocks back unchanged, and treat the tool_use and tool_result pairs as the exact record of what the agent did.

Failure modes specific to ReAct

Next: Reflexion: Agents That Learn from Mistakes, what an agent does after a ReAct episode fails.