AI Agents Explained: When LLMs Start Using Tools

Deep Dive: Stage 1 — The ReAct Loop: Thought → Action → Observation

• The dominant pattern for agents is ReAct (Reasoning + Acting).
• The model cycles through three steps until the task is complete: This loop continues until the model decides it has enough information to answer.

flowchart TD
    Start([User Goal]) --> T[Thought: What do I need?]
    T --> A[Action: Call a Tool]
    A --> O[Observation: Tool Result]
    O --> D{Goal reached?}
    D -- No --> T
    D -- Yes --> Answer([Return Final Answer])

sequenceDiagram
    participant U as User
    participant L as LLM
    participant T as Tool
    U->>L: User request
    L-->>L: Thought: what to do
    L->>T: Action: call tool
    T-->>L: Observation: result
    L-->>L: Next thought
    L-->>U: Final Answer

Observable outcome: The model cycles through three steps until the task is complete: This loop continues until the model decides it has enough information to answer.

Deep Dive: Stage 2 — How an Agent Processes a Request

• When a user sends a question to an agent-powered system, several layers of logic activate before any answer is returned.
• Understanding this flow helps you reason about latency, costs, and failure points.
• What happens at each node: - Inject Tool Schemas — before the first LLM call, all tool names, descriptions, and input types are serialised into the system prompt so the model knows what it can use.
• • LLM Reasoning — the model outputs a structured "Thought" explaining its next move.

flowchart TD
    U([User Request]) --> SYS[Inject Tool Schemas into LLM Context]
    SYS --> LLM1[LLM Reasoning: Thought  What do I need?]
    LLM1 --> TC[Tool Selection: Which tool and args?]
    TC --> TE[Tool Execution: Call external function]
    TE --> OBS[Observation: Capture tool output]
    OBS --> CHK{Goal reached?}
    CHK -- No --> LLM1
    CHK -- Yes --> ANS([Return Final Answer to User])

Observable outcome: - LLM Reasoning — the model outputs a structured "Thought" explaining its next move.

Deep Dive: Stage 3 — Tool Definitions: How an Agent Knows What It Can Do

• A tool is a function the model can call.
• In LangChain you define tools with a name, description, and input schema: The model receives the tool descriptions in its system prompt and decides which to call (and with what arguments) based on the task.
• It never sees the implementation — only the name and docstring.

from langchain.tools import tool

@tool
def search_web(query: str) -> str:
    """Search the web for current information. Use this for recent events or facts."""
    return web_search_api(query)

@tool
def run_python(code: str) -> str:
    """Execute Python code and return the output. Use this for calculations."""
    return exec_sandbox(code)

flowchart TD
    I[Input from User] --> LM[LLM Reasoning]
    LM --> D{Need a tool?}
    D -- No --> R[Return Answer]
    D -- Yes --> TS[Select Tool]
    TS --> EX[Execute Tool]
    EX --> OB[Observe Output]
    OB --> LM

Observable outcome: It never sees the implementation — only the name and docstring.

Deep Dive: Stage 4 — Deep Dive: Building a Simple Agent with LangChain

• The verbose=True flag shows you the full Thought/Action/Observation chain — invaluable for debugging.

from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain import hub

llm = ChatOpenAI(model="gpt-4o-mini")
tools = [search_web, run_python]

prompt = hub.pull("hwchase17/react")          # standard ReAct prompt
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "Who was US president when Titanic was released?"})
print(result["output"])

Observable outcome: The verbose=True flag shows you the full Thought/Action/Observation chain — invaluable for debugging.

Deep Dive: Stage 5 — Real-World Applications: Real-World Agent Use Cases

Observable outcome: You can explain how “Real-World Applications: Real-World Agent Use Cases” changes the architecture or implementation path.

Deep Dive: Stage 6 — Practical: Debugging Agent Behavior

• Agents fail in opaque ways that are hard to catch without systematic debugging.
• Here is a practical workflow for diagnosing misbehaving agents.
• Step 1 — Enable verbose output.
• In LangChain, set verbose=True on the AgentExecutor .

executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=10)

Observable outcome: In LangChain, set verbose=True on the AgentExecutor .