The Source Map connects external agent-pattern references to this book’s chapters and explains how each source informs the catalog.

Section
Pattern Selection and Composition
Type
Reference
Level
Intermediate
Read
12 min
Effort
10-20 min reference
ArchitectReviewer

Source Map

This page maps external references to this book’s chapters. Use it as a reading guide, not as a replacement for the book’s pattern language.

The sources repeat several core ideas: start simple, separate workflows from agents, use tools through typed contracts, add memory deliberately, evaluate behavior, and reserve multi-agent systems for cases where specialization justifies orchestration cost.

How To Use This Map

Use this page when you need to answer one of three questions:

Question Use This Section Output
Where did this book’s pattern language come from? Primary References and Local PDF References Reviewed. A short source trail for a chapter, decision, or term.
Does the book cover a pattern I saw elsewhere? Pattern Coverage Map and Local Pattern Repository Coverage. A chapter link, or a candidate gap for future expansion.
Which sources should I trust first? Evidence Tiers. A priority order for reading, citing, and revising.

For normal reading, do not start here. Start with How To Read This Book, then return to this map when you want source context or coverage checks.

sequenceDiagram participant Source participant Editor participant Chapter participant Release Source->>Editor: Pattern, claim, or failure mode Editor->>Editor: Check access and evidence tier alt Weak or inaccessible source Editor-->>Source: Keep as discovery only else Strong source Editor->>Chapter: Map to claim or coverage gap alt Changes design advice Chapter->>Chapter: Update prose, diagram, lab, or checklist Chapter->>Release: Verify links, site parity, and PDF else No design change Chapter-->>Editor: Keep as reference context end end

Read the map as an editorial filter. A source earns space in the book when it changes a reader’s design decision, exposes a missing failure mode, or gives stronger evidence for a chapter claim.

Source-Backed Decision Shortcuts

Use these shortcuts when a source names a pattern but the engineering decision is still unclear.

Decision You Need To Make Start With Use The Sources To Check
Is this a workflow, an agent, or a multi-agent system? Choosing the Right Pattern Whether the source separates deterministic control from model-chosen steps.
Should we add routing, handoffs, or specialist agents? Routing and Handoffs and Choosing Multi-Agent Topology Whether separate context, tools, permissions, or latency justify coordination cost.
Does this need memory, retrieval, or a knowledge boundary? Context Engineering, Working Memory, and Agentic RAG Systems Whether the source distinguishes transient context, durable memory, and cited evidence.
Are tools safe enough for model-mediated use? Tool Capability Design, MCP-first Tool Use, and Human Approval Gates Whether tool authority, schema, errors, policy, and approval are explicit.
Can the pattern survive production failure? Circuit Breakers, Fallbacks, and Replay, Observability and Evals, and Production Evaluation Feedback Loops Whether traces, replay, evals, rollback, and incident feedback are part of the design.
Is a source adding a useful pattern or just a new name? Pattern Composition Playbook Whether the pattern changes ownership, state, tools, risk, evals, or operations.

Evidence Tiers

Not every source has the same editorial weight. Use this order when sources disagree:

Tier Source Type Editorial Use
1 Vendor engineering guides, framework docs, and primary implementation docs. Use for current terminology, operational guidance, and framework-specific behavior.
2 Technical books and long-form practitioner material. Use for durable concepts, teaching order, and examples that need deeper explanation.
3 Curated catalogs, pattern lists, and diagrams. Use for coverage discovery and cross-linking, not as final authority.
4 Videos, gated articles, and lightly reviewed posts. Use as discovery material only until claims are checked against stronger sources.

This prevents the online book from drifting toward whatever source has the longest pattern list. The book should privilege engineering evidence over novelty.

Primary References

