ReAct (Reasoning and Acting)

The core mechanism of ReAct is a deterministic loop where the model alternates between two phases:

• Reasoning (Thought): The model analyzes the current state and plans the next step, verbalizing its internal reasoning.
• Acting (Action): The model executes a concrete action, typically formatted as a structured call to an external tool, API, or search function. The output of the action (Observation) is fed back into the context, and the loop repeats until a termination condition is met. This creates a transparent, step-by-step trace of the problem-solving process.

Before taking any action, the model is prompted to generate a Thought. This serves multiple critical functions:

• Improves reliability by forcing the model to articulate its plan, reducing impulsive or incorrect actions.
• Provides auditability by creating a human-readable log of the decision-making process.
• Enables self-correction; flawed logic in the thought can be identified before an action is taken. The thought often includes analyzing previous observations, decomposing the overall goal, and selecting the appropriate tool and parameters for the next step.

Actions in ReAct are not free-form text. They are constrained outputs that match a predefined schema for tool calling. A typical format is: Action: <tool_name>[<input_parameters>] For example: Action: Search[OpenAI revenue Q4 2023] or Action: Calculator[15 * (22 + 7)]. This structured output is easily parsed by an orchestrator (the system running the ReAct loop) to execute the actual function call, retrieve the result, and format it as an Observation for the next cycle.

Each action generates an Observation, which is the result returned from the tool or API. This observation is appended to the growing context of the interaction.

• Closes the information gap: The model can gather real-time, external data not present in its initial training.
• Enables conditional branching: The next thought and action are directly conditioned on the new information. A failed search might lead to a rephrased query, while a successful data retrieval leads to analysis.
• Maintains state: The concatenated sequence of (Thought, Action, Observation) triples forms a complete episodic memory of the task execution.

ReAct is fundamentally an extension of Chain-of-Thought (CoT) prompting into interactive environments. It retains CoT's strength in complex reasoning while overcoming its key limitation: static knowledge.

• CoT provides the 'Reasoning': The thought generation is a CoT trace focused on planning.
• Tools provide grounded 'Acting': Actions allow the model to move beyond parametric knowledge. This synergy allows ReAct to outperform CoT alone on tasks requiring up-to-date information (e.g., "What's the latest news about X?") or precise computation (e.g., multi-step arithmetic).

ReAct provides the basic operational blueprint for autonomous AI agents. The loop of perceive (via observation), think (generate thought), and act (execute tool) is the core of many agent architectures.

• Modularity: Different tools (calculators, APIs, code executors) can be plugged into the same ReAct loop.
• Scalability: The pattern can be nested or coordinated across multiple agents (see Tree of Thoughts or Multi-Agent Debate).
• Safety & Control: The explicit thought and structured action allow for human oversight, validation checks, and interruption points before external effects occur.

Chain-of-Thought Prompting is the foundational technique that elicits a language model to generate an explicit, step-by-step reasoning trace before delivering a final answer. It is the core 'reasoning' component abstracted by the ReAct loop.

• Mechanism: Instructs the model to "think aloud," decomposing a problem into intermediate logical or arithmetic steps.
• Impact: Dramatically improves performance on complex tasks requiring mathematical, symbolic, or commonsense reasoning.
• Relation to ReAct: ReAct interleaves CoT-style 'Thought' steps with actionable 'Act' steps, using reasoning to plan the next tool call.

Tree of Thoughts is a prompting framework that generalizes Chain-of-Thought by modeling reasoning as a heuristic search over a tree structure. It enables exploration, backtracking, and strategic planning.

• Mechanism: At each step, the model generates multiple possible 'thoughts' (tree branches). A scoring function or a language model evaluates these options to guide the search toward a solution.
• Key Features: Supports lookahead, pruning, and non-linear problem-solving. It is computationally more expensive but more powerful than linear CoT.
• Contrast with ReAct: While ReAct is a linear loop of thought-act-observation, ToT is a search algorithm over a reasoning space, which can be integrated within a ReAct 'Thought' step for complex planning.

Program of Thoughts is a method where a language model uses code generation as its intermediate reasoning step. The model writes executable code (e.g., Python) to offload precise calculation or symbolic manipulation to a runtime interpreter.

• Mechanism: The prompt instructs the model to generate a program that, when executed, computes the answer. The code and its output become part of the reasoning trace.
• Advantage: Leverages the deterministic accuracy of a code interpreter for mathematical operations, reducing arithmetic hallucinations.
• Relation to ReAct: PoT can be seen as a specialized 'Act' step where the action is writing and executing code. In a ReAct loop, a 'Thought' could decide to use a PoT-style approach for a computational sub-task.

Self-Ask is a prompting technique where a model is explicitly instructed to decompose a question into intermediate, searchable sub-questions. It is designed for tasks requiring external knowledge retrieval.

• Mechanism: The model follows a template: it asks itself a sub-question, uses a tool (like a search API) to find the answer, and then uses that new information to ask the next sub-question or answer the original query.
• Use Case: Ideal for open-domain question answering where facts are not in the model's pre-trained knowledge.
• Contrast with ReAct: Self-Ask is a specific, linear instantiation of the ReAct pattern. ReAct generalizes this idea to any tool (not just search) and allows for more flexible reasoning in the 'Thought' step.

Chain-of-Verification is a method focused on self-correction and factual grounding. A model generates an answer, then plans and executes independent verification steps to check its claims, finally revising its output.

• Four-Step Process: 1) Generate initial answer. 2) Plan verification questions. 3) Answer verification questions independently (isolating context). 4) Produce final, revised answer.
• Goal: Mitigate hallucinations and improve factual consistency by breaking the model's tendency to stick to its initial, potentially flawed, generation.
• Relation to ReAct: CoVe can be implemented using a ReAct loop, where 'Act' steps involve querying knowledge bases or performing calculations to verify facts identified in the 'Thought' step.

Function Calling (or Tool Calling) is the model capability to identify when and how to invoke a predefined external function, API, or tool. It is the primary execution mechanism for the 'Act' phase in ReAct.

• Mechanism: The model is provided with a schema of available functions (name, description, parameters). In response, it generates a structured request (often JSON) to call a specific function with the correct arguments.
• Technical Foundation: Enabled by fine-tuning or system prompt engineering, it allows models to become the 'orchestrator' of a software ecosystem.
• Core to ReAct: ReAct's 'Act' step is concretely realized through a function call. The 'Observation' is the return value from that call. Robust function calling is therefore a prerequisite for effective ReAct implementation.