AI Agent Handbook

Explains the core idea of an AI agent in clear terms, describing it as a program powered by AI that can perceive instructions, decide on actions, and produce results autonomously.

Presents a friendly 'personal assistant' example that will grow throughout the book, giving readers a motivating overview of what this assistant will eventually be able to do.

Introduces language models as the foundation of AI agents, explaining how they power every agent's ability to understand language and generate responses.

Describes the basics of large language models in an accessible way, covering how models are trained to predict text and explaining concepts like vocabulary and next word prediction.

Walks through a simple, runnable Python snippet that calls a language model to generate text, showing the practical side of connecting to a model.

Introduces the fundamental skill of communicating with AI agents through prompts, explaining why clear instructions matter and how to guide model responses effectively.

Teaches the basics of writing good prompts, emphasizing using plain, direct language and giving the AI enough detail about what you want.

Introduces practical strategies for more effective prompting, including guiding the AI with roles or context and few-shot prompting techniques.

Shows how to get the AI agent to reason through problems step by step using chain-of-thought prompting and other simple techniques to significantly improve the agent's ability to handle complex questions.

Introduces chain-of-thought reasoning, showing how we can prompt the model to think in steps and break down complex questions.

Explains how an agent can be guided to check its own work or refine its answers, leading to more accurate and trustworthy outcomes.

Uses everyday scenarios to illustrate the limitations of a stand-alone AI model and why tools are helpful for getting up-to-date information or performing precise calculations.

Explains how we can connect tools to the agent in practice, describing a basic framework where the agent decides when to use a tool and how to invoke it.

Provides a concrete walk-through of extending the personal assistant with a calculator capability, showing how tools can be integrated step by step.

Describes how the agent keeps track of recent dialogue or actions, discussing methods like storing the last N messages or summarizing the conversation.

Introduces the concept of long-term memory for the agent, explaining how it might use a database or vector store to remember facts and retrieve information when needed.

Walks through how we can add memory to the personal assistant in code, showing how conversation history and long-term facts can be stored and retrieved.

Defines what state means in the context of an AI agent, including the current user goal, conversation history, intermediate results, and available tools.

Describes how all the pieces come together in a structured way, introducing a basic architecture that ties together input, state updates, tool use, reasoning, and output.

Explains how the agent maintains continuity over multiple turns or tasks, ensuring the agent's state remains consistent and is cleared or updated appropriately.

Explains in intuitive terms what an environment means for an AI agent, contrasting different kinds of environments from chatbots to physical robots.

Discusses how the agent perceives its environment and how it takes actions, reinforcing the idea that the environment is interactive and changes based on the agent's actions.

Highlights the importance of defining what the agent can and cannot do in its world, introducing the idea of constraints for safety and practicality.

Introduces task decomposition, explaining that when given a big goal, an agent should first split it into smaller, manageable pieces.

Describes how the agent uses the plan it made to actually do the work step by step, discussing sequential execution and handling failures gracefully.

Gives a concrete walkthrough of the personal assistant doing a planned task, showing how planning enables the agent to handle complex, multi-step tasks reliably.

Describes what it means for AI agents to cooperate, presenting simple collaborative scenarios where agents work together to achieve goals more effectively.

Explains how multiple agents might talk to each other and coordinate their actions, introducing the idea of messages and common protocols for agent communication.

Discusses why one might use multiple agents and what difficulties can arise, covering specialization, parallelism, robustness, and the need for careful design.

Teaches how to define what a 'successful' outcome looks like for an agent, encouraging clear, measurable goals like accuracy, task completion rate, or user satisfaction.

Covers creating and using test cases to evaluate the agent, showing how to build scenario tests and track performance over time.

Emphasizes that evaluation is an ongoing process, introducing the concept of a feedback loop: build → test → learn → improve.

Shows how to instrument the agent with logging at key points, providing a snippet of code illustrating how to add logging to track the agent's decisions.

Teaches how to interpret logs and use them to find problems, outlining a straightforward debugging approach for tracing the agent's line of thought.

Shows that observability isn't only for finding bugs but also for continuously refining the agent, discovering patterns and making improvements based on observations.

Focuses on keeping the agent's outputs safe and benign, describing strategies like filtering responses and training the agent to politely refuse inappropriate requests.

Deals with controlling what the agent is allowed to do, especially when tools and environment come into play, emphasizing the importance of constraints and sandboxing.

Broadens the discussion to governance, explaining how to set ethical guidelines and incorporate human oversight, especially for high-stakes deployments.

Explains the steps to deploy the agent, outlining what deployment means: packaging the code, choosing where it runs, and how users will interact with it.

Emphasizes the importance of keeping the agent running and trustworthy, discussing health checks, error handling, and scaling to handle more load.

Discusses what happens after deployment, giving tips on how to safely update the agent and maintain it over time, including monitoring costs and optimizing the system.

Covers techniques to make the agent respond faster, including using smaller models, limiting response length, and parallelizing operations.

Focuses on the cost aspect, providing tips on batching requests, using caching, and choosing the most cost-effective approach for each part of the agent's workload.

Talks about maintaining performance and cost-efficiency as usage grows, discussing horizontal scaling, cost control, and optimizing prompts and responses.