Source Useful Ideas Book Mapping
Anthropic: Building Effective Agents Workflows vs agents, prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, autonomous agents. Choosing the Right Pattern, Prompt Chaining and Gates, Routing and Handoffs, Evaluator-Optimizer, Agent Loop.
Google Cloud: Choose a design pattern for your agentic AI system Requirements-first selection, single-agent and multi-agent patterns, sequential, parallel, iterative refinement, human-in-the-loop, custom logic. Choosing the Right Pattern, Parallel Agents, Human Approval Gates, Agentic System Architecture.
Databricks: Agent system design patterns Complexity continuum from prompt to deterministic chain to single-agent and multi-agent systems, plus production guidance for testing, tracing, failure handling, model updates, and cost. Choosing the Right Pattern, Circuit Breakers, Fallbacks, and Replay, Observability and Evals.
LangChain: Choosing the Right Multi-Agent Architecture Multi-agent selection across subagents, skills, handoffs, and routers, with explicit tradeoffs around context isolation, state, parallelism, and model-call overhead. Choosing the Right Pattern, Routing and Handoffs, Skills, Supervisor / Worker, Parallel Agents.
LangChain: Deep Agents overview and Frameworks, runtimes, and harnesses Agent harness framing: planning, files, context management, subagents, long-term memory, human approval, permissions, sandboxes, durable execution, and framework/runtime/harness distinctions. Agent Harnesses, Context Budgets and Working Sets, Agent Engineer Toolkit, Framework Selection, Skills, Durable Workflows.
MongoDB: 7 Practical Design Patterns for Agentic Systems Controlled flows, LLM routing, parallelization, reflection, human-in-the-loop, agents, and multi-agent architectures. Prompt Chaining and Gates, Routing and Handoffs, Reflection, Supervisor / Worker.
Agentic Patterns Graph Large pattern catalog with categories for context, orchestration, reliability, security, tool use, learning, and UX. Circuit Breakers, Fallbacks, and Replay, Context Engineering, Working Memory, Policy Enforcement.
GitHub: awesome-agentic-patterns Curated repository of production and emerging patterns, useful as a discovery index. This source informs the extended catalog and future additions, especially reliability, context, coding-agent, security, and tool-use patterns.

Secondary References

Source Useful Ideas How To Use
ByteByteGo: Top AI Agentic Workflow Patterns Accessible explanations of reflection, tool use, ReAct, planning, and multi-agent patterns. Good introductory reading for readers who want a lighter explanation before the deeper chapters.
Phil Schmid: Zero to One - Learning Agentic Patterns Practical examples for routing, parallelization, tool use, orchestrator-workers, and multi-agent systems. Useful for implementation intuition and example shapes.
ProjectPro: Agentic AI Design Patterns Planning, tool use, reflection, multi-agent examples, and a practical MCP discussion. Useful for explaining common enterprise examples.
Tungsten Automation: Tool-Use Pattern Enterprise framing for tool use, ground truth, and workflow APIs. Maps to MCP-first Tool Use and Policy Enforcement.
Towards AI: 5 Design Patterns in Agentic AI Workflow Introductory framing for prompt chaining and workflow decomposition. Useful as a light overview; the article is partially gated.
Medium: Multi-Agent System Patterns Multi-agent architecture dimensions: control, execution, coordination, and interaction. Useful distinction between roles and patterns. Good support for a future bridge chapter on composing multi-agent systems without turning the book into a flat catalog.
Medium: Agentic Design Patterns Common pattern explanations for reflection, tool use, planning, and multi-agent design. Duplicates core concepts already covered here.
Medium: Agentic Patterns - Architectures for Coordinated AI Systems Hierarchical, peer-to-peer, market-based, and swarm coordination. Useful for future expansion of multi-agent coordination patterns.
YouTube: AI agent design patterns Video walkthrough of agent design patterns. Use as companion media, not as a primary textual source unless transcript review is added.
YouTube: Master ALL 20 Agentic AI Design Patterns Broad video catalog of pattern names and examples. Use as discovery material; validate individual claims against primary sources.

Sources that were not publicly accessible or only served as discovery routes were excluded from the map.

Local Pattern Repository Coverage

A local flattened digest of the awesome-agentic-patterns project was used as a coverage checklist. Its patterns were not copied into this book. They helped identify missing or underdeveloped areas that now have authored treatment here.

The 2026-06-20 intake scan extracted 167 pattern records across orchestration and control, tool use and environment, reliability and evaluation, context and memory, UX and collaboration, security and safety, feedback loops, and learning and adaptation. The online book should use this catalog as an expansion queue for chapter quality and cross-links, not as a replacement taxonomy.

