ReAct (Reasoning and Acting)

ReAct structures output as a repeating cycle: Thought (reasoning about the current state), Action (executing a tool command), and Observation (receiving external feedback). This interleaving grounds the model's internal reasoning in real-world data, preventing hallucination cascades. For example, a model might think 'I need to find the CEO's birth year,' act by calling a search API, and observe the returned snippet before proceeding.

The framework requires a predefined, searchable action space—typically a set of APIs or tools with strict schemas. Actions are expressed as structured commands (e.g., Search[entity], Lookup[string], Finish[answer]). This constraint allows the model to interact with external environments deterministically, transforming an opaque generative process into a verifiable sequence of tool calls.

Unlike pure Chain-of-Thought prompting, which relies solely on parametric knowledge, ReAct uses Observations from external tools to update its internal reasoning. If a search returns a surprising fact, the model can revise its plan. This creates a closed-loop system where the model's beliefs are continuously reconciled with external evidence, significantly reducing factual errors on knowledge-intensive tasks like multi-hop question answering.

ReAct is implemented via few-shot examples that demonstrate complete thought-action-observation trajectories. These prompts teach the model to: (1) decompose tasks, (2) choose appropriate tools, (3) handle null results gracefully, and (4) know when to terminate with a final answer. The prompt engineering focuses on showing the model how to reason through tool failures and information dead ends.

ReAct and Chain-of-Thought (CoT) are complementary. ReAct excels at fact-gathering via external tools, while CoT excels at mathematical and logical deduction. The original paper demonstrated that combining both—using internal reasoning for calculations and external actions for retrieval—yields superior performance on complex tasks. This hybrid approach leverages the model's internal knowledge for structured reasoning and external tools for factual grounding.

A key characteristic of ReAct is its ability to recover from tool failures. When an action returns an empty result or an error, the model generates a new Thought analyzing the failure and formulates an alternative action. This self-correcting loop enables robust behavior in unpredictable information environments, such as searching a noisy knowledge base or navigating a website with broken links.

A reasoning paradigm that interleaves retrieval steps with the generation of intermediate rationales. Unlike standard ReAct which separates thought and action, CoT Retrieval uses each generated reasoning sentence as a query to fetch supporting evidence, creating a tight feedback loop between logical deduction and evidence gathering.

• Generates a rationale step
• Retrieves evidence for that specific step
• Continues reasoning with new context

Interleaving Retrieval with Chain-of-Thought is a specific implementation that formalizes the CoT Retrieval pattern. It uses the generated rationale sentence directly as a search query against a knowledge source, ensuring each reasoning step is grounded in retrieved facts before proceeding.

• Directly queries a knowledge base with reasoning traces
• Grounds each logical hop in external evidence
• Reduces hallucination in multi-step problems

A reasoning framework that generalizes ReAct and CoT by exploring multiple reasoning paths simultaneously in a tree structure. The model can look ahead, evaluate branches, and backtrack from dead ends—enabling deliberate planning beyond linear thought-action loops.

• Explores multiple strategies concurrently
• Uses breadth-first or depth-first search
• Backtracks from unpromising reasoning branches

An agentic pattern that extends ReAct with episodic memory and verbal reinforcement. After executing a thought-action loop, the model generates a self-evaluation of its output and stores this reflective critique in a memory buffer to guide and improve subsequent reasoning attempts.

• Generates self-critique after each attempt
• Stores verbal reinforcement signals
• Uses past failures to improve future strategies

An agentic capability central to ReAct where a language model autonomously selects and invokes external tools—calculators, code interpreters, search APIs—to perform sub-tasks. ReAct formalizes this by reasoning about which tool to use and how to interpret its output before acting.

• Calculator for numerical operations
• Code interpreter for algorithmic tasks
• Search APIs for real-time information

A prompting technique that instructs the model to first generate a detailed execution plan before attempting to solve the problem step-by-step. This contrasts with ReAct's interleaved approach by front-loading all reasoning before any action, reducing calculation errors and reasoning omissions.

• Generates complete plan upfront
• Executes steps sequentially without re-planning
• Reduces mid-execution context switching