ReAct Framework

The Thought step is the model's internal reasoning process. It is a free-text, chain-of-thought style analysis where the model:

• Decomposes the problem into sub-tasks.
• Plans the next logical step.
• Evaluates the necessity of using an external tool.
• Formulates the precise query or action for the selected tool.

Example: Thought: The user asked for the current weather. I need to call a weather API. I should first determine their location. I can use a geolocation tool with their provided city name, 'Tokyo'.

The Action step is the structured invocation of an external tool. The model must output a strictly formatted command, typically as a JSON object, specifying:

• Tool Name: The exact identifier of the function to call (e.g., get_weather).
• Action Input: The parameters required for the tool (e.g., {"city": "Tokyo"}).

This output is parsed by the system orchestrator, which executes the actual API call or database query. The format enforces deterministic, machine-readable output.

The Observation step is the system's feedback to the model. After the Action is executed, the raw result from the tool is injected back into the model's context.

• This can be structured data (e.g., a JSON response from an API) or unstructured text (e.g., database query results).
• It may also include error messages (e.g., "Tool 'get_stock' not found" or "API timeout").

The model must interpret this observation to continue its reasoning loop, adapting its plan based on success or failure.

The loop continues iterating (Thought → Action → Observation) until a terminal condition is met. The model decides to terminate the loop during a Thought step when:

• It has sufficient information to construct a final answer for the user.
• It determines no further actions are possible or required.
• A maximum iteration limit is enforced by the system to prevent infinite loops.

The final output is a natural language answer synthesized from all gathered observations, presented outside the ReAct loop structure.

For ReAct to work, the model requires a catalog of available tools. Each tool definition includes:

• Name & Description: A clear purpose (e.g., "search_web": "Searches the internet for current information").
• Parameter Schema: A strict definition of inputs, often using a JSON Schema (e.g., {"query": {"type": "string"}}).
• Access Rules: Permissions and guardrails governing when the tool can be used.

These definitions are provided to the model in the system prompt or via a framework like the Model Context Protocol (MCP), enabling accurate tool selection.

The Orchestrator is the software layer that manages the ReAct loop. Its critical duties are:

• Parsing: Extracting the structured Action from the model's text response using output parsing.
• Execution: Calling the corresponding external function, API, or database query.
• Context Management: Appending the Observation to the ongoing conversation history for the next model call.
• Error Handling: Implementing fallback logic and retry logic for failed actions.
• Guardrails: Applying input sanitization and validation to prevent unsafe operations.

Frameworks like LangChain and LlamaIndex provide built-in ReAct orchestrators.

A prompting technique that elicits step-by-step reasoning in a model's output before delivering a final answer. Unlike ReAct, CoT is purely internal; it does not involve external tool calls or actions. It is the intellectual precursor to ReAct, demonstrating the performance gains from explicit reasoning traces.

• Key Difference: CoT reasons about a problem; ReAct reasons to act on it.
• Use Case: Primarily for complex arithmetic, commonsense, and symbolic reasoning tasks where no external data or API is needed.

The core capability of a language model to generate a structured request (e.g., JSON) to execute a defined external function, API, or data source. This is the "Act" phase of the ReAct loop. The model must identify the correct tool and extract parameters from its internal reasoning and the user's request.

• Implementation: Often defined via JSON Schema or OpenAPI Specifications.
• Provider Examples: OpenAI Functions, Anthropic Tools, and Gemini Function Calling are proprietary implementations.

The overarching system design that enables autonomous agents to decompose goals, plan, and execute multi-step tasks. ReAct is a specific, widely adopted architectural pattern within this domain. These architectures typically include components for planning, memory, tool use, and reflection.

• Broader Scope: Encompasses ReAct but also includes other paradigms like Reflection and Hierarchical Planning.
• System Concern: Focuses on the agent's persistent state, long-term objectives, and self-correction loops beyond a single ReAct cycle.

A process where an agent (or model) critiques and revises its own outputs or actions. In advanced ReAct agents, this can be an additional step in the loop, where the agent evaluates the result of a tool call, detects errors, and reasons about the next corrective action.

• Enhances Reliability: Moves agents from simple execution towards resilient problem-solving.
• Example: An agent calls a calculator but gets an unexpected result; its self-correction step would re-examine the initial problem and tool parameters.

Prominent open-source frameworks that provide high-level abstractions for building ReAct-style agents. They simplify the orchestration of reasoning, tool calling, and memory.

• LangChain: Offers a rich ecosystem of Tools, Agents, and Chains to compose multi-step workflows. Its ReActAgent is a canonical implementation.
• LlamaIndex: Excels at data-aware agents, providing tools for sophisticated retrieval over private data, which then feed into the ReAct reasoning loop.
• Role: These frameworks handle the scaffolding, letting developers focus on defining tools and the agent's objective.

An open standard for securely exposing tools, data sources, and services to AI models. MCP provides a unified, secure way for ReAct agents to discover and interact with external resources, moving beyond vendor-specific function calling implementations.

• Key Benefit: Decouples tool definitions from any single model provider (OpenAI, Anthropic, etc.).
• Architecture: Uses servers to expose resources and clients (like an AI app) to connect to them. It standardizes schema definition, authentication, and streaming results.
• Impact: Promotes interoperability and is becoming a foundational layer for enterprise-grade ReAct agent systems.