Local Pattern Area Representative Patterns Reviewed Book Mapping
Agent threat model and tool security lethal-trifecta-threat-model, policy-gated-tool-proxy, sandboxed-tool-authorization, egress-lockdown-no-exfiltration-channel, pii-tokenization. Agent Threat Model, Agent Security and Sandboxing, Policy Enforcement, Tool Capability Design.
Tool capability and agent-friendly interfaces cli-first-skill-design, tool-capability-compartmentalization, llm-friendly-api-design, agent-first-tooling-and-logging, static-service-manifest-for-agents, code-first-tool-interface-pattern. Skills, Tool Capability Design, MCP-first Tool Use, Agent Harnesses.
Context operations curated-file-context-window, curated-code-context-window, context-window-auto-compaction, context-minimization-pattern, context-window-anxiety-management. Context Budgets and Working Sets, Context Engineering, Agent Harnesses.
Production eval feedback incident-to-eval-synthesis, workflow-evals-with-mocked-tools, canary-rollout-and-automatic-rollback-for-agent-policy-changes, anti-reward-hacking-grader-design, background-agent-ci. Production Evaluation Feedback Loops, Evaluation-Driven Agent Development, Observability and Evals, Coding Agents.
Coding-agent runtime coding-agent-ci-feedback-loop, background-agent-ci, asynchronous-coding-agent-pipeline, shell-command-contextualization, custom-sandboxed-background-agent. Coding Agents, Agent Harnesses, Production Evaluation Feedback Loops.
Multi-agent topology and coordination declarative-multi-agent-topology-definition, board-mediated-inter-agent-coordination, workspace-native-multi-agent-orchestration, oracle-and-worker-multi-model, multi-model-orchestration-for-complex-edits. Choosing Multi-Agent Topology, Agents As Services, A2A Agent Interoperability, Supervisor / Worker.

This local source is best treated as a checklist, not as the book’s taxonomy. Some entries are production-proven, some are emerging, and some are research or product-specific. The book should keep absorbing the useful engineering ideas while preserving its own structure: boundaries first, then patterns, then evaluation and operations.

Local PDF References Reviewed

The following PDFs were reviewed or intake-scanned locally as source-of-knowledge inputs. They are not included in this repository, linked from the book, or reproduced. They inform coverage checks, chapter structure, and topic prioritization only.

Local Reference Useful Themes Book Mapping
AI Agents in Action, Micheal Lanham Agent definitions, LLM interfaces, GPT assistants, AutoGen and CrewAI multi-agent systems, agent actions, behavior-tree orchestration, agent platforms, RAG, memory, prompt flow, reasoning, evaluation, planning, and feedback. What Is An Agent?, Framework Selection, CrewAI Flows and Crews, Tool Use, Memory-Augmented Agent, Planning and Execution, Evaluation-Driven Agent Development.
30 Agents Every AI Engineer Must Build, Imran Ahmad Agent engineering foundations, toolkit decisions, domain agents, retrieval agents, tool orchestration, software agents, explainability, and domain-specific agents. Agent Engineer Toolkit, Framework Selection, Domain Agent Architectures, Coding Agents, Agentic RAG Systems.
Agentic Architectural Patterns for Building Multi-Agent Systems, Ali Arsanjani, Juan Pablo Bustos, Thomas Kurian Enterprise maturity, agent-ready model selection, RAG-to-fine-tuning spectrum, coordination patterns, compliance, robustness, human-agent interaction, production readiness. Choosing the Right Pattern, Agent Development Lifecycle, Agent Security and Sandboxing, Domain Agent Architectures, Agentic System Architecture.
Agentic Design Patterns, Antonio Gulli Prompt chaining, routing, parallelization, reflection, tool use, planning, memory, MCP, A2A, monitoring, guardrails, resource optimization, CLI and coding agents. Prompt Chaining and Gates, Routing and Handoffs, Resource-Aware Agent Design, MCP-first Tool Use, A2A Agent Interoperability.
Designing Multi-Agent Systems, Victor Dibia Multi-agent taxonomy, UX principles, execution loops, cancellation, memory, middleware, computer-use agents, workflow graphs, observability, evaluation, distributed protocols, ethics. Agent UX and Human Trust, Evaluation-Driven Agent Development, Computer-Use Agents, Supervisor / Worker, Secure Agent Communication.
Patterns for Building AI Agents, Sam Bhagwat and Michelle Gienow Agent capability design, context engineering, context compression, eval suites, production data evaluation, sandboxing, granular access control, guardrails. Context Budgets and Working Sets, Context Engineering, Resource-Aware Agent Design, Evaluation-Driven Agent Development, Agent Security and Sandboxing.
Build a Multi-Agent System (from Scratch), Val Andrei Fajardo Foundational LLM agent construction, tools, LLM interfaces, MCP tools, skills, memory, human-in-the-loop, A2A, and building a small educational framework from first principles. Tool Use, MCP-first Tool Use, Skills, Memory-Augmented Agent, A2A Agent Interoperability.
Build an AI Agent (From Scratch), Jungjun Hur and Younghee Song LLM interface design, tool use, ReAct, RAG, memory, planning, reflection, code execution, multi-agent orchestration, and agent evaluation. Single Agent, ReAct, Semantic Recall and RAG, Planning and Execution, Evaluation-Driven Agent Development.
Designing AI Agents, Jia Huang Agent harnesses, bounded resource allocation, cognitive functions, execution topology, governance, and a running code-review-agent example. Agentic System Architecture, Resource-Aware Agent Design, Coding Agents, Policy Enforcement, Architecture Decision Records.
Multi-Agent Systems with AutoGen, Victor Dibia AutoGen-based multi-agent foundations, UX, interface agents, evaluation, optimization, deployment, messaging protocols, safety, and sandboxing. CrewAI Flows and Crews, Agent UX and Human Trust, Computer-Use Agents, Evaluation-Driven Agent Development, Agent Security and Sandboxing.
AI Agents and Applications, Roberto Infante LangChain, LangGraph, MCP, RAG, tool-based agents, multi-agent systems, memory, guardrails, and productionization. Framework Selection, Agentic RAG Systems, MCP-first Tool Use, Multi-Agent Systems, Observability and Evals.
Agentic Transformation Playbook Business adoption framing, agent lifecycle management, governance, human role design, and common enterprise use cases. Agent Development Lifecycle, Agent UX and Human Trust, Policy Enforcement, Domain Agent Architectures.

