ReAct (Reasoning and Acting)

The Thought component is where the language model verbalizes its internal reasoning process. This step involves analyzing the current state, recalling relevant information, and planning the next action. It transforms implicit model calculations into an explicit, human-readable chain of logic.

• Purpose: To make the model's decision-making process transparent and auditable.
• Output: A natural language statement like 'I need to find the current weather in Tokyo to answer this question.'
• Key Benefit: This explicit trace allows for debugging, improves faithfulness, and provides a basis for process supervision.

The Act component is where the model interfaces with the external world. Based on the preceding Thought, the model generates a structured action, typically a call to an external tool or API.

• Format: Actions are often formatted as commands like Search[Tokyo weather] or Calculator[15 * 1.08].
• Mechanism: A separate function or tool-use layer parses this command, executes it (e.g., performing a web search or running code), and returns the result (Observation) to the model's context.
• Capability: This enables the model to overcome its inherent limitations, such as lack of real-time data or inability to perform precise calculations.

The Observation is the result returned from an executed Action. This new information is appended to the model's context, grounding its subsequent reasoning in factual, external data.

• Role: Serves as the feedback loop between the agent and its environment.
• Example: After Search[Tokyo weather], the Observation might be 'Current weather in Tokyo: 22°C, sunny.'
• Critical Function: This step prevents the model from relying solely on its parametric knowledge, which may be outdated or incorrect, thereby significantly reducing hallucinations in tasks requiring external verification.

The core innovation of ReAct is the interleaving of Thoughts, Actions, and Observations in a cyclic loop until a task is solved. This creates a dynamic reasoning-and-acting trajectory.

• Sequence: Thought → Act → Observation → Thought → Act → Observation → ... → Final Answer.
• Adaptability: Each cycle allows the model to adjust its plan based on new Observations, mimicking a flexible problem-solving strategy.
• Contrast with Planning-Then-Acting: Unlike frameworks that create a full plan upfront (e.g., early plans in ReWOO), ReAct's interleaved approach allows for real-time replanning in response to unexpected Observations.

ReAct builds directly upon Chain-of-Thought (CoT) prompting. The Thought steps are essentially CoT traces, but they are specifically geared toward justifying and planning actions.

• Enhanced CoT: While standard CoT is purely linguistic reasoning, ReAct's Thoughts are action-oriented, culminating in a tool call.
• Grounding: The periodic integration of Observations ensures the reasoning chain is factually grounded, addressing a key weakness of pure CoT which can drift or hallucinate.
• Foundation: Mastery of CoT techniques like Least-to-Most Prompting or Self-Consistency is often a prerequisite for implementing effective ReAct agents.

ReAct is a canonical implementation of Tool-Augmented Reasoning, where a language model's reasoning process is explicitly supported by external utilities. The framework defines the protocol for integrating these tools.

• Tool Definition: A set of capabilities (e.g., Search, Calculator, SQL_Executor) must be defined for the agent, along with their descriptions and usage formats.
• Model's Role: The language model acts as a router and interpreter, deciding when and how to use which tool based on its reasoning.
• System Architecture: This requires a supporting execution layer that can safely parse and run the model's action commands, a cornerstone of modern Agentic Cognitive Architectures.

Chain-of-Thought (CoT) prompting is the foundational technique that enables step-by-step reasoning in language models. It involves providing the model with examples or instructions that demonstrate an explicit reasoning process before delivering a final answer.

• Core Mechanism: Elicits intermediate reasoning traces, making the model's logic transparent.
• Relation to ReAct: ReAct builds upon CoT by interleaving these reasoning traces with actionable tool calls, transitioning from passive reasoning to active interaction with an environment.
• Key Distinction: Standard CoT is a reasoning-only paradigm, while ReAct is a reasoning-and-acting paradigm.

Tool-Augmented Reasoning is the general approach of enhancing a language model's capabilities by allowing it to call external tools during its reasoning process. This addresses inherent model limitations in precision, factuality, and access to real-time data.

• Common Tools: Calculators, code executors, search APIs, database queries, and software APIs.
• Implementation: The model generates a reasoning step, identifies a need for a tool, calls it, and incorporates the result into its next step.
• ReAct's Role: ReAct provides a specific, structured framework for implementing Tool-Augmented Reasoning, formalizing the interleaving pattern.

ReWOO (Reasoning Without Observation) is an alternative agent framework that decouples planning from execution to improve efficiency and reduce costs.

• Core Mechanism: The planner (LLM) first generates a complete plan consisting of a reasoning graph and a list of tool calls with placeholders. This plan is then executed by separate workers without further LLM inference.
• Comparison to ReAct: ReAct is interleaved (think-act-think-act). ReWOO is decoupled (plan-then-execute).
• Trade-off: ReWOO reduces latency and token usage but is less adaptable to dynamic environments where observations might necessitate plan changes.

Self-Ask is a prompting technique closely related to ReAct, designed for question-answering with search. It guides the model to explicitly decompose a complex question into smaller, searchable sub-questions.

• Process: The model asks itself a sub-question, uses a search tool to find the answer, and then uses that information to ask the next sub-question or synthesize the final answer.
• Relation to ReAct: Self-Ask can be viewed as a specific, simplified instance of the ReAct pattern, applied to the domain of factual QA with a retrieval tool. ReAct generalizes this pattern to any sequence of reasoning and arbitrary actions.

Program-Aided Language Models (PAL) is a Chain-of-Thought technique where the model generates reasoning steps as executable code (e.g., Python) within its response. An external interpreter then runs this code to compute the final answer.

• Core Strength: Offloads precise mathematical and logical computation to a deterministic runtime, eliminating calculation errors from the LLM.
• Comparison to ReAct: Both use external executors. PAL uses a code interpreter for computation within a single, planned response. ReAct interleaves reasoning with a broader set of tools and APIs in a dynamic loop. They are complementary and can be combined.

Tree-of-Thoughts (ToT) is an advanced reasoning framework that extends Chain-of-Thought by exploring multiple reasoning paths in parallel, forming a search tree.

• Core Mechanism: At each step, the model generates several possible thoughts (reasoning steps). These are evaluated, and the most promising paths are expanded further using search algorithms like breadth-first or depth-first search.
• Relation to ReAct: ToT focuses on exploring the reasoning space. ReAct focuses on interleaving reasoning with action. The two paradigms can be fused to create agents that explore different action-reasoning paths (e.g., "Plan A: use API X, Plan B: query database Y") before committing.