Agentic Design Patterns
A Visual Summary

What is an AI Agent?

An AI agent is a system that can perceive its environment, make decisions, and take actions to achieve a goal. Think of the difference between a calculator (you press buttons, it computes) and a personal assistant (you say "organize my schedule" and it figures out the steps on its own). An agent is the assistant.

At its core, every agent follows a five-step loop: get a mission, scan the scene, think it through, take action, then learn and improve. Large language models (LLMs) like ChatGPT or Gemini are the "brain" powering these agents, but on their own they just generate text. The 21 patterns in this book are the architecture that turns that raw brain into something that can reliably plan, use tools, remember things, collaborate with other agents, and stay safe.

Prompt Chaining

Instead of asking an AI to do a massive, complicated thing all at once, you break it into a sequence of smaller steps. The output of step one becomes the input for step two, and so on — like an assembly line. This dramatically reduces errors because each step is simple and focused.

Real-world analogy: Imagine asking someone to "summarize this report, pull out the key numbers, and draft an email about it" all in one breath. They'd likely miss something. But if you ask them to do each piece separately, they nail every step.

Routing

Routing adds decision-making to an agent's workflow. Instead of always following the same path, the agent analyzes the input and chooses the right path. Think of a receptionist who listens to your question and directs you to the right department.

The router can be the AI itself (it reads the question and classifies it), a set of rules ("if the message mentions billing, go to the billing agent"), or even an embedding model that matches meaning rather than keywords.

Parallelization

When multiple tasks don't depend on each other, run them at the same time instead of one after another. A travel agent that checks flights, hotels, and restaurants simultaneously gives you an answer much faster than one that checks each sequentially.

Reflection

Reflection is an AI checking its own homework. After generating an initial answer, the agent evaluates it — looking for errors, gaps, or ways to improve — and then revises. This can be the same agent reviewing its own work, or a separate "critic" agent whose only job is finding flaws.

The Producer-Critic model is especially powerful: one agent writes the draft, another tears it apart with structured feedback, and the first agent uses that feedback to improve. This cycle can repeat until the output meets a quality threshold.

Tool Use (Function Calling)

An AI model's knowledge is frozen at its training date and it can't take real-world actions on its own. Tool Use gives it hands: the ability to call external services like search engines, calculators, databases, or APIs. The model decides which tool to use and what arguments to pass, then an orchestration layer executes the call and feeds the result back.

This is what lets an agent check today's weather, look up your order status, send an email, or run code — bridging the gap between "thinking" and "doing."

Planning

Planning is the ability to receive a high-level goal and autonomously decompose it into a sequence of steps before executing. A planning agent doesn't just react — it strategizes. Give it "organize a team offsite for 30 people" and it'll create a step-by-step plan (find venues, check availability, book flights, etc.) and then execute each step.

The key insight: use planning when the "how" needs to be discovered, not when it's already known. If the workflow is fixed and repeatable, a simple chain is better. Planning shines when the path to the goal depends on context.

Multi-Agent Collaboration

Instead of one agent doing everything, you build a team of specialists. A "Researcher" agent finds information, a "Writer" agent drafts content, an "Editor" agent reviews it. They communicate through defined channels, pass work between each other, and together solve problems none could handle alone.

Collaboration can be sequential (assembly line), parallel (divide and conquer), hierarchical (a manager delegates to workers), or debate-based (agents argue to reach consensus). The architecture mirrors how human teams work.

Memory Management

Without memory, an agent forgets everything between conversations — like a goldfish. Memory Management gives agents two types of recall:

Short-term memory is the conversation context — recent messages and tool results within the current chat. It's limited by the model's context window (how many words it can "see" at once).

Long-term memory stores information across sessions using external databases. When the agent needs to recall something from weeks ago, it queries this store and pulls the relevant information back into its current context.

Learning & Adaptation

This pattern is about agents getting better over time. Through techniques like reinforcement learning (trial and error with rewards), few-shot learning (learning from a handful of examples), or even self-modification (an agent editing its own code), agents can evolve beyond their initial programming.

A striking example is SICA (Self-Improving Coding Agent), which reviews its own past performance, identifies what to improve, then modifies its own source code to get better at coding tasks — progressively building new tools for itself.

Model Context Protocol (MCP)

MCP is like a universal adapter for AI. Instead of building a custom integration every time you want an AI to talk to a new tool or database, MCP provides a standardized interface. Any AI that speaks MCP can connect to any tool that speaks MCP — like how USB-C lets any device plug into any port.

An MCP server exposes tools, data (resources), and interaction templates (prompts). An MCP client (the AI app) discovers what's available and uses it. This is different from basic function calling, which is vendor-specific and one-to-one. MCP creates an interoperable ecosystem.

Goal Setting & Monitoring

