While basic agent loops involve receiving input and generating an action, they often lack a structured mechanism for internal deliberation, especially when tackling multi-step problems or interacting with external tools. When an action fails or produces unexpected results, a simple reactive agent might struggle to adapt. The ReAct framework, introduced by Yao et al. (2022), provides a more robust approach by explicitly intertwining reasoning steps with actions within the agent's operational cycle.

ReAct stands for "Reason + Act". Its core principle is to augment the action space of an agent with an internal reasoning space. At each step, the agent doesn't just decide what to do next (Act); it first articulates why (Reason). This explicit articulation, often referred to as a "thought", serves multiple purposes: it helps decompose complex tasks, track progress, handle exceptions, and dynamically adjust the plan based on intermediate outcomes.

The ReAct Operational Loop

The ReAct process operates iteratively, typically following a sequence of Thought-Action-Observation steps:

Observation ( $o_t$ ): The agent receives initial input or observes the outcome of its previous action. This forms the context for the current step.
Thought ( $t_t$ ): Based on the current observation $o_t$ and the overall goal, the Large Language Model (LLM) generates an internal reasoning trace. This thought might involve analyzing the situation, evaluating the success of the previous step, strategizing the next move, or identifying necessary information. For example: "The search result provided the publication year but not the author's affiliation. I need to perform another search query focusing on the author."
Action ( $a_t$ ): Following the thought, the LLM determines and generates the next action to be executed. This could be interacting with an external tool (like a search engine, calculator, or API), querying a database, or formulating a response to the user. The action is derived directly from the reasoning articulated in the thought step.
Execution & New Observation ( $o_{t+1}$ ): The environment or a dedicated tool execution module performs the action $a_t$ . The result of this execution (e.g., API response, search result, calculation output, error message) becomes the observation $o_{t+1}$ for the next iteration of the loop.

This cycle continues until the agent determines, through its reasoning process, that the task is complete and generates a final answer or response.

The iterative flow in a ReAct agent. Observations trigger thoughts, thoughts guide actions, and action results become new observations.

Implementation via Prompting

ReAct is typically implemented by structuring the prompt provided to the LLM. The prompt instructs the model to explicitly generate text corresponding to its internal thought process before outputting the action command. A common format encourages the LLM to output responses following a template like:

Thought: [Agent's reasoning process goes here]
Action: [Agent's chosen action, e.g., Search[query] or Final Answer: [answer]]

The agent system then parses this output. If an Action is present, it's executed, and its output is appended to the prompt history as the next Observation. The updated history is then fed back into the LLM for the subsequent Thought-Action generation.

Example Interaction Snippet

Consider an agent tasked with finding the capital of France and its population.

Iteration 1:

Observation: What is the capital of France and its population?

Prompt includes:

Question: What is the capital of France and its population?
Think step-by-step. You have access to a Search tool. Use the format:
Thought: [Your reasoning]
Action: [Search[query] or Final Answer: answer]

LLM Output:

Thought: The question asks for two pieces of information: the capital of France and the population of that capital. I should first find the capital of France. I can use the Search tool for this.
Action: Search[capital of France]

Iteration 2:

Action Execution: The system executes Search[capital of France].
Observation: Paris is the capital of France.

Prompt includes (previous steps + new observation):

... [previous prompt history] ...
Observation: Paris is the capital of France.
Thought: [Your reasoning]
Action: [Search[query] or Final Answer: answer]

LLM Output:

Thought: Okay, the capital is Paris. Now I need to find the population of Paris. I should use the Search tool again, specifically for the population of Paris.
Action: Search[population of Paris]

Iteration 3:

Action Execution: The system executes Search[population of Paris].
Observation: The population of Paris was estimated to be 2.1 million in 2023.

Prompt includes:

... [previous prompt history] ...
Observation: The population of Paris was estimated to be 2.1 million in 2023.
Thought: [Your reasoning]
Action: [Search[query] or Final Answer: answer]

LLM Output:

Thought: I now have both pieces of information requested: the capital (Paris) and its population (2.1 million). I can formulate the final answer.
Action: Final Answer: The capital of France is Paris, and its population is approximately 2.1 million.

Advantages and Considerations

The ReAct framework offers significant advantages:

Improved Interpretability: The explicit Thought traces provide a clear window into the agent's reasoning process, making it easier to debug failures and understand its strategy.
Enhanced Robustness: By reasoning about observations, the agent can identify failed actions or unexpected outcomes (e.g., a tool returning an error) and attempt corrective actions or alternative strategies.
Better Handling of Complex Tasks: The framework naturally encourages breaking down complex problems into intermediate, manageable steps guided by internal reasoning.
Effective Tool Integration: ReAct provides a structured way to decide when and how to use external tools, grounding tool use in explicit reasoning.

However, expert practitioners should be aware of certain considerations:

Prompt Engineering: The performance of ReAct agents is highly sensitive to the structure and wording of the prompt. Crafting effective prompts that consistently elicit the desired Thought-Action format requires careful design and experimentation.
Increased Computational Cost: Generating explicit thoughts adds computational overhead (token usage and latency) compared to direct action generation. Each reasoning step requires an additional inference pass through the LLM.
Potential for Inefficiencies: Agents might occasionally get stuck in reasoning loops or take unnecessarily verbose paths if the thought process isn't well-guided or if the task lacks clear intermediate checkpoints.
Context Length Limitations: For tasks requiring many steps, the accumulated history of Observations, Thoughts, and Actions can eventually exceed the LLM's context window limit, requiring summarization or other context management techniques (discussed further in Chapter 3).

Despite these considerations, ReAct represents a foundational architecture for building more capable and reliable LLM agents. Its emphasis on explicit reasoning provides a powerful mechanism for tackling problems that require planning, tool use, and adaptation. Understanding and implementing ReAct is an important step towards developing sophisticated agentic systems. The next section delves into the practical implementation details.