AI Agents and the ReAct Loop: Explained Visually

Chatbot vs AI agent

The building blocks of an agent

The ReAct loop, step by step

ReAct was introduced by Yao et al. in 2022. The model writes a Thought (what it should do next), then an Action (a tool call). The tool's result comes back as an Observation. The loop repeats until the model writes a Final Answer.

Press Play to watch an HR agent answer a real question. The scratchpad on the right side of the loop shows exactly what the model sees.

How tool calling works under the hood

The LLM never runs code itself. Tool calling is a conversation between your code and the model:

1. You describe the tools to the model: a name, a description and a JSON schema for the arguments.
2. The model replies with a tool call instead of text, for example {"name": "calculator", "arguments": {"expression": "1.5 * 10 - 6"}}.
3. Your code runs the function and sends the result back as a "tool" message.
4. The model continues: it either calls another tool or writes the final answer.

A tool definition looks like this:

{
  "name": "policy_search",
  "description": "Search the HR policy handbook. Use for any question about leave, expenses or rules.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {"type": "string", "description": "What to search for, in plain English"}
    },
    "required": ["query"]
  }
}

And the agent loop itself is short. This version uses the OpenAI Python SDK; other providers work the same way.

import json
from openai import OpenAI

client = OpenAI()
TOOLS = {"policy_search": policy_search, "calculator": calculator}   # your Python functions

def run_agent(question, tool_specs, max_steps=6):
    messages = [
        {"role": "system", "content": "You are an HR assistant. Use tools. Never guess numbers."},
        {"role": "user", "content": question},
    ]
    for _ in range(max_steps):                       # guardrail: never loop forever
        reply = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages, tools=tool_specs
        ).choices[0].message
        if not reply.tool_calls:                     # no tool needed: this is the final answer
            return reply.content
        messages.append(reply)
        for call in reply.tool_calls:                # Action -> run the real function
            args = json.loads(call.function.arguments)
            result = TOOLS[call.function.name](**args)
            messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})  # Observation
    return "Sorry, I could not finish this request."

Common agent patterns

MCP: a standard plug for tools

The Model Context Protocol (MCP), released by Anthropic in late 2024 and now supported by OpenAI, Google, Microsoft and most agent tools, is an open standard for connecting agents to tools and data. Instead of writing custom code for every app, a company builds one MCP server (for example, for Jira, a database or Google Drive), and any MCP-compatible agent can use it. Think of it as USB-C for AI tools.

Popular agent frameworks

Keeping agents safe and reliable