The first wave of AI agent literature was organized by domain. It offered vertical recipes: how to build a healthcare agent, a finance agent, or a coding agent, as if each field were a separate discipline. That approach served the field well in its infancy, but it has become misleading. When you strip away the prompts and toolkits, a healthcare agent and a coding agent are running the same five or six architectural patterns. The surface variation is cosmetic; the underlying substance is capability.
This book reorganizes agent engineering around those very capabilities. There are eight that matter: perception, reasoning, planning, memory, tool use, coordination, learning, and alignment. Every working agent—from the cron-job-with-a-prompt that summarizes your inbox to the multi-agent system that drafts merger documents—is a composition of these eight, in different ratios and at different fidelities.
If you understand the patterns inside each capability, you can build any agent on demand. But if you know only the domain templates, you will spend your career rediscovering the same architectures with slightly different prompts. As we move into 2026, with agent ecosystems maturing and enterprise adoption accelerating, this capability-led approach is not just a conceptual refinement—it is a practical necessity.
The number sixty in the subtitle is not a marketing flourish. It is the number of distinct, named patterns this book defines. Some are well-known under other names; many are formalized here for the first time. Each pattern is presented with eight components: a one-line tagline; the technical problem it solves—what specifically goes wrong without it; why the pattern works, with reference to underlying mechanisms; detailed code examples in Python; failure modes and how to identify them; design trade-offs and when not to use the pattern; an illustrative composite case study; and a set of variants or extensions.
This structure is deliberate: it makes each pattern self-contained, so you can use the book as a reference, reading only the chapters or patterns relevant to your current challenge. It also means that the patterns themselves form a coherent whole, building from the simplest building blocks to complex multi-agent systems.
Who This Book Is For
This guide is written for software engineers who are building agents in production, technical architects who need to make principled trade-offs, and team leads who want a shared vocabulary for agent design. It assumes you have a working knowledge of Python and a basic familiarity with large language models. It does not assume you have built an agent before.
If you are a domain expert—in healthcare, finance, or another field—you will find the patterns transferable. If you are a machine learning researcher, you will find the book provides a useful bridge between research prototypes and engineering practice. And if you are a product manager or technical leader, the book offers the language to specify agent systems precisely and to evaluate architectural proposals.
How to Read This Book
The eight capabilities are introduced in the order that mirrors how a typical agent is architected: perception grounds the agent in its environment; reasoning and planning give it deliberative power; memory provides continuity; tool use extends its reach into the world; coordination enables multi-agent systems; learning allows improvement over time; and alignment ensures the agent acts safely and in accordance with user intent.
Each capability is covered in one or two chapters, and within each chapter the patterns are arranged from simple to complex. You can read the book cover-to-cover to build a complete mental model, or you can jump directly to the pattern that matches the problem you are solving today. Cross-references throughout the book connect related patterns and help you navigate between capabilities.
The Landscape in 2026
If you are reading this in 2026, you are likely aware that AI agents have moved from experimental prototypes to production infrastructure at scale. The past few years have seen dramatic improvements in base model capabilities, inference efficiency, and tool ecosystems. Yet the core architectural challenges remain remarkably stable: grounding outputs in reality, managing state, coordinating multiple actors, and ensuring safety. This book focuses on those durable challenges.
What has changed is the context in which agents are built. There are now mature frameworks that implement many of these patterns for you, and there is a growing ecosystem of specialized tools and services. However, no framework removes the need for architectural understanding. In fact, as abstraction layers thicken, it becomes more important to know what is happening underneath—both to debug effectively and to choose the right framework for the job. This book gives you that foundation.
Summary of Patterns
The following list previews the sixty patterns, organized by capability. This is both a reading guide and a quick reference. Each pattern name links to its full treatment in the corresponding chapter.
Perception
- Pattern 1: Structured Input Extraction
- Pattern 2: Schema-Constrained Generation
- Pattern 3: Multi-Modal Sensing
- Pattern 4: Grounded Observation
- Pattern 5: Noise-Resilient Encoding
- Pattern 6: Temporal Aggregation
Reasoning
- Pattern 7: Chain-of-Thought Deliberation
- Pattern 8: Self-Consistency Sampling
- Pattern 9: Dual-Pass Verification
- Pattern 10: Decomposition for Complex Inference
- Pattern 11: Analogical Reasoning
- Pattern 12: Probabilistic Inference
Planning
- Pattern 13: Hierarchical Task Networks
- Pattern 14: Means-Ends Analysis
- Pattern 15: Progressive Refinement
- Pattern 16: Contingency Planning
- Pattern 17: Receding-Horizon Control
- Pattern 18: Market-Based Planning
Memory
- Pattern 19: Episodic Buffering
- Pattern 20: Working Memory Slots
- Pattern 21: Long-Term Semantic Store
- Pattern 22: Procedural Memory Indexing
- Pattern 23: Forgetting and Consolidation
- Pattern 24: Cross-Session Anchoring
Tool Use
- Pattern 25: Tool Registry Protocol
- Pattern 26: Capability Discovery
- Pattern 27: Semantic Tool Matching
- Pattern 28: Streaming Execution
- Pattern 29: Tool Result Reconciliation
- Pattern 30: Compensating Actions
Coordination
- Pattern 31: Blackboard Architecture
- Pattern 32: Contract-Net Protocol
- Pattern 33: Stigmergic Coordination
- Pattern 34: Role-Based Orchestration
- Pattern 35: Split-Brain Avoidance
- Pattern 36: Consensus and Quorum
- Pattern 37: Plan Synchronization
Learning
- Pattern 38: In-Context Adaptation
- Pattern 39: Reflection and Correction
- Pattern 40: Preference Optimization
- Pattern 41: Reward-Model Distillation
- Pattern 42: Experience Replay
- Pattern 43: Task Curriculum
- Pattern 44: Meta-Learning for Few-Shot
Alignment
- Pattern 45: Constraint Propagation
- Pattern 46: Value Anchoring
- Pattern 47: Safety Interlock
- Pattern 48: Human-in-the-Loop Escalation
- Pattern 49: Audit Trail Generation
- Pattern 50: Irreversibility Detection
- Pattern 51: Normative Interference
- Pattern 52: Privacy-Preserving Operation
- Pattern 53: Adversarial Robustness
- Pattern 54: Benevolent Deception
Composite Patterns
- Pattern 55: ReAct Loop (Reason+Act)
- Pattern 56: Reflexion with Memory
- Pattern 57: Plan-and-Execute
- Pattern 58: Multi-Agent Debate
- Pattern 59: Recursive Self-Improvement
- Pattern 60: Autonomous Design Loop
Final Thoughts
Building AI agents is still hard. The material in this book does not promise to make it easy, but it will make it tractable. The patterns here are the result of years of collective engineering experience, distilled into a form that you can apply directly. Work through them systematically, and you will have the tools to architect agents that are reliable, maintainable, and aligned with what you intend them to do.
This book is a living document in spirit: the field will evolve, and new patterns will emerge. But the fundamental capabilities will remain, and the patterns that realize them will provide a stable foundation. Use this guide to build well, and to build with confidence.
— Vahe Aslanyan
via FreeCodeCamp