ReAct Prompting

The Thought component is the model's internal monologue, where it articulates its reasoning process before taking action. This is a direct extension of Chain-of-Thought (CoT) prompting.

• Purpose: Decomposes the problem, plans next steps, and interprets observations.
• Format: Typically prefixed with Thought: in the prompt.
• Example: Thought: The user is asking for the current weather. I need to call a weather API, but first I must determine their location.

The Act component is where the model pauses its text generation to request an external operation. This is the interface for function calling or tool use.

• Purpose: Interacts with the external world (databases, APIs, calculators, search).
• Format: A structured call, often in JSON or a specific syntax like Action: search[query].
• Mechanism: The system intercepts this output, executes the tool, and returns the result as an Observation.

The Observation is the result returned from the executed action, which is fed back into the model's context window to inform subsequent reasoning.

• Purpose: Grounds the model's reasoning in real, external data, mitigating hallucinations.
• Key Concept: This creates a tight loop similar to an agentic cognitive architecture, where perception informs planning.
• Example: After an action Action: get_weather[London], the observation might be Observation: {'temp': 12°C, 'conditions': 'rainy'}.

The core innovation of ReAct is the interleaving of reasoning and action in a single, continuous prompt. This is distinct from running CoT and then separate tool calls.

• Process: Thought → Act → Observation → Thought → Act... until a final answer is formulated.
• Benefit: Allows dynamic re-planning based on unexpected observations, enabling recursive error correction.
• Contrast: Unlike prompt chaining, this is a unified loop within one extended context.

For the LLM to act, it must know what tools are available. This involves providing a tool catalog within the prompt or system context.

• Content: Includes tool names, descriptions, parameter schemas, and expected output formats.
• Standardization: Often aligns with frameworks using OpenAI's function calling or the Model Context Protocol (MCP).
• Engineering: This schema definition is a critical part of prompt architecture for reliable agentic systems.

The model must generate cleanly parsable actions. This requires structured output prompting to ensure the system can reliably interpret and execute the Act step.

• Techniques: Using explicit delimiters (e.g., Action:), JSON schema definitions, or formal grammars.
• Failure Mode: Unparseable actions break the loop, highlighting the need for robust output validation.
• Evolution: This requirement has driven the development of native tool-calling capabilities in modern LLM APIs.

Chain-of-thought (CoT) prompting is the reasoning foundation of ReAct. It explicitly instructs a model to articulate its intermediate reasoning steps before delivering a final answer. This technique is critical for decomposing complex problems.

• Core Mechanism: The prompt includes phrases like "Let's think step by step" to trigger sequential, logical reasoning.
• Impact: Significantly improves performance on arithmetic, commonsense, and symbolic reasoning tasks by making the model's internal process explicit.
• Relation to ReAct: ReAct integrates CoT's step-by-step reasoning with the ability to take actions, creating an iterative loop of thought and interaction.

Function calling (or tool use) is the execution mechanism that enables the "Act" phase of ReAct. It is a prompting paradigm where an LLM is instructed to respond with a structured request to execute a predefined function or API call.

• Structured Output: The model generates a JSON object specifying a function name and its arguments, which is then parsed and executed by the application.
• External Integration: This allows the LLM to retrieve live data (e.g., stock prices, weather), perform calculations, or modify external systems.
• Relation to ReAct: In a ReAct loop, the model's reasoning ("Think") often concludes with a decision to call a function ("Act"), gather the result, and then reason again.

Prompt chaining is a compositional technique where a complex task is broken into a sequence of simpler subtasks, with the output of one LLM call becoming the input for the next. It shares a sequential execution philosophy with ReAct.

• Modular Design: Each step in the chain is a discrete prompt optimized for a specific subtask (e.g., plan, research, summarize).
• State Management: The application code, not the LLM, is responsible for passing state between links in the chain.
• Relation to ReAct: ReAct can be viewed as a specialized, tightly integrated form of prompt chaining where the LLM itself decides the next step (reason or act) within a single, extended context window.

Tree-of-thoughts (ToT) prompting is an advanced reasoning framework that generalizes Chain-of-Thought by enabling an LLM to explore multiple concurrent reasoning paths, forming a search tree.

• Search Algorithms: It employs algorithms like breadth-first or depth-first search to explore and evaluate different reasoning branches.
• Backtracking: The model can backtrack from dead ends, a capability not present in standard CoT or basic ReAct loops.
• Relation to ReAct: ToT represents a more sophisticated "Think" phase. A future evolution, Tree-of-Actions, could combine this exploratory reasoning with external tool use, allowing an agent to plan and evaluate multiple action sequences before committing.

Self-consistency prompting is an advanced technique that improves upon a single Chain-of-Thought by sampling multiple, diverse reasoning paths from an LLM and selecting the most consistent final answer through a majority vote.

• Ensemble Method: It mitigates the variability and potential errors in any single reasoning trajectory.
• Verification: The consistency of the final answers across multiple paths serves as a confidence metric.
• Relation to ReAct: This technique can be integrated into the ReAct paradigm for critical decision points. Before executing an action, the system could sample multiple reasoning paths to decide on the most reliable next step, increasing robustness.

Agentic cognitive architectures are the overarching system designs that implement autonomous loops of reasoning, planning, and action. ReAct is a fundamental prompting pattern within these architectures.

• Core Loop: Architectures like ReAct, Reflexion, and Plan-and-Execute define how an agent perceives, thinks, acts, and learns from feedback.
• Memory & State: These systems incorporate agentic memory (vector stores, knowledge graphs) to maintain context over long horizons.
• Relation to ReAct: ReAct provides the basic unit of cognition (Think-Act-Observe) that is orchestrated at scale within these architectures to achieve complex, multi-step goals.