LLM Agents

A note on this module: The previous modules focused on building everything from scratch with NumPy. This final module takes a step back and looks at the applications layer — how LLMs are used as components in larger systems. The code here is more conceptual than runnable, since agents rely on external APIs and tools.

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:

Try both examples — click “Next Step” to watch the agent’s reasoning unfold. Notice how each cycle has three parts:

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.

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."

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

The next step? Build something. Pick a project and implement what you’ve learned. The best way to solidify understanding is to create.