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

MCP — Model Context Protocol — is the open standard that connects agents to the outside world. Think of it as USB-C for AI. Before MCP, every tool needed custom integration code — an N-times-M problem. MCP solves this with three core primitives. Tools — actions the agent can invoke, like calling an API or running a query. Resources — data the agent can read, like files, databases, or live feeds. And Prompts — reusable templates that standardize how the agent handles common tasks. Your agent connects to an MCP server, discovers what's available, and uses what it needs. It's now governed by the Linux Foundation, backed by Anthropic, OpenAI, Google, and Microsoft — 97 million SDK downloads a month, 5,800+ servers. And there's a companion protocol: Google's A2A — Agent-to-Agent — for when agents need to talk to each other, not just to tools. MCP for connecting to the world, A2A for coordinating with other agents.

Memory: How Agents Learn

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

Managing Memory

Compress, summarize, discard memory strategies

Memory needs active management — you can't just stuff everything into the context window. It fills up. Here's a real example: Claude Code — Anthropic's coding agent — has a 200K token context window. Sounds huge, but a medium codebase can be 500K+ tokens. So it compresses: turns full file reads into summaries, keeps only relevant function signatures, discards irrelevant test output. Without this, the agent literally forgets what it was doing mid-task. The industry calls this "context engineering" — deliberately curating the information an agent sees. Anthropic published a major guide on it. The key insight: the quality of an agent's output is directly proportional to the quality of its context. Too much in, confusion out. Good context engineering is arguably more important than model selection.

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)

From Simple to Powerful

Progressive enhancement: model, tools, memory

The Honest Assessment

Where This Is Going

Evolution from autocomplete to autonomous agents

Where's this all headed? We're in the copilot-to-agent transition right now. Autocomplete is yesterday. Copilots are today's baseline. Agents — systems that plan and act autonomously — are where the industry is moving fast. The pace is staggering: computer use went from 14.9% to 72.5% accuracy in just 16 months. Inference costs dropped 92% in three years. NIST just launched an AI Agent Standards Initiative this month. And the next frontier is already here: multi-agent teams where specialists coordinate via A2A protocol, equipped with standardized Agent Skills — Anthropic's open standard for packaging agent capabilities, already adopted by Microsoft, OpenAI, and Figma. And for guiding how agents work within your codebase, there's AGENTS.md — an open standard already in 2,500+ repos. Think of it as a README, but for AI. The infrastructure is being built right now.

Remember These Three Things

Go Deeper

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

00:00