AI Agents 101

What is an Agent?

Agents are Everywhere

3 Parts, 1 Agent

Every agent needs a brain, hands, and memory

The Brain: Thinking Models

How Thinking Changes Everything

Without thinking vs with thinking comparison

Tools: The Agent's Hands

MCP: The Universal Adapter

Memory: How Agents Learn

Short-term, long-term memory, and context window

Managing Memory

Compress, summarize, discard memory strategies

Step 1: Receive Task

Robot receives task with 3 component icons faded

Task: Analyze quarterly sales data

Step 2: Observe — Tools

Robot uses Tools to read spreadsheet data

Step 3: Think — Brain

Step 4: Act — Tools

Step 5: Remember — Memory

Step 6: Think + Remember

Robot combines thinking and memory to find insights

Step 7: Act — Tools

Step 8: Complete!

All 3 components working together, task complete

3 Ways to Build Agents

Pattern 1: The Simple Agent

Best for: well-defined tasks, getting started, clear objectives

Pattern 2: Sub-Agents

Best for: workflows with specialized subtasks

Pattern 3: The Orchestrator

Orchestrator routing to specialist agents

Best for: multiple domains, varied request types

How to Choose

Your First Agent

from claude_agent_sdk import query, ClaudeAgentOptions

async for msg in query(
    prompt="Analyze sales data, find trends," # User Request
           "and build a dashboard", 
    options=ClaudeAgentOptions(
        model="claude-sonnet-4-6",             # Brain
        system_prompt="You are a data analyst.", # Agent Role
        allowed_tools=[
            "Read",   # read sales CSV
            "Bash",   # run SQL queries
            "Write",  # create dashboard
        ],
        permission_mode="acceptEdits",
    ),
):
    print(msg)

When Agents Write Code

Sequential Tool Calls

# 4 round trips to the model

tool_call("read_file", "data.csv")
  ↓ return to model
tool_call("query_db", "SELECT ...")
  ↓ return to model
tool_call("check_status")
  ↓ return to model
tool_call("format_output")

# Each ↓ = latency + tokens
# Each ↓ = context drift risk

Code as Tool Use

# 1 round trip — agent writes a program

async def analyze():
    data = read_csv("data.csv")
    try:
        results = db.query(
            "SELECT region, SUM(rev)"
            " FROM sales GROUP BY region"
        )
    except DBError:
        results = fallback_query(data)
    return format_chart(results)

# Logic preserved in one piece

Calculator vs Spreadsheet — the agent becomes a programmer

Here's a pattern that changes how you think about tool use. In a typical agent, the model calls tools one at a time — read file, then query database, then check result, then format output. Four round trips to the model, four chances for the context to drift. [pause] But what if the agent could write a program instead? Not call tools sequentially, but generate a script with conditionals, loops, error handling — and execute it in one shot. [pause] Instead of 'call API, check status, retry if failed, parse response' as four separate tool calls, the agent writes a function that does all four in a try-catch block. One round trip. The agent becomes a programmer, not a button-presser. [pause] This matters because every round trip costs latency and tokens — and more importantly, each round trip is a chance for the model to lose its train of thought. Writing a program preserves the full logic in one coherent piece. Some call this 'code-as-tool-use.' It's the difference between giving someone a calculator and giving them a spreadsheet.

From Simple to Powerful

Progressive enhancement: model, tools, memory

The Honest Assessment

Where This Is Going

Evolution from autocomplete to autonomous agents

Remember These Three Things

Go Deeper

Anthropic — Building Effective Agents Anthropic — Context Engineering MCP — modelcontextprotocol.io Cloudflare — Agents SDK A2A — a2a-protocol.org AGENTS.md — agents.md

00:00