ReAct Framework

The Thought step is the model's internal reasoning process. It analyzes the current state, decomposes the problem, and plans the next action. This explicit chain-of-thought is crucial for transparency and debugging.

• Purpose: To articulate the agent's internal logic and justify the subsequent action.
• Output Format: Free-form natural language.
• Example: Thought: The user asked for the weather in Tokyo. I don't have current weather data in my training. I need to call a weather API. I should first find the correct API endpoint and required parameters.

The Action step is where the model decides to interact with the external world. It selects a specific tool and generates a structured call, typically conforming to a defined schema like JSON.

• Purpose: To translate internal reasoning into an executable external command.
• Output Format: A structured object specifying the tool_name and tool_input (arguments).
• Example: Action: {"tool_name": "get_weather", "tool_input": {"location": "Tokyo", "units": "celsius"}}
• This step directly enables tool calling and API execution.

The Observation step is the result returned from the executed tool or API. This raw data, which was not in the model's original training set, is fed back into the agent's context.

• Purpose: To provide the agent with new, external information necessary to continue its task.
• Input: Can be structured (JSON) or unstructured (text, HTML).
• Example: Observation: {"location": "Tokyo", "temperature": 22, "conditions": "Partly Cloudy", "humidity": 65%}
• The agent must parse and integrate this observation into its ongoing reasoning loop.

ReAct operates as a cyclic, stateful process. The agent repeats the Thought-Action-Observation sequence until the task is complete or a termination condition is met.

• State Management: Each cycle updates the agent's context with new thoughts and observations.
• Dynamic Planning: The agent can adjust its plan based on unexpected observations (e.g., an API error).
• Termination: The final Thought concludes the task, often followed by an Answer to the user.
• Example Flow: Thought -> Action -> Observation -> Thought -> Action -> Observation -> ... -> Final Answer This loop is the core of agentic cognitive architectures.

ReAct is implemented via a specialized prompt template that provides the model with examples of the loop, available tools, and output format instructions.

• Components:
  • System Instructions: Define the agent's role and the ReAct format.
  • Tool Definitions: A list of available tools with names, descriptions, and parameter schemas.
  • Few-Shot Examples: Demonstrations of complete ReAct trajectories for similar tasks.
  • Output Format Enforcement: Instructions to strictly output Thought:, Action:, or Answer:.
• This template is a key element of context engineering and prompt architecture.

ReAct is a high-level reasoning pattern that is typically implemented on top of a function calling framework. The framework handles the translation between the model's action output and the actual code execution.

• Mechanism: The Action JSON is passed to a dynamic dispatch system that matches the tool_name to a handler in a function registry.
• Role of Frameworks: Libraries like LangChain Tools or Semantic Kernel provide the abstraction to define tools and bind the ReAct loop to them.
• Validation: The framework performs parameter validation against the tool's schema before execution.
• Error Handling: Framework-level error propagation and retry policies manage failures, allowing the ReAct loop to reason about them in the next Thought.

Function calling is a core LLM capability where the model is prompted to output a structured request, typically JSON, matching a predefined schema to invoke an external function or API. It is the fundamental mechanism that frameworks like ReAct rely upon to execute the 'Act' phase.

• Structured Output: The model must generate arguments that conform to a strict type definition (e.g., {"function": "get_weather", "location": "Boston"}).
• Schema-Driven: Function signatures (name, description, parameter types) are provided to the model in its prompt context.
• Foundation for Tools: It transforms natural language intent into executable code, enabling agents to perform actions beyond text generation.

Tool calling is the end-to-end process where an AI agent selects and invokes an external utility. While function calling refers to the model's structured output, tool calling encompasses the full lifecycle: selection, argument generation, dispatch, execution, and handling the result.

• Agent-Centric: Focuses on the agent's decision to use a tool based on context and capability.
• Runtime Integration: Involves a dynamic dispatch system that routes the model's request to the correct handler code.
• Broader Scope: Includes error handling, authentication, and state management that pure function calling does not address.

Structured outputs are formatted, schema-conforming data (like JSON objects) that a language model generates to reliably interface with downstream systems. In ReAct, both the reasoning trace and the tool call request must be structured for deterministic parsing by the orchestration layer.

• JSON Schema Binding: A technique to enforce output conformity using a formal JSON Schema definition.
• Type Safety: Guarantees that parameters for tool calls are of the correct type (string, number, array) before execution.
• Integration Enabler: Allows AI-generated data to be consumed directly by traditional software without fragile text parsing.

Tool selection is the decision-making process where an AI agent evaluates available tools against the current context and user intent to choose the most appropriate function. In ReAct, this occurs during the 'Act' step, informed by the preceding 'Reasoning' trace.

• Semantic Matching: The agent matches the task's needs to tool descriptions (name, purpose, parameter docs).
• Driven by Context: Selection depends on the current state of the problem and previous tool results.
• Core to Planning: Effective selection is critical for multi-step problem-solving, preventing the agent from getting stuck.

Workflow orchestration is the automated coordination, sequencing, and state management of multiple tool calls and conditional logic within an agent's execution plan. ReAct implicitly defines a simple orchestration loop: Reason -> Act -> Observe, repeat.

• State Management: Tracks inputs, outputs, and intermediate results across a sequence of actions.
• Conditional Logic: Determines the next step based on the success or output of a previous tool call.
• Beyond Chaining: More sophisticated than simple tool chaining, as it involves loops, branching, and error recovery pathways.