AI Agents

Chatbots answer questions. Agents get things done.

An agent can research a topic across dozens of sources, write a report, and email it to your team—all while you're in a meeting. This track teaches you to build autonomous systems that work independently on complex, multi-step tasks.

What Makes an Agent?

Every agent follows the same loop:

Types of Agents

Task-Specific Agents

Built for one job, done exceptionally well:

General-Purpose Agents

Flexible assistants for varied tasks:

• Personal Assistant: Calendar, email, task management
• Project Coordinator: Track work, manage workflows
• Problem Solver: Open-ended analysis and recommendations

Multi-Agent Systems

Multiple agents working together:

Sub-Agents: Divide and Conquer

Complex tasks need specialized workers. Sub-agents handle specific pieces of work with focused context and limited tools.

Why Sub-Agents?

Built-in Sub-Agents

Claude Code includes ready-to-use sub-agents:

• Plan Sub-Agent: Dedicated planning with task breakdown
• Explore Sub-Agent: Fast, read-only codebase search

Creating Custom Sub-Agents

Define sub-agents as markdown files in .claude/agents/:

1---
2name: code-reviewer
3description: Expert code review specialist for quality and security reviews.
4tools: Read, Grep, Glob
5---
6 
7You are a code review specialist. When reviewing code:
8 
91. Identify security vulnerabilities (injection, auth issues)
102. Check for performance problems (N+1 queries, memory leaks)
113. Verify adherence to project coding standards
124. Suggest specific, actionable improvements
13 
14Be thorough but constructive. Explain *why* something is a problem.

Common Tool Combinations

Tools: The Agent's Hands

Agents need tools to interact with the world. Without tools, they can only talk. With tools, they can do.

Designing Good Tools

Clear purpose: Each tool does one thing well

1# Good: specific
2"search_company_docs" - searches internal documentation
3 
4# Bad: vague
5"search" - search what? where?

Defined inputs: Specific parameters with types

1{
2    "name": "search_docs",
3    "input_schema": {
4        "properties": {
5            "query": {"type": "string", "description": "Search terms"},
6            "category": {"type": "string", "enum": ["policies", "products"]}
7        }
8    }
9}

Predictable outputs: Consistent return format so the agent can parse results reliably.

Memory: The Agent's Mind

Agents need memory to maintain context across steps and conversations.

Short-term Memory

• Current conversation
• Working notes
• Intermediate results

Long-term Memory

• Past interactions
• Learned preferences
• Domain knowledge

Memory Strategies

Track Modules

Quick Start Example

Here's a minimal research agent:

1from anthropic import Anthropic
2 
3client = Anthropic()
4 
5def research_agent(question: str) -> str:
6    """Agent that researches a question using web search."""
7 
8    tools = [{
9        "name": "web_search",
10        "description": "Search the web for information",
11        "input_schema": {
12            "type": "object",
13            "properties": {
14                "query": {"type": "string"}
15            },
16            "required": ["query"]
17        }
18    }]
19 
20    messages = [{
21        "role": "user",
22        "content": f"""Research this question: {question}
23 
24        Use web_search to find information.
25        Cite your sources in the final answer."""
26    }]
27 
28    # Agent loop
29    while True:
30        response = client.messages.create(
31            model="claude-sonnet-4-20250514",
32            max_tokens=4096,
33            tools=tools,
34            messages=messages
35        )
36 
37        if response.stop_reason == "tool_use":
38            # Execute tools, add results, continue
39            tool_results = execute_tools(response.content)
40            messages.append({"role": "assistant", "content": response.content})
41            messages.append({"role": "user", "content": tool_results})
42        else:
43            # Done - extract final text
44            return extract_text(response.content)

Best Practices

Start Simple

1. One task, one tool: Get that working first
2. Add tools gradually: One capability at a time
3. Add memory when needed: Not before
4. Split into sub-agents: When context gets too complex

Common Pitfalls

Safety First

• Human approval for sensitive actions (delete, send, pay)
• Rate limits and cost caps
• Logging all agent actions
• Sandboxed environments for testing
• Clear boundaries on what agents can/cannot do

Real-World Applications

Resources

• Claude Agent SDK — Official documentation
• Building Effective Agents — Anthropic research
• Tool Use Guide — API reference
• Anthropic Cookbook — Example implementations

Prerequisites

Before starting this track:

• Completed Start Here track
• Basic Python knowledge
• Familiarity with APIs (REST, HTTP)
• Understanding of LLMs (Claude, ChatGPT)