Building LangChain Agents: Tools, AgentExecutor, and the ReAct Loop

From Chains to Agents

A chain follows a fixed path: prompt goes in, response comes out. An agent, by contrast, decides at each step what action to take. It can call tools, inspect results, reason about what to do next, and repeat until it has enough information to answer the original question.

LangChain agents implement the ReAct (Reasoning + Acting) pattern. The model alternates between reasoning about the problem and taking actions (tool calls). This loop continues until the model decides it can produce a final answer.

Defining Tools

Tools are functions that an agent can invoke. Each tool has a name, a description (used by the LLM to decide when to call it), and an implementation.

flowchart TD
    USER(["User message"])
    LLM["LLM call<br/>with tools schema"]
    DECIDE{"Model wants<br/>to call a tool?"}
    EXEC["Execute tool<br/>sandboxed runtime"]
    RESULT["Append tool_result<br/>to messages"]
    GUARD{"Output passes<br/>guardrails?"}
    DONE(["Final reply"])
    BLOCK(["Refuse and log"])
    USER --> LLM --> DECIDE
    DECIDE -->|Yes| EXEC --> RESULT --> LLM
    DECIDE -->|No| GUARD
    GUARD -->|Yes| DONE
    GUARD -->|No| BLOCK
    style LLM fill:#4f46e5,stroke:#4338ca,color:#fff
    style EXEC fill:#ede9fe,stroke:#7c3aed,color:#1e1b4b
    style GUARD fill:#f59e0b,stroke:#d97706,color:#1f2937
    style DONE fill:#059669,stroke:#047857,color:#fff
    style BLOCK fill:#dc2626,stroke:#b91c1c,color:#fff

from langchain_core.tools import tool

@tool
def multiply(a: float, b: float) -> float:
    """Multiply two numbers together."""
    return a * b

@tool
def web_search(query: str) -> str:
    """Search the web for current information about a topic."""
    # In production, this would call a search API
    return f"Search results for: {query}"

print(multiply.name)        # "multiply"
print(multiply.description) # "Multiply two numbers together."

The @tool decorator automatically extracts the function name, docstring, and parameter types to build the tool schema. The LLM sees the name, description, and parameter schema when deciding which tool to call.

Creating an Agent with Tool Binding

Modern LangChain agents use the create_tool_calling_agent function, which leverages native tool-calling capabilities of chat models rather than parsing text output.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import create_tool_calling_agent, AgentExecutor

# Define the prompt with required placeholders
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful math assistant."),
    MessagesPlaceholder("chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder("agent_scratchpad"),
])

# Create model and bind tools
llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [multiply, web_search]

# Build the agent
agent = create_tool_calling_agent(llm, tools, prompt)

# Wrap in AgentExecutor
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

The agent_scratchpad placeholder is where intermediate tool calls and results are stored during the reasoning loop.

Running the Agent

result = executor.invoke({
    "input": "What is 47.5 multiplied by 23.8?"
})
print(result["output"])

With verbose=True, you will see the full reasoning trace:

1. The agent receives the question
2. It decides to call the multiply tool with arguments a=47.5, b=23.8
3. The tool returns 1130.5
4. The agent produces the final answer: "47.5 multiplied by 23.8 is 1,130.5"

The ReAct Loop Internals

Each iteration of the agent loop follows this pattern:

1. Observe — the current state (user question plus any previous tool results) is formatted into the prompt
2. Reason — the LLM generates a response that may include tool calls
3. Act — if tool calls are present, the executor runs each tool and appends results to the scratchpad
4. Repeat — the loop continues until the LLM responds without tool calls (the final answer)

The AgentExecutor manages this loop and provides safeguards:

executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=10,         # Prevent infinite loops
    handle_parsing_errors=True, # Recover from malformed output
    return_intermediate_steps=True, # Include tool call history
)

result = executor.invoke({"input": "Search for LangChain news"})

# Access intermediate steps
for step in result["intermediate_steps"]:
    action, observation = step
    print(f"Tool: {action.tool}, Input: {action.tool_input}")
    print(f"Result: {observation}")

Multi-Tool Agent Example

Here is a more complete agent that combines calculation and search capabilities.

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import create_tool_calling_agent, AgentExecutor

@tool
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression. Use Python syntax."""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Error: {e}"

@tool
def get_current_date() -> str:
    """Get today's date."""
    from datetime import date
    return date.today().isoformat()

tools = [calculate, get_current_date]

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with access to tools. "
               "Always use tools when a calculation is needed."),
    ("human", "{input}"),
    MessagesPlaceholder("agent_scratchpad"),
])

agent = create_tool_calling_agent(
    ChatOpenAI(model="gpt-4o-mini", temperature=0),
    tools,
    prompt,
)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

response = executor.invoke({
    "input": "What day is it and what is 2 raised to the 20th power?"
})
print(response["output"])

The agent will call both tools — get_current_date and calculate("2**20") — then combine the results into a coherent answer.

FAQ

What is the difference between create_tool_calling_agent and the older create_react_agent?

create_tool_calling_agent uses the native tool-calling API supported by modern LLMs, which returns structured tool calls in the response. create_react_agent relies on text-based parsing of the ReAct format. The tool-calling approach is more reliable and is the recommended default.

How do I prevent an agent from running forever?

Set max_iterations on the AgentExecutor. The default is 15. If the agent exceeds this limit, it returns an error message. You can also set max_execution_time (in seconds) as a wall-clock timeout.

Can an agent call the same tool multiple times?

Yes. The agent can call any tool any number of times across iterations. It can also call multiple tools in a single step if the model supports parallel tool calling.

---

#LangChain #AIAgents #ReAct #ToolUse #Python #AgenticAI #LearnAI #AIEngineering