ReAct Loop

The reasoning phase where the language model analyzes the current state and plans the next action. This step produces an explicit, natural language reasoning trace that logs the agent's internal logic, making its decision-making process transparent and auditable.

• Key Output: A textual plan (e.g., "I need to find the current weather to answer the user's question. I will use the weather API.")
• Purpose: Creates a verifiable chain-of-thought before any irreversible action is taken.

The acting phase where the agent formulates and executes a precise command to interact with the external world. This typically involves generating a structured call to a tool, API, or function.

• Key Output: A formatted action directive (e.g., a JSON object like {"tool": "weather_api", "query": "Boston, MA"}).
• Mechanism: Relies on the model's function-calling or tool-use capabilities, often guided by a system prompt detailing available tools.

The phase where the result (observation) from the executed action is received and parsed. This observation becomes new context, closing the loop and informing the next cycle of thought.

• Input: Raw data from the external tool (e.g., {"temp": 72, "conditions": "sunny"}).
• Critical Function: Grounds the agent's subsequent reasoning in factual, real-world data, preventing hallucination and enabling dynamic adaptation.

A deterministic rule that evaluates the current state and latest observation to decide whether the task is complete. This halts the cyclical ReAct process.

• Implementation: Can be a simple keyword check in the thought (e.g., "Final Answer:"), a programmatic evaluation of the observation, or a maximum iteration limit.
• Importance: Prevents infinite loops and ensures the agent delivers a final, synthesized output to the user.

The structured system prompt that defines the ReAct loop's format and rules for the agent. It explicitly instructs the model on the required Thought/Action/Observation sequence and available tools.

• Typical Structure:
  • Defines the agent's role and goal.
  • Lists available tools with descriptions and parameters.
  • Mandates the exact output format (e.g., Thought: ...\nAction: ...\nAction Input: ...).
• Role: Acts as the controlling program, ensuring the model adheres to the deterministic loop architecture.

The implicit or explicit mechanism for maintaining context across loop iterations. The state accumulates the history of thoughts, actions, and observations, preventing the agent from repeating steps or losing track of the goal.

• Components:
  • Short-Term Memory: The conversation history or context window containing the recent loop cycles.
  • Task Context: The original user query and any high-level parameters.
• Challenge: Requires careful context window management to avoid truncation in long-running tasks.

A prompting technique that explicitly requests a model to generate intermediate reasoning steps before producing a final answer. It improves performance on complex arithmetic, commonsense, and symbolic reasoning tasks by mimicking human problem-solving.

• Core Mechanism: The prompt includes an instruction like "Let's think step by step."
• Key Benefit: Makes the model's reasoning process transparent and verifiable.
• Relation to ReAct: CoT is the pure reasoning component; ReAct extends this by interleaving reasoning with actionable Act steps using external tools.

An advanced reasoning framework that generalizes Chain-of-Thought by exploring multiple reasoning paths simultaneously. It frames problem-solving as a search over a tree where each node represents a partial "thought."

• Core Mechanism: At each step, a language model generates multiple possible continuations (branching). A separate evaluation step or heuristic (often using the same LM) scores these options to guide the search.
• Key Benefit: Enables deliberate planning, lookahead, and backtracking, which is useful for tasks like creative writing or strategic game play.
• Relation to ReAct: ToT is a search-based reasoning paradigm. ReAct is typically a linear, single-path loop focused on integrating action with reasoning.

A technique where a language model generates code (e.g., Python) as an intermediate reasoning step to solve a problem. An external code interpreter then executes the generated program to produce the final answer.

• Core Mechanism: The prompt instructs the model to write code that solves the problem. The code's execution provides a deterministic, computationally accurate result.
• Key Benefit: Offloads precise computation and algorithmic logic to a reliable interpreter, reducing numerical hallucinations.
• Relation to ReAct: PAL is a specific type of Act step where the action is code execution. ReAct is a more general loop that can use PAL for one of its tool-calling cycles.

A chaining pattern where a model is prompted to critique and revise its own initial output. This creates an iterative loop of generation and improvement within a single task.

• Core Mechanism: A follow-up prompt asks the model to identify errors, inconsistencies, or areas for improvement in its first response, then generate a refined version.
• Key Benefit: Can improve factual accuracy, coherence, and adherence to instructions without human intervention.
• Relation to ReAct: Self-correction is a specialized, internal refinement loop. ReAct is an externalized loop focused on gathering new information or performing actions outside the model's parametric knowledge.

The broader orchestration pattern of interleaving language model calls with executions of external tools, APIs, or functions within a sequential workflow. ReAct is a specific, structured paradigm for implementing this.

• Core Mechanism: A controller (or the LM itself) decides when to call a tool based on the context, passes relevant parameters, processes the tool's output, and decides the next step.
• Key Benefit: Extends an LM's capabilities beyond its training data, enabling real-time data lookup, calculation, and interaction with digital systems.
• Relation to ReAct: ReAct provides a standardized Reason-Act-Observe template for tool-use chaining, emphasizing explicit reasoning before each action.

A chaining technique where context or state (such as conversation history, intermediate results, or variables) is explicitly maintained and passed between prompts in a sequence.

• Core Mechanism: The system manages a state object that is updated after each step and selectively included in the context of subsequent prompts.
• Key Benefit: Enables multi-turn coherence and allows later steps to build upon or reference earlier conclusions.
• Relation to ReAct: The ReAct Loop is inherently stateful. The Observation from one cycle updates the internal state (the context window) that informs the next Reason step, creating a running memory of the interaction.