AI Agents Explained: What Is a ReAct Loop and How Does It Work?

AI Agents Explained: What Is a ReAct Loop and How Does It Work?

Artificial intelligence agents have evolved far beyond simple chatbots. Today, the most capable AI systems don't just generate text—they reason, act, and adapt in real time. At the heart of this evolution lies a powerful pattern called the **ReAct loop**. If you've ever wondered how AI agents decide which tool to use, when to ask for clarification, or how to recover from mistakes, the answer is often a ReAct loop.

In this article, we’ll break down what a ReAct loop is, why it matters, and how you can build your own agent using this pattern. We’ll include concrete installation steps, code examples, and practical usage scenarios drawn from leading research and industry practices.

What Is a ReAct Loop?

The term "ReAct" stands for **Reasoning + Acting**. It was popularized by researchers seeking to combine large language models (LLMs) with the ability to take actions in an environment—such as calling APIs, searching databases, or executing code.

A ReAct loop is a cyclical process where an AI agent:

1. **Receives a prompt or observation** (e.g., a user question or sensor data). 2. **Reasons about what to do next** using an LLM. 3. **Acts** by calling a tool, making a decision, or generating a response. 4. **Observes the result** of that action. 5. **Loops back** to reasoning, using the new observation as context.

This cycle continues until the agent determines it has answered the user’s request or reached a terminal state. The loop gives agents a structured way to handle multi-step tasks, recover from errors, and use external tools.

Why Is ReAct Important?

Traditional LLMs are stateless—they generate a single response without any ability to verify facts or perform actions. ReAct loops turn LLMs into autonomous agents by:

• **Enabling tool use**: The agent can call search engines, calculators, or databases.
• **Supporting self-correction**: If an action fails, the agent can try another approach.
• **Improving transparency**: Each step is logged, making the reasoning process visible.
• **Handling long tasks**: The loop can run many iterations, chaining actions together.

Industry leaders like OpenAI, Microsoft, and Anthropic have all incorporated ReAct-like patterns into their agent frameworks. For example, OpenAI’s function calling and Microsoft’s AutoGen both rely on iterative reasoning and acting.

How the ReAct Loop Works in Practice

Let’s walk through a concrete example. Suppose you ask an AI agent: *"What was the temperature in London on January 15, 2024?"*

Without a ReAct loop, a standard LLM might guess or say "I don't have real-time data." With a ReAct loop, the agent follows these steps:

1. **Reason**: "I need to find the temperature in London on that date. I can use a weather API." 2. **Act**: Call the weather API with parameters `city: London, date: 2024-01-15`. 3. **Observe**: The API returns `{ "temperature": 5, "unit": "celsius" }`. 4. **Reason**: "I have the temperature. The answer is 5°C." 5. **Act**: Respond to the user with the answer.

If the API call fails (e.g., rate limit), the agent can reason again: "The API failed. I should retry after a delay or use a fallback source."

This loop is the core of modern AI agents.

Requirements for Building a ReAct Agent

Before we dive into code, let's outline what you’ll need.

Hardware Requirements

• A computer with internet access.
• At least 8 GB of RAM (16 GB recommended for running local models).

Software Requirements

• **Python 3.10 or newer** (Python 3.11 recommended).
• **pip** package manager.
• An **OpenAI API key** (or a local LLM provider like Ollama for open-source models).

Knowledge Prerequisites

• Basic Python programming.
• Familiarity with command-line interfaces.
• Understanding of REST APIs is helpful but not required.

Step-by-Step Installation

We’ll build a minimal ReAct agent using Python and the OpenAI API. This agent will be able to search the web and perform calculations.

Step 1: Set Up a Python Virtual Environment

First, create an isolated environment for our project. This prevents dependency conflicts.

python3 -m venv react-agent-env
source react-agent-env/bin/activate   # On Windows: react-agent-env\Scripts\activate

Step 2: Install Required Libraries

We need the OpenAI Python client and a library for making HTTP requests.

pip install openai requests python-dotenv

• `openai` – allows us to call GPT models.
• `requests` – for making API calls to external services.
• `python-dotenv` – to securely store our API key.

Step 3: Set Up Your API Key

Create a file named `.env` in your project folder. Add your OpenAI key like this:

OPENAI_API_KEY=sk-your-key-here

Replace `sk-your-key-here` with your actual key. To get one, sign up at [OpenAI](https://openai.com) and generate a key from the API dashboard.

Step 4: Create the Agent Script

Now, create a file called `react_agent.py` and paste the following code. This script implements a basic ReAct loop.

import os
import json
import requests
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Define available tools
tools = [
    {
        "name": "web_search",
        "description": "Search the web for current information",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"}
            },
            "required": ["query"]
        }
    },
    {
        "name": "calculator",
        "description": "Perform mathematical calculations",
        "parameters": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression to evaluate"}
            },
            "required": ["expression"]
        }
    }
]

