Book Roadmap and Projects

Introduction

This book is designed as a practical journey from understanding what agents are to building production-ready systems. Here's what you'll learn and build along the way.

Our Philosophy: Learn by building. Every concept is paired with working code. By the end, you'll have built complete agent systems, not just read about them.

Your Learning Path

The book is organized into 8 parts, progressing from fundamentals to production deployment:

Part-by-Part Breakdown

Part I: Foundations (Chapters 0-2)

Build your understanding of what agents are and how they work.

• Chapter 0: Prerequisites and environment setup
• Chapter 1: The agentic AI revolution (you are here!)
• Chapter 2: Agent architecture fundamentals

What you'll build: A minimal agent with basic loop, tools, and LLM integration.

Part II: How Top Agents Work (Chapters 3-5)

Deep dive into production agents from leading AI labs.

• Chapter 3: How Claude Code works
• Chapter 4: How OpenAI Codex works
• Chapter 5: How Gemini agents work

What you'll learn: The patterns, decisions, and trade-offs that power the best agents.

Part III: Building Core Systems (Chapters 6-9)

Implement the fundamental components every agent needs.

• Chapter 6: Tool design and implementation
• Chapter 7: Memory systems (short-term, long-term, RAG)
• Chapter 8: Planning and reasoning
• Chapter 9: Prompt engineering for agents

What you'll build: Reusable tool library, vector-based memory system, planning engine.

Part IV: Agent Frameworks (Chapters 10-12)

Master the major frameworks for building agents.

• Chapter 10: LangGraph - graph-based orchestration
• Chapter 11: CrewAI - multi-agent teams
• Chapter 12: Claude Agent SDK - Anthropic-native agents

What you'll build: Agents using each framework, understanding when to use which.

Part V: Advanced Patterns (Chapters 13-16)

Tackle complex agent architectures.

• Chapter 13: Multi-agent systems
• Chapter 14: MCP (Model Context Protocol)
• Chapter 15: Human-in-the-loop patterns
• Chapter 16: Agentic RAG

What you'll build: Multi-agent research team, MCP server and client, approval workflows.

Part VI: Production (Chapters 17-21)

Take agents from prototype to production.

• Chapter 17: Safety and guardrails
• Chapter 18: Sandboxing and isolation
• Chapter 19: Observability and debugging
• Chapter 20: Evaluation and benchmarking
• Chapter 21: Deployment strategies

What you'll build: Production-ready safety layer, monitoring dashboard, evaluation suite.

Part VII: Domain Applications (Chapters 22-24)

Build specialized agents for specific domains.

• Chapter 22: Coding agents
• Chapter 23: Research agents
• Chapter 24: Data analysis agents

What you'll build: Domain-specific agents with specialized tool sets.

Part VIII: Capstone Projects (Chapters 25-28)

Bring everything together with complete agent systems.

Capstone Projects

Project 1: Code Review Agent (Chapter 25)

Build a complete code review agent that:

• Analyzes pull requests automatically
• Identifies bugs, security issues, and code smells
• Suggests improvements with explanations
• Integrates with GitHub/GitLab

1# Preview: Code Review Agent
2class CodeReviewAgent:
3    async def review_pull_request(self, pr_url: str) -> ReviewResult:
4        # Fetch PR details
5        pr = await self.github.get_pull_request(pr_url)
6
7        # Analyze each changed file
8        issues = []
9        for file in pr.changed_files:
10            file_issues = await self.analyze_file(file)
11            issues.extend(file_issues)
12
13        # Generate summary
14        summary = await self.generate_summary(pr, issues)
15
16        # Post review
17        await self.github.post_review(pr, summary, issues)
18
19        return ReviewResult(pr=pr, issues=issues, summary=summary)

Project 2: Research Assistant (Chapter 26)

Build a multi-agent research system that:

• Searches web and academic sources
• Extracts and synthesizes information
• Generates structured reports with citations
• Answers follow-up questions

Project 3: Data Pipeline Agent (Chapter 27)

Build a data analysis agent that:

• Connects to databases and APIs
• Generates and executes SQL queries
• Creates visualizations and reports
• Answers natural language questions about data

Project 4: Personal Assistant (Chapter 28)

Build a comprehensive personal assistant that:

• Manages calendar and email
• Automates repetitive tasks
• Learns from user preferences
• Integrates with productivity tools

How to Use This Book

For Beginners

1. Start with Part I to build foundational understanding
2. Work through Part II to learn from production agents
3. Complete Part III hands-on exercises
4. Pick one framework from Part IV to master first
5. Tackle capstone projects as you gain confidence

For Experienced Developers

1. Skim Part I for gaps in your knowledge
2. Deep dive into Part II for architecture insights
3. Focus on Part V for advanced patterns
4. Prioritize Part VI for production considerations
5. Use capstones as reference implementations

For Teams

• Use Part VI as a production checklist
• Adapt capstone projects to your domain
• Build internal tools using patterns from this book

Summary

Your journey through this book will take you from understanding what agents are to building complete, production-ready systems:

1. Foundations: Core concepts and architecture
2. Learning from the Best: How top agents work
3. Building Blocks: Tools, memory, planning
4. Frameworks: LangGraph, CrewAI, Claude SDK
5. Advanced Patterns: Multi-agent, MCP, human-in-the-loop
6. Production: Safety, observability, deployment
7. Applications: Domain-specific agents
8. Capstones: Complete agent systems

Let's Begin: You now have the roadmap. In the next chapter, we'll dive deep into agent architecture fundamentals - the core patterns that power every agent system.