ReAct: Reasoning and Acting
ReAct interleaves chain-of-thought reasoning with tool actions like search and lookup, grounding language models in external feedback.
Primary source: ReAct: Synergizing Reasoning and Acting in Language Models (arXiv:2210.03629)
Chain-of-thought lets models reason; tool-using agents let them act. The 2022 ReAct paper combined the two into one loop: the model writes a Thought, takes an Action (search, lookup, calculate), reads the Observation, and repeats. Reasoning guides which tools to use; tool results ground the reasoning in facts. It is the design pattern behind nearly every agent built since.
The loop
A ReAct trace alternates three step types in plain text. Thought steps plan and decompose ("I need the director's birth year, so I'll search for it"). Action steps call tools with concrete arguments ("search[Marie Curie]"). Observation steps paste back the tool result, which the next Thought must reckon with.
This interleaving fixes complementary failures. Pure reasoning hallucinates facts it never checked. Pure acting (act-only agents) wanders without a plan. ReAct's traces show the model catching its own errors mid-stream: a search returns nothing useful, the next thought reformulates the query.
What the results showed
On HotpotQA (multi-hop questions needing Wikipedia lookup) and FEVER (fact verification), ReAct beat both chain-of-thought and act-only baselines by large margins. Ablations confirmed the synergy: reasoning without acting hallucinates, acting without reasoning flails.
Just as important, the traces are human-readable. A ReAct agent's Thought steps expose its plan, and failures are debuggable — you can see exactly which search went wrong.
The prompt format that made it work
ReAct is pure prompting: a few hand-written trajectories demonstrate the Thought/Action/Observation grammar, and the model continues unseen tasks in the same format. The paper's HotpotQA prompt shows the model thinking ("I need to find who directed Inception"), acting (search[Inception director]), and folding the observation into the next thought — all as text the harness parses with simple rules (stop at "Observation", execute the bracketed action, append the result).
Fine-tuning came later and helped substantially. FireAct (2023) fine-tuned smaller models on ReAct traces and found that 7B models could match prompted GPT-3.5 on tool tasks — the loop is learnable, not just inducible. This is now the standard recipe for cheap agents: distill big-model traces into small fine-tuned actors.
Tool design matters more than model size
ReAct's ablations quietly showed that the action space shapes everything. On HotpotQA, three actions (search, lookup, finish) beat richer toolkits; extra tools the model rarely needs just add failure modes. The lookup action (find text within a retrieved page) mattered enormously — without it, the model drowned in long search results.
The general lesson stuck: give agents few, well-described, composable tools with clear error messages, and spend the complexity budget on observations (snippets, not raw dumps). Most agent failures in production trace to tool design, not reasoning depth.
The pattern that ate agents
ReAct needs no training: it is a prompting format plus a tool harness. That made it instantly reusable, and the "Thought, Action, Observation" loop (or its JSON equivalents) now underlies coding agents, research agents, and computer-use systems. Reflexion, ReWOO, and whole agent frameworks are refinements of this loop with memory and planning layered on top.
Failure modes in production
ReAct loops fail in predictable ways. Loops: the model repeats the same failed action because nothing in the trace says "stop trying this" — production harnesses add step limits and visited-state detection. Context bloat: long tool outputs crowd out the plan, so observations get truncated mid-reasoning — solved with summarization steps or retrieval over the trace itself. Parsing errors: the model emits actions outside the grammar, which strict JSON tool schemas (function calling) largely fixed.
Reflexion (2023) added the missing piece: a memory of past failures. After a failed episode, the model writes a verbal critique stored alongside the trace, and future episodes retrieve it. Self-correction from episodic memory, layered exactly on ReAct's loop.
The deepest fix is architectural: separate planning memory from working memory, so the plan survives long traces. Agent frameworks now routinely split durable state (goals, findings) from the rolling tool transcript — a small change that eliminates most context-bloat failures.
Bottom line
ReAct showed that reasoning and acting are better together: thoughts plan the tool calls, observations correct the thoughts. Two years on, it remains the default architecture for any language model that does things in the world.
Sources
- Yao et al., ReAct: Synergizing Reasoning and Acting in Language Models, 2022. arXiv:2210.03629
Want the next review in your inbox? The briefing collects them — at most one email a week. Read signup data and removal options.
Cite this report
@misc{knowyourml-react-reasoning-acting-language-models
title = {ReAct: Reasoning and Acting},
author = {{Know Your ML}},
year = {2022},
howpublished = {\url{https://knowyourml.yunusemrevurgun.com/report.php?slug=react-reasoning-acting-language-models}},
note = {AI-generated review of arXiv:2210.03629. Primary sources are listed on the page.}
}
Machine Learning Decision Toolkit
Turn this review into a decision: the Machine Learning Decision Toolkit packages the evaluation scorecards, workload templates and deployment checks behind model, provider and architecture choices.
References
- ReAct: Synergizing Reasoning and Acting in Language Models (arXiv:2210.03629) — https://arxiv.org/abs/2210.03629
Frequently asked questions
How is ReAct different from chain-of-thought?
Chain-of-thought only reasons; ReAct alternates Thought, Action, and Observation steps, so the model can query tools mid-reasoning and adjust based on what comes back.
Is ReAct still used in agents today?
Yes — every modern coding and research agent (ReAct-style tool loops with search, code execution, and retrieval) descends directly from this pattern.
Part of
Beyond the paper
How to Remain Valuable When Intelligence Becomes Cheap
This report covered one more way the machine gets smarter. The companion eBook asks the question on the other side: which human advantages stay scarce — and valuable — when intelligence itself is cheap?