def web_search(query):
    """Simulate a web search (replace with real API later)"""
    return f"Search results for '{query}': Sample result 1, Sample result 2"

def calculator(expression):
    """Evaluate a math expression safely"""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Error: {str(e)}"

def run_agent(user_input, max_iterations=5):
    """Main ReAct loop"""
    messages = [{"role": "user", "content": user_input}]
    
    for _ in range(max_iterations):
        # Step 1: Reason - ask the LLM what to do
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        assistant_message = response.choices[0].message
        
        # If the model says it's done, break
        if assistant_message.content and not assistant_message.tool_calls:
            print(f"Assistant: {assistant_message.content}")
            break
        
        # Step 2: Act - process tool calls
        if assistant_message.tool_calls:
            messages.append(assistant_message)
            for tool_call in assistant_message.tool_calls:
                function_name = tool_call.function.name
                arguments = json.loads(tool_call.function.arguments)
                
                # Execute the appropriate tool
                if function_name == "web_search":
                    result = web_search(arguments["query"])
                elif function_name == "calculator":
                    result = calculator(arguments["expression"])
                else:
                    result = "Unknown tool"
                
                # Step 3: Observe - add the result back to context
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
                
                print(f"Action: {function_name}({arguments}) -> {result}")
        
        # Continue loop with new observation
    
    return messages

if __name__ == "__main__":
    user_query = input("Enter your question: ")
    run_agent(user_query)

This script defines two tools—`web_search` and `calculator`—and runs a loop that repeatedly asks the LLM to decide which tool to call, executes it, and feeds the result back.

Usage Examples

Now that we have our agent, let's test it with real queries.

Example 1: Simple Calculation

Run the script and ask:

Enter your question: What is 24 * 7?

The agent will: 1. Reason that a calculation is needed. 2. Call the `calculator` tool with `expression: "24 * 7"`. 3. Observe the result `168`. 4. Respond with the answer.

You should see output like:

Action: calculator({'expression': '24 * 7'}) -> 168
Assistant: 24 multiplied by 7 equals 168.

Example 2: Multi-Step Task

Ask a question that requires both tools:

Enter your question: What is the population of Japan divided by 10 million?

The agent might first search for Japan's population, then perform the division. The loop handles both steps sequentially.

Example 3: Error Recovery

Test what happens when a tool fails. Modify the `calculator` function to raise an exception intentionally, then ask:

Enter your question: What is the square root of -1?

With complex numbers, the agent might try a different approach or explain the limitation.

Extending the Agent with Real Tools

The example above uses simulated search. To make it truly useful, replace `web_search` with a real API like SerpAPI or Bing Search. Here’s how to integrate a real search:

1. Install the `serpapi` library:

   pip install google-search-results

2. Update the `web_search` function:

   from serpapi import GoogleSearch

   def web_search(query):
       params = {
           "q": query,
           "api_key": os.getenv("SERPAPI_KEY"),
           "num": 3
       }
       search = GoogleSearch(params)
       results = search.get_dict()
       snippets = [r.get("snippet", "") for r in results.get("organic_results", [])]
       return "\n".join(snippets)

3. Add `SERPAPI_KEY` to your `.env` file.

Now your agent can fetch real-time information from the web.

Best Practices for Building ReAct Agents

Based on patterns from OpenAI, Microsoft, and Anthropic, here are key recommendations:

• **Limit iterations**: Always set a maximum loop count (e.g., 5–10) to prevent infinite loops.
• **Validate tool inputs**: Sanitize parameters before executing external calls.
• **Log every step**: Print or store each action and observation for debugging.
• **Use structured tool descriptions**: Clearly describe what each tool does and its parameters. The LLM relies on this to choose correctly.
• **Handle edge cases**: Prepare for API failures, empty results, or ambiguous user queries.

Conclusion

The ReAct loop is a foundational pattern for building intelligent AI agents. By combining reasoning and acting in a continuous cycle, agents can solve complex tasks, use external tools, and recover from errors—all with transparency.

In this article, you learned:

• What a ReAct loop is and why it matters.
• How the reasoning-acting-observing cycle works.
• How to build your own ReAct agent with Python and OpenAI.
• How to extend it with real tools like web search.

As AI continues to evolve, the ReAct loop will remain a core design principle. Whether you’re building a customer support bot, a research assistant, or an automation tool, understanding this pattern gives you the power to create agents that don’t just talk—they act.

Now it’s your turn. Install the code, experiment with different tools, and see what your agent can do. The loop is just the beginning.