Learn How to Build an AI Agent from Scratch
Master AI agent development with 12 progressive sessions. Build the agent loop, tool systems, planning, memory, and multi-agent coordination—one concept at a time.
The Core Pattern
Every AI coding agent shares the same loop: call the model, execute tools, feed results back. Production systems add policy, permissions, and lifecycle layers on top.
while True:
response = client.messages.create(messages=messages, tools=tools)
if response.stop_reason != "tool_use":
break
for tool_call in response.content:
result = execute_tool(tool_call.name, tool_call.input)
messages.append(result)Message Growth
Watch the messages array grow as the agent loop executes
Learning Path
12 progressive sessions, from a simple loop to isolated autonomous execution
The Agent Loop
The minimal agent kernel is a while loop + one tool
Tools
The loop stays the same; new tools register into the dispatch map
TodoWrite
An agent without a plan drifts; list the steps first, then execute
Subagents
Subagents use independent messages[], keeping the main conversation clean
Skills
Inject knowledge via tool_result when needed, not upfront in the system prompt
Compact
Context will fill up; three-layer compression strategy enables infinite sessions
Tasks
A file-based task graph with ordering, parallelism, and dependencies -- the coordination backbone for multi-agent work
Background Tasks
Run slow operations in the background; the agent keeps thinking ahead
Agent Teams
When one agent can't finish, delegate to persistent teammates via async mailboxes
Team Protocols
One request-response pattern drives all team negotiation
Autonomous Agents
Teammates scan the board and claim tasks themselves; no need for the lead to assign each one
Worktree + Task Isolation
Each works in its own directory; tasks manage goals, worktrees manage directories, bound by ID
Architectural Layers
Five orthogonal concerns that compose into a complete agent
Tools & Execution
2 versionsPlanning & Coordination
4 versionsMemory Management
1 versionsConcurrency
1 versionsCollaboration
4 versionsFrequently Asked Questions
Everything you need to know about building AI agents
This website is a comprehensive, step-by-step guide on how to build an AI agent from scratch. We take you through a 12-session journey, starting from a simple agent loop and progressively adding capabilities like tool use, planning, memory management, concurrency, and multi-agent collaboration. Each session includes working code, interactive simulations, and detailed documentation.
You don't need to be an AI expert, but basic programming knowledge is required. If you're comfortable with Python and understand basic programming concepts (loops, functions, classes), you'll be able to follow along. We explain AI-specific concepts as we go, making it accessible to software engineers, students, and tech enthusiasts who want to understand how AI agents work under the hood.
The 12 progressive sessions cover:
1. The Agent Loop - Core while-loop pattern (response → tool execution)
2. Tools - Giving your agent capabilities (read, write, execute)
3. TodoWrite - Task management and nag system
4. Subagents - Context isolation for parallel tasks
5. Skills - On-demand loading of specialized capabilities
6. Compact - Memory management and context compression
7. Tasks - Dependency-aware task boards
8. Background Tasks - Non-blocking execution with notifications
9. Agent Teams - Multi-agent coordination via mailboxes
10. Team Protocols - FSM-based team collaboration patterns
11. Autonomous Agents - Self-directed agent execution
12. Worktree + Task Isolation - Production-ready task isolation
Yes! Every session includes complete, runnable Python code. You can:
- View source code directly in the browser
- Download the full implementation
- See diff between versions to understand exactly what changed
- Run the code locally with your own API keys
The code is designed to be educational but also production-ready, following best practices from real-world agent systems like Claude Code.
Absolutely. Each session features an interactive simulator where you can:
- Watch the agent loop execute step-by-step
- See how messages flow between user, agent, and tools
- Visualize memory growth and compression
- Observe multi-agent communication
- Control execution speed and pause at any point
This helps you understand the concepts before diving into the code.
Most tutorials either stay too simple (basic API calls) or jump to complex frameworks. We take a progressive disclosure approach:
- Build from scratch - No hidden abstractions, you see every line
- Incremental complexity - Each session adds one concept
- Real-world patterns - Based on how production agents like Claude Code work
- Interactive learning - Simulations, visualizations, and hands-on coding
- Complete codebase - Not snippets, but full working implementations
You understand *why* each architectural decision is made.
By the end, you'll have built a production-ready AI coding agent capable of:
- Autonomous task planning and execution
- Tool use (file operations, code execution, web search)
- Long-running task management with memory
- Multi-agent collaboration for complex projects
- Background task execution
- Isolated task environments
You'll understand the architecture well enough to customize it for your own use cases—whether that's a coding assistant, research agent, or automated workflow system.
Yes! While the focus is on core agent architecture, we cover important production topics:
- Security - Sandboxed execution, permission systems
- Scalability - Concurrency patterns and resource management
- Error handling - Recovery from tool failures and API errors
- Monitoring - Logging, tracing, and observability hooks
- Cost optimization - Context compression and efficient token usage
- Isolation - Worktree-based task separation for safety
The final sessions specifically address making your agent robust and deployable.
The core stack is intentionally minimal:
- Python - Primary language
- Anthropic API - Claude for language model capabilities
- Standard library - No heavy frameworks, clear dependencies
The simplicity ensures you focus on agent concepts, not framework specifics.
Yes, completely free and open source. The educational content and code are provided under the MIT License. You can:
- Use the code in personal projects
- Build commercial products based on the agent architecture
- Modify and distribute your own versions
- Contribute improvements back to the community
We believe in open education and want to see what you build!
Time varies based on your pace and how deep you go:
- Quick overview - 2-3 hours (read + watch simulations)
- Hands-on coding - 1-2 days (implement along with each session)
- Deep mastery - 1-2 weeks (experiment, modify, build extensions)
Each session is designed to be completed in 30-60 minutes of focused learning. The progressive structure means you can stop at any point with a working agent—you don't need all 12 to build something useful.