ReAct (Reasoning and Acting)

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.

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.