Start Here

This book has one goal: get you from “I can call an LLM API” to “I have shipped an agent that real people use and I can keep it running.”

It is deliberately build-first. There is no chapter where you only read. Every part ends with something you have made and run, and the parts stack — the tool framework you write in Part 2 gets used by the workflow engine in Part 4, which gets evaluated by the harness in Part 5, which becomes the quality gate in your CI pipeline in Part 6, which ships the research agent in Part 7. By the end you are not looking at nine disconnected tutorials, you are looking at one system you assembled.

What you will have built

Nine mini-projects and three production systems.

The mini-projects are the machinery: a ReAct agent written from scratch with no framework, your own @tool decorator and function-calling framework, an MCP client harness, a memory system with extraction and consolidation, a workflow engine with routing and parallelism, a multi-agent orchestrator, an evaluation harness with a regression gate, full OpenTelemetry tracing, and a containerized deployment.

The production systems are the payoff: a deep research agent that crawls and ingests heterogeneous sources with citation integrity, a deterministic writing workflow built on an evaluator-optimizer loop, and a capstone MCP server of your own design, deployed.

What you need

Python 3.10 or newer, and comfort reading it. You do not need prior agent experience — Part 1 assumes none.

You do not strictly need API keys. Every build chapter has an offline or mock mode so the code runs and the tests pass without credentials, because a book you cannot execute is a book you will not finish. Having a key from any major provider makes the experience better but is never required to proceed.

How to read it

Read a chapter, then run its code before moving on. This sounds obvious and almost nobody does it. The understanding in this material lives in the debugging, not the prose — the moment your version fails differently from mine is the moment you actually learn how the thing works.

The build chapters are written as build-alongs. They start with the simplest version that works, then break it on purpose, then fix it. Resist the urge to skip to the final listing. The intermediate failures are the curriculum.

If you are short on time, the highest-value path is Part 1 chapter 4 (build the loop by hand), Part 2 chapter 1 (tool design, which is where most agents silently fail), Part 3 chapter 1 (context engineering), Part 5 chapter 3 (the eval harness), and Part 6 chapter 4 (security). Those five give you the load-bearing ideas. But the book is better whole.

Where this sits among the other guides

This book is about building and shipping agents. Three sibling repositories go deeper on adjacent ground, and this book cross-references them rather than duplicating:

Agentic AI Evaluation — twelve chapters on evaluating agents, a 21-pattern design-patterns playbook, and a long-horizon operations track covering what breaks when agents run for thirty-plus turns. When Part 5 says “the sibling guide goes deeper here”, that is where it points.

LLM Serving & Inference — the layer beneath: vLLM, Kubernetes GPU scheduling, autoscaling, canary deployment, monitoring, Triton. Part 6 stays at the application layer and points here for infrastructure.

ML & LLM Learning — the fundamentals underneath everything: transformers, attention, inference mechanics, training.

About the sources

The conceptual backbone comes from the Google 5-Day Agents Intensive whitepapers (May 2026 revision), which sit in resources/, and the project arc follows the Towards AI Agent Engineering course curriculum. Those set the syllabus. The explanation, the code, and the failures are written fresh for this book, and every code listing here was executed before it was published — when you see terminal output in a chapter, that is real output from a real run, not an illustration of what output might look like.

Where the sources have been overtaken by events, the book says so. The Model Context Protocol in particular changed substantially in its 2026-07-28 revision, and Part 2 teaches the current stateless protocol rather than the superseded session model.