Chapter 1: Understanding Multi-Agent Systems
Introduces agents that reason, act, communicate, and adapt. Defines multi-agent systems for complex tasks requiring planning, diverse expertise, and adaptive solutions. Build your first poet-critic collaboration using round-robin orchestration.
Chapter 2: Multi-Agent Patterns
Covers a taxonomy of orchestration patterns from explicit to emergent control. Deterministic workflows (sequential, parallel, supervisor) offer predictable control. Autonomous patterns (plan-based, handoff, conversation-driven) provide flexibility with trade-offs.
Chapter 3: UX Principles for Multi-Agent Systems
Covers four useful design principles AI agent interfaces should support: capability discovery, cost-aware action delegation, observability and provenance, and interruptibility.
Chapter 4: Building Your First Agent (From Scratch
Implement the core agent loop with async architecture, streaming, and cancellation. Add model clients, structured output, tool calling, memory (RAG, agentic memory), middleware, telemetry and human input.
Chapter 5: Building Computer Use Agents
Extend your agent with the ability to accomplish tasks by driving Playwright browser instance. Learn about concepts such as action generation, interface representation (DOM/visual/hybrid), and execution.
Chapter 6: Building Multi-Agent Workflows
Implement workflows - computational graphs with nodes as computation units and edges as control flow. Type-safe steps with Pydantic, conditional edges, dependency resolution, concurrent execution, and automatic checkpointing.
Chapter 7: Building Autonomous Multi-Agent Orchestration
Implement autonomous orchestration loops across multiple agents: select agent, execute turn, check termination, repeat. Implement composable termination conditions and common GroupChat patterns (round-robin, AI turn selection) and planning patterns like Magentic One.
Chapter 8: Building Modern Web Experiences
Learn to integrate your agents into web interfaces built from scratch that support long-running agent tasks with real-time progress. Start out with a vanilla html + js app with pointers on how to extend to React. Learn about important SSE vs Websocket transport tradeoffs.
Chapter 9: Multi-Agent Frameworks
Learn about 10 important criteria for evaluating any frameworks (e.g., LangChain, AutoGen, CrewAI etc), when to build from scratch vs leverage existing frameworks.
Chapter 10: Evaluating Multi-Agent Systems
Learn to represent any agentic application results as trajectories, learn to build metrics and judges, and build evaluation harnesses that provide critical signal on the performance of your applications.
Chapter 11: Optimizing Multi-Agent Systems
Ten common failure modes with optimization strategies. Making small models effective through optimization techniques.
Chapter 12: Protocols for Distributed Agents
Discusses the concept of distributed agents - distributed agent architectures where components run across separate execution contexts—different machines, regions, or organizations—communicating over networks. Discusses how MCP and A2A protocol enable distributed agents.
Chapter 13: Ethics and Responsible AI
Examines how agentic AI ethics fundamentally differs from traditional AI ethics across four dimensions: controllability, action capability, domain scope, and verification. Reflects on the concept of agentic noise, distributed responsibility challenges, emergent risks from agent interactions (alignment faking, autonomous harmful behaviors), and security as ethical imperative when agents can act.
Chapter 14: Answering Business Questions from Unstructured Data
Implement a workflow to analyze thousands of YCombinator companies to identify AI agent use cases. Four-stage workflow: data loading, pre-filtering, structured LLM analysis, insight generation. Two-stage filtering, checkpointing, cost monitoring.
Chapter 15: Software Engineering Agent
Implement the foundational pattern used by modern AI coding assistants like GitHub Copilot, Cursor, and Claude Code: agent capability emerges from tools + prompts + memory. It demonstrates building a software engineering agent that can autonomously write code, run tests, and iteratively improve solutions.