LLM Agents

This module covers the applications layer: using language models inside systems that call tools and take actions. Earlier pages explain the operations with NumPy, and the small GPT lab trains them with PyTorch. The agent code here illustrates control flow and needs a model API and tool implementations to run.

From LLM to Agent

An LLM by itself can only generate text. An agent can:

The key difference: agents interact with the real world through tools.

A Real Example

User: “What’s the weather in Tokyo right now?”

The ReAct Pattern: Think, Then Act

The most influential agent pattern is ReAct (Reasoning + Acting). The LLM alternates between thinking about what to do and acting to gather information:

What to look for: Try both examples and click “Next Step” to step through each cycle. Watch how the Thought phase identifies what’s missing, the Action phase calls a specific tool to fill that gap, and the Observation phase feeds the result back in. Notice that the agent may need multiple cycles before it has enough information to answer.

def react_agent(question, tools, max_steps=5):
    history = f"Question: {question}\n"
    
    for step in range(max_steps):
        # LLM generates thought + action
        response = llm.generate(f"""
        {history}
        
        Think about what to do next, then take an action.
        Available tools: {[t.name for t in tools]}, finish(answer)
        
        Thought: """)
        
        thought, action = parse_response(response)
        history += f"Thought: {thought}\nAction: {action}\n"
        
        if action.startswith("finish"):
            return extract_answer(action)
        
        tool_name, args = parse_action(action)
        result = tools[tool_name].execute(args)
        history += f"Observation: {result}\n"
    
    return "Max steps reached"

Tool Use: Giving LLMs Superpowers

Common Tools

Function Calling

Modern LLMs support structured function calling — the model outputs a JSON object specifying which tool to use and with what arguments. The system executes the function and feeds the result back to the LLM.

Structured Outputs

Modern LLM APIs support structured outputs — the model generates valid JSON matching a predefined schema, making tool calls reliable:

{
  "tool": "web_search",
  "arguments": { "query": "population of Paris 2024" },
  "thought": "I need current population data"
}

This eliminates brittle text parsing. The model is constrained to output valid JSON, so tool calls always have the right format.

Model Context Protocol (MCP)

MCP is an emerging open standard for connecting LLMs to external tools and data sources. Instead of each agent framework building custom integrations, MCP provides a universal protocol:

Think of MCP as “USB-C for AI” — a standard connector that lets any LLM application work with any tool server.

Memory Systems

Humans don’t forget conversations. Neither should agents.

The Context Window Problem

LLMs have limited context windows (4K-128K tokens). An agent that runs for many steps can exceed this limit.

Solutions:

• Summarization: Compress old conversation turns
• Retrieval: Use embeddings to find relevant past context
• Structured storage: Save facts to a database, retrieve as needed

Planning: Breaking Down Complex Tasks

Sophisticated agents plan before acting. For a request like “Write a blog post about transformer architectures,” an agent might:

Each step might involve multiple ReAct cycles. The agent tracks progress and adjusts the plan if a step fails.

Agent Architectures

Common Challenges

# Hallucinated actions
if action.tool not in available_tools:
    return "Invalid tool. Available: {list(available_tools)}"

# Infinite loops
if step_count > max_steps:
    return "Stopping: exceeded step limit"
if action in recent_actions[-3:]:
    return "Stopping: detected loop"

# Error recovery
try:
    result = tool.execute(args)
except Exception as e:
    result = f"Error: {e}. Try a different approach."

Quick Summary

Congratulations!

You’ve completed the entire Transformer 101 course — from RNNs to agents. You now understand:

• How RNNs process sequences with memory
• Why vanishing gradients motivated new architectures
• How attention lets tokens communicate
• The complete Transformer architecture
• How BERT and GPT specialize the transformer for different tasks
• How agents extend LLMs with tools and reasoning

To finish the course with a model you trained, complete Train Your Own GPT and keep its checkpoint, loss curves, and training report. For another experiment, try Fine-tune an Open Model and compare its results on held-out task examples.