Pattern Coverage Map

External Pattern Name Current Book Chapter
Augmented LLM Single Agent, Tool Use, Structured Output
Prompt chaining Prompt Chaining and Gates
Routing Routing and Handoffs
Parallelization Parallel Agents
Orchestrator-workers Supervisor / Worker, Planning and Execution
Evaluator-optimizer Evaluator-Optimizer
Reflection Reflection
ReAct ReAct
Agent loop Agent Loop
Human-in-the-loop Human Approval Gates
Tool use Tool Use, MCP-first Tool Use
Memory and context Context Engineering, Working Memory, Long-Term Episodic Memory
Resource-aware optimization Resource-Aware Agent Design
Agentic RAG Semantic Recall and RAG, Agentic RAG Systems
Multi-agent supervisor Supervisor / Worker
Peer or network agents A2A Agent Interoperability, Debate and Consensus
Circuit breaker Circuit Breakers, Fallbacks, and Replay
Action replay Circuit Breakers, Fallbacks, and Replay, Observability and Evals
Deterministic chain Choosing the Right Pattern, Durable Workflows
Coding agent Coding Agents
Computer-use agent Computer-Use Agents
Domain-specific agent Domain Agent Architectures

Maintenance Checklist

Update this page when a source changes the book’s structure, not every time a new link appears.

Before adding a source, check:

  • Does it introduce a pattern, failure mode, runtime concern, or implementation technique not already covered?
  • Is it stronger than an existing source for the same claim?
  • Does it map to at least one chapter where a reader can act on the idea?
  • Is it public enough for an online GitHub Pages reader to inspect?
  • Does it create a concrete editorial task, such as a missing example, checklist, diagram, lab, or cross-link?

If the answer is mostly no, leave the source out. A shorter map with clear editorial purpose is more useful than a large reference pile.

Editorial Rule

External sources are used to validate coverage and expose missing patterns. The book keeps its own taxonomy:

  • foundations first;
  • control loops second;
  • memory and knowledge as a separate concern;
  • tools, skills, and protocols as integration boundaries;
  • multi-agent systems only when specialization has value;
  • production runtime patterns for safety, evaluation, and operations;
  • source-informed pattern selection as the entry point for choosing the right design.

This keeps the book useful as a reference instead of turning it into a link dump.