Choose an architecture
Compare model calls, chains, workflows, agent loops, and multi-agent systems before adding autonomy.
Open guideOnline-first field guide
Agentic Systems Patterns
A practical book for designing, evaluating, and operating agentic systems: goals, loops, tools, skills, memory, protocols, multi-agent topologies, and production runtimes.
102 chapters
15 sections
Static searchable site
Reader contract
Every chapter should change an engineering decision.
The book is built for software engineers who need boundaries, contracts, evals, traces, checklists, labs, and production gates they can use at work.
Read the contract- Decision you can defend
- Boundary you can draw
- Failure mode you can test
- Artifact your team can reuse
Courtesy formats
Read on GitHub Pages first.
The online reader is the primary edition. PDF and EPUB are provided as convenience copies for offline reading and annotation.
Use the book
Start from the engineering decision
Use the book as a progression from orientation to implementation evidence. Start with the reader path, choose a pattern, build a small slice, verify the runtime, then use the release chapters to publish or operate the result.
sequenceDiagram
participant Reader
participant Paths as Reader paths
participant Patterns
participant Labs
participant Gates as Production gates
Reader->>Paths: Choose role and goal
Paths->>Patterns: Select architecture
Patterns->>Labs: Run focused slice
Labs->>Gates: Verify traces, evals, rollback
Gates-->>Reader: Publish or operate with evidence
Read visually
Use the diagram route to understand boundaries, ownership, runtime control, coordination, and production safeguards.
Open guideRun a focused lab
Use small TypeScript and Python examples to inspect tools, state, retrieval, evals, protocols, and framework slices.
Open guideReview for production
Check state, policy, tools, memory, traces, evals, approvals, rollback, and release evidence before shipping.
Open guideHigh-value chapters
Start with these decisions
Choosing the Right Pattern
Choosing the Right Pattern helps you select the least agentic architecture that can meet the workload with acceptable quality, cost, latency, and risk.
Read chapterAgent Loop
The agent loop turns a model call into an agent: observe state, decide the next action, act, evaluate the result, and stop when the goal is complete or a limit is reached.
Read chapterTool Use
Tool use gives an agent controlled access to external capability such as calculators, search, databases, files, code execution, APIs, or business systems.
Read chapterSemantic Recall and RAG
Semantic recall retrieves relevant material by meaning rather than exact keywords. RAG injects retrieved material into context before generation.
Read chapterTask Delegation
Task delegation assigns bounded subtasks to specialized workers and combines their outputs.
Read chapterObservability and Evals
Observability records what happened. Evals decide whether behavior is good enough. Release gates decide whether a change is allowed to ship.
Read chapterReading paths
Browse the book
Start Here
Orientation chapters that define the book, the reader paths, and the basic agent model.
Open sectionPattern Selection and Composition
Decision guides for choosing, scoring, composing, routing, budgeting, and hardening patterns before implementation.
Open sectionAgent Runtime Foundations
Runtime primitives every agentic system depends on: single agents, loops, state, tools, and structured outputs.
Open sectionEngineering Practice and Frameworks
Engineering workflow, harnesses, runtime primitives, framework choices, setup notes, and worksheets.
Open sectionEvaluation, Security, and Trust
Evaluation, threat modeling, sandboxing, policy trust, and UX controls for systems that affect users.
Open sectionControl Loops
Planning, reflection, evaluator-optimizer, and self-healing control patterns.
Open sectionContext, Memory, and Knowledge
Context assembly, working sets, durable memory, semantic recall, RAG, and knowledge-bound behavior.
Open sectionTools, Skills, and Protocols
Tool contracts, skills, MCP, A2A, approval gates, and secure communication.
Open sectionMulti-Agent Systems
Topology choices, delegation, supervisors, parallelism, and consensus.
Open sectionSystems Architecture
Reference architectures for agentic services, RAG, coding, personal agents, and domains.
Open sectionProduction Runtime
Runtime controls, observability, policy, budgets, durable workflows, and events.
Open sectionHands-On Labs
Practical implementation paths and vertical slices.
Open sectionCapstone Projects
Complete product-shaped examples that combine patterns, evals, traces, ADRs, runbooks, and rollout controls.
Open sectionHistorical Patterns
Historical patterns retained for context.
Open sectionPublishing Appendix
Release, publishing, and maintenance notes.
Open section