What you will learn in Designing AI Agents
Principles, patterns, and best practices
Chapter by chapter
Chapter 1: The agent paradigm shift
The chapter introduction uses a coding-agent failure to explain why model-directed decisions require agent design patterns, while connecting those patterns to established engineering practice.
What you learn in chapter 1 →Chapter 2: Turn a task into an agent architecture
The introduction frames agent architecture as a set of choices driven by a business task and its constraints, rather than by a preferred pattern.
What you learn in chapter 2 →Chapter 3: Perception: What your agent sees determines what it does
The chapter introduction shows why an agent can fail despite having the right evidence: perception depends on how useful information is selected and presented, not merely on how much context is supplied.
What you learn in chapter 3 →Chapter 4: Memory: What your agent remembers shapes what it becomes
The introduction defines agent memory as a policy for carrying information across boundaries, using a decision ledger to show why stored history must be separated from current authority.
What you learn in chapter 4 →Chapter 5: Reasoning: How your agent decides what to do next
This introduction defines reasoning as producing an inspectable decision from clearly represented state and evidence, then frames how to choose an appropriate reasoning approach.
What you learn in chapter 5 →Chapter 6: Action: How your agent acts is where strategy meets consequences
The introduction shows why a state-changing agent action must be judged by its bounded, verified real-world effect rather than by a successful tool response.
What you learn in chapter 6 →Chapter 7: Reflection and evaluation: How your agent audits and learns from itself
The chapter introduction shows why useful fixes to individual agent failures need evaluation across runs to determine whether the system is improving.
What you learn in chapter 7 →Chapter 8: Collaboration: When one agent is not enough
This introduction explains why collaboration helps when work can be divided, but adds costs that a single agent may avoid.
What you learn in chapter 8 →Chapter 9: Governance: Constraints that enable freedom
The introduction explains why agents with consequential capabilities need governance and how clear boundaries can make delegation possible.
What you learn in chapter 9 →Chapter 10: Composing patterns: From map to terrain
Introduces pattern composition through an identifier handoff failure and the need to preserve continuity across consequential interfaces.
What you learn in chapter 10 →Chapter 11: Patterns in the wild: Three end-to-end case studies
The introduction illustrates evidence-driven architecture changes and the need for exact rules at agent system boundaries.
What you learn in chapter 11 →Concepts explained in this book
- perceptionAn agent capability for identifying relevant information from inputs and loading context for subsequent processing.
- agent skillA packaged agent capability that specifies how to perform a class of tasks, including relevant tools and workflow guidance.
- governanceThe agent capability and control framework for enforcing policies, constraints, oversight, and accountability.
- approval gateA control point that determines whether an operation may proceed autonomously or requires human authorization.
- execution topologyA structural arrangement that determines how steps or agents are organized and executed in an agent system.
- cognitive functionA recurring responsibility in an agent architecture, such as perception, memory, reasoning, or action.
- reflectionAn agent capability for inspecting and revising its own intermediate results or proposed actions.
- damage limitationA control that limits the scope or potential impact of an agent's harmful or erroneous actions.
- context triageAn agent pattern that prioritizes relevant context and avoids loading irrelevant material to reduce unnecessary processing cycles.
- observability harnessA system that records and exposes execution traces for monitoring, diagnosis, and audit.
- progressive commitmentAn agent pattern in which reversible evidence precedes consequential action and autonomy changes according to observed outcomes.
- progressive discoveryProgressive discovery is a technique in which an agent incrementally obtains relevant information while navigating an unfamiliar information environment.
- reasoningAn agent capability for evaluating information, forming hypotheses, and selecting conclusions or actions.
- cognitive moduleA separable agent subsystem responsible for a cognitive function such as perception, memory, reasoning, action, reflection, or collaboration.
- agent systemA software system in which an AI model perceives context, reasons, and acts through available capabilities.
- decision recordAn inspectable record of a decision or conclusion and its supporting evidence, assumptions, and rationale.
- dispatchingThe assignment of a request or unit of work to a processing path or handler based on its properties.
- actionAn agent capability for executing external operations or producing artifacts in response to reasoning.
- collaborationAn agent capability for coordinating information or activity with other agents or humans.
- generator-critic loopA pattern in which a generator produces a candidate result and a critic evaluates it to guide revision or delivery.
- autonomy-level classificationThe degree to which an agent can make decisions and take actions without human intervention or authorization.
- ReActReAct is an agent technique that interleaves language-model reasoning with actions to interact with an environment.
- fail-diagnose-fix-verify loopA process for recovering from a failure by capturing its context, diagnosing a cause, proposing and applying a repair, verifying the result, and deciding what to do next.
- agent design patternA reusable architectural solution for building systems in which an AI model makes decisions at runtime.
- prompt chainA workflow pattern that divides a known sequence into narrow stages, with each stage producing an artifact that passes a gate before the next stage proceeds.
- agent harnessA software layer around an agent that manages execution, resources, tools, delegation, context, and verification.
- subagentAn agent assigned a bounded portion of a larger task or delegated plan.
- admissionTool admission is a check that a proposed tool operation remains authorized and appropriate given current authority, provenance, and state freshness.
- trajectoryA record of events and operations during a system run, arranged to show its progression and support diagnosis.
- evaluationEvaluation is the systematic assessment of a result against criteria for quality, correctness, or suitability.
- guardrail sandwichAn execution pattern that places a state-changing action between trusted pre-check and post-check controls, with a controlled executor in between.
- plan-and-executeAn agent pattern in which planning precedes execution of the planned steps.
- evidenceInformation that supports or substantiates a claim or decision.
- memoryAn agent capability for retaining or retrieving information across or within tasks.
- authorizationAuthorization is a decision about whether a proposed operation is permitted under applicable policy and delegated objectives.
- agent architectureThe design of an agent system's model, control, constraints, resources, and execution mechanisms.
- complexity-based routingA routing pattern that selects an agent's reasoning policy and resource path according to request properties such as difficulty and consequence.
- harness engineeringThe practice of engineering constraints and supporting mechanisms around an AI agent to prevent recurring mistakes and govern its work.
- evaluation receiptAn evaluation receipt is a record of a model's training and generator versions, held-out workload, evaluation results, and release decision.
- agentAn autonomous software system that performs tasks by perceiving information, reasoning, and taking actions.
- fan-out/gatherA coordination pattern that distributes work across multiple agents or workers and then aggregates their results.
- progressive disclosureProgressive disclosure is a technique that reveals detailed information or capabilities only when they become relevant to the current task.
- adversarial thinkingAn adversarial review is a review approach that examines work from a challenging or opposing perspective.
- verificationThe process of checking whether a system or result satisfies specified requirements or properties.
- checkpointingThe practice of recording execution state at checkpoints so a workflow can resume after interruption.
- control planeA control plane is the part of a system that governs its operation by managing authoritative decisions, policies, or configuration.
- tool registryA collection of tools available to an agent, together with information needed to identify or invoke them.
- iterative hypothesis testingAn evaluation pattern in which successive passes propose hypotheses and test them against evidence.
- experience replayA pattern that uses past execution trajectories and relevant parts of their history to guide later work.
- evidence coverageThe extent to which decisive claims in a result are linked to the evidence required to support them.
- hierarchical coordinationA collaboration pattern that delegates bounded portions of work to agents arranged hierarchically.
- evidence classAn evidence class is a category describing the kind of evidence available for assessing an architectural claim.
- tool contractA description of a tool's execution requirements, including checks and information needed by its runner.
- source of truthA source of truth is the authoritative source for a particular piece of information.
- instruction hierarchyA layered arrangement of instructions in which levels determine their priority and the context loaded for an agent session.
- context isolationContext isolation is a technique that gives a task-specific agent a separate context containing only information relevant to its assigned task.
- commit identityAn identifier assigned by a runtime to recognize repeated requests for the same state-changing business operation.
- trustThe confidence an organization grants an agent to act within defined limits, informed by its observed outcomes.
- recoveryThe process of restoring a system or its operation after a failure or interruption.
- agent loopAn iterative agent-control pattern in which an agent perceives, reasons, acts, and reflects, with subsequent steps selected dynamically.
- progress trackingA persistence pattern that records task state and completed work so an interrupted agent can resume execution.
- accountabilityThe ability to connect an outcome and the decisions that produced it to responsible agents and people.
- least agencyA principle of granting an agent only the autonomy needed to perform its delegated task.
- uncertaintyUncertainty is the lack of complete predictability about a system's state, behavior, or outcome.
- contractAn agreement specifying conditions that a task, state, authority, or evidence must satisfy.
- token leverageThe ratio of agent output quality to the token cost required to produce it.
- Pattern Selection CardA book-specific aid for choosing among recurring agent execution topologies.
- compound errorA compound error is an overall failure produced when errors in successive agent roles or processing stages accumulate or cascade.
- context windowThe bounded sequence of tokens that a language model can attend to during an interaction.
- multi-agent systemA software system in which multiple agents coordinate or work independently to perform tasks.
- auto memoryClaude Code's agent-authored memory facility, which loads selected indexed content at session start and makes detailed topic files available for retrieval.
- verifierA verifier is a component that checks whether an answer or result satisfies relevant criteria.
- working memoryThe limited information temporarily available to an agent or model while it performs a task.
- sandboxingA sandbox is an isolated execution environment that restricts a system's access to resources and external effects.
- specificationA formal or informal description of required behavior, constraints, and objectives for a system.
- specification-driven developmentA software-development approach in which structured specifications guide implementation and define intended behavior.
- metacognitionMeta-cognition is the ability of an agent to evaluate and improve its own cognitive activities or outputs.
- isolationIsolation is a technique for containing the effects of a failure or operation so they do not propagate across system boundaries.
- chain-of-thoughtA reasoning technique that represents a decision as a sequence of intermediate steps or claims.
- retrieval-augmented generationA technique that retrieves relevant information from an external corpus and supplies it to a language model to inform generation.
- progressive trust levelA level of confidence in an agent that determines how much routine approval work may be removed.
- perception pipelineA sequence of perception stages that acquires, combines, prioritizes, and compresses information into context for an agent.
- re-read ratioA metric measuring how often an agent retrieves the same file or information more than once during a task.
- memory hierarchyAn organized set of memory stores with different capacities, persistence, and access costs.
- memory bank methodologyA structured practice of maintaining project context in a collection of persistent Markdown files for agent sessions.
- ArgusArgus is the code review agent built as the book's progressively developed reference system.
- LLM-as-a-judgeModel-based judging is the assessment of outputs using a model as the judge.
- progressive trustA governance approach in which an agent receives increasing autonomy as it demonstrates reliable behavior.
- validationValidation is the process of assessing whether a candidate lesson is suitable to influence a later task.
- semantic routingA routing mechanism that selects a processing path based on the meaning of a request.
- attention zone coverageA metric measuring whether critical information is positioned in regions of the context window that receive strong model attention.
- MCP hostAn MCP host is an agent runtime component that connects an agent to Model Context Protocol capabilities and manages their use.
- semantic memorySemantic memory is persistent memory for general facts, concepts, and their relationships rather than specific events.
- skill libraryA collection of Skills maintained for selection and reuse by an agent system.
- heuristicA practical rule or strategy for proposing a solution without guaranteeing an optimal result.
- human-in-the-loopAn approach in which a person intervenes in an automated process by supplying information, editing output, or judging a result.
- process supervisionProcess supervision evaluates intermediate steps in a problem-solving process rather than assessing only its final answer.
- cognitive axisA dimension of the book's design framework that organizes agent cognitive functions.
- agentic RAGRetrieval-augmented generation in which an agent can make decisions about whether and how to retrieve information.
- authorization decisionThe recorded outcome of applying a policy to an agent action.
- reasoning depthReasoning depth is the amount of deliberate analysis and computational effort an agent allocates to a problem before acting or responding.
- planningAn agent capability for decomposing goals and selecting an intended sequence of steps toward achieving them.
- iteration limitA loop limit is the maximum number of iterations permitted in a loop.
- hypothesis testingAn analytical technique that evaluates candidate explanations or predictions against evidence or observations.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