This pattern gives agents a sense of purpose. You define specific, measurable objectives (think SMART — Specific, Measurable, Achievable, Relevant, Time-bound — goals), and the agent continuously monitors its own progress. If it drifts off course or encounters obstacles, the monitoring system detects the deviation and triggers adjustments.

This transforms an agent from a task executor into a goal-driven system — one that can assess "am I getting closer to the goal?" and self-correct when the answer is no.

Exception Handling & Recovery

Real-world agents will encounter failures — APIs go down, data gets corrupted, unexpected inputs arrive. This pattern builds resilience through three layers: detection (catching errors as they happen), handling (logging, retrying, falling back to alternatives), and recovery (rolling back to a stable state, replanning, or escalating to a human).

Human-in-the-Loop

Full autonomy isn't always safe or desirable. HITL (Human-in-the-Loop) deliberately integrates human judgment at critical points — approving plans before execution, reviewing high-stakes decisions, providing feedback that improves the agent over time, or stepping in when the AI encounters something beyond its abilities.

Think of it as a collaboration: the AI handles the heavy lifting of data processing and initial analysis, while the human provides judgment, ethics, and domain expertise. The goal isn't to slow things down but to catch what the AI might miss.

Knowledge Retrieval (RAG)

RAG (Retrieval-Augmented Generation) solves a fundamental limitation: AI models only know what they were trained on, and that knowledge is frozen. RAG connects the model to a live knowledge base. When you ask a question, the system first searches for relevant information, then feeds those results into the AI's prompt as context, so it can generate an answer grounded in real, up-to-date facts.

Agentic RAG goes further: instead of passively accepting whatever the search returns, an intelligent agent evaluates the results — checking if sources are current, resolving contradictions between documents, identifying knowledge gaps and running follow-up searches.

Inter-Agent Communication (A2A)

Google's A2A (Agent-to-Agent) protocol is an open standard that lets agents built with completely different frameworks talk to each other. Each agent publishes an "Agent Card" — a digital identity file describing what it can do. Other agents discover these cards and delegate tasks accordingly.

If MCP is a universal adapter for tools, A2A is a universal translator for agents. Together they enable an ecosystem where specialized agents from different vendors can be composed into complex workflows.

Resource-Aware Optimization

Not every question needs the most powerful (and expensive) AI model. This pattern dynamically selects the right model based on task complexity, budget, and latency requirements. A simple factual question goes to a fast, cheap model; a complex analysis goes to a powerful one.

A "Router Agent" classifies the difficulty, and a "Critique Agent" evaluates the quality of responses, creating a feedback loop that improves routing over time. Fallback mechanisms ensure the system keeps working even when a preferred model is unavailable.

Reasoning Techniques

These techniques make the AI's "thinking" visible and structured, dramatically improving accuracy on complex problems.

Chain of Thought (CoT) prompts the model to think step-by-step instead of jumping to an answer. Tree of Thoughts (ToT) explores multiple reasoning paths simultaneously, like branching possibilities. ReAct interleaves reasoning with action — the agent thinks, acts (uses a tool), observes the result, then thinks again.

The Scaling Inference Law reveals that giving a smaller model more "thinking time" can outperform a larger model that answers quickly. Quality comes from how much the model deliberates, not just how big it is.

Guardrails & Safety

As agents become more autonomous, guardrails become essential. They're implemented at every layer: input validation screens out malicious content and jailbreak attempts. Output filtering catches toxic or off-topic responses. Behavioral constraints in the system prompt define boundaries. Tool restrictions limit what actions the agent can take.

Engineering reliable agents also means applying proven software principles: modularity (small, specialized agents), observability (structured logging of every decision), least privilege (agents only get the permissions they need), and checkpoint/rollback (the ability to undo if things go wrong).

Evaluation & Monitoring

Traditional software tests don't work well for AI agents because their outputs are non-deterministic. This pattern establishes continuous measurement: tracking accuracy, latency, and token costs; analyzing the full sequence of steps (the "trajectory") the agent takes; and using techniques like "LLM-as-a-Judge" where one AI evaluates another's quality.

The chapter also introduces the concept of AI "Contracts" — formal agreements that precisely define what an agent is expected to deliver, enabling objective verification of success.

Prioritization

When an agent faces competing tasks and limited resources, it needs to decide what to do first. Prioritization evaluates each task against criteria like urgency, importance, dependencies, and cost, then ranks them. The agent tackles the highest-priority items and dynamically re-prioritizes as conditions change.

Exploration & Discovery

Most patterns optimize known workflows. Exploration is about finding things you didn't know to look for. Agents designed for exploration proactively venture into unfamiliar territory — generating hypotheses, designing experiments, running searches on their own initiative, and uncovering "unknown unknowns."

Google's AI Co-Scientist exemplifies this: a multi-agent system where one agent generates hypotheses, another critiques them, a third ranks them through simulated debates, and a fourth evolves the best ideas. In lab validation, it independently re-discovered findings that took human researchers over a decade.