What Are Agentic Design Patterns and How Do They Map to Software Architecture?

Updated

Agentic design patterns are reusable structures for breaking a complex agent task into smaller LLM calls and orchestration steps, and most of them map directly onto architecture concepts you already know: Prompt Chaining ≈ Pipe & Filter, Routing ≈ Load Balancer / API Gateway, Parallelization ≈ Scatter-Gather / MapReduce, Reflection ≈ a unit-testing/TDD loop, Tool Use ≈ Adapter/Proxy, and Multi-Agent Collaboration ≈ microservices. That mapping is the fastest way to reason about an agent system, because you can reuse the same trade-offs (coupling, fan-out, failure isolation) you apply to ordinary services. It applies when you're designing or reviewing an agent workflow; it does not tell you which model to use or guarantee production behavior on its own.

The core patterns and their software analogues

The curriculum this is drawn from lists 21 developer patterns, each paired with a conventional software concept. The first several are the ones you'll reach for most often:

Pattern Software analogue What it does
Prompt Chaining Pipe & Filter Decomposes a complex task into a linear sequence of smaller LLM calls; each step's output becomes the next step's input/context
Routing Load Balancer / API Gateway Classifies the input by semantic intent and complexity, then delegates to a specialized agent, model, or processing path
Parallelization Scatter-Gather / MapReduce Runs independent tasks at once — voting on a decision, generating multiple drafts, verifying facts against different sources — then aggregates results. Also called Sectioning or Voting
Reflection Unit Testing / TDD Loop Has the agent critique and revise its own output before it's accepted
Tool Use Adapter / Proxy Lets the agent call external functions or services through a uniform interface
Planning Workflow Orchestration / Saga Sequences multi-step work, including compensating steps when part of it fails
Multi-Agent Collaboration Microservices Architecture Splits work across agents with distinct responsibilities

The pattern list continues into Memory Management (Database / Caching / Session State), Learning & Adaptation (CI/CD / A-B Testing), State Management via MCP (IDL / REST Standards / USB-C), Goal Setting & Monitoring (Health Checks / APM), Exception Handling & Recovery (Try-Catch / Circuit Breaker), Human-in-the-Loop (Manual Approval Gates), Knowledge Retrieval / RAG (Database Query / Search Index), and Inter-Agent Communication / A2A (Messaging).

Why the mapping matters more than the pattern names

The analogy isn't decoration — it tells you what each pattern costs you.

  • Prompt Chaining buys you debuggability at the price of latency: every step is a round trip, so a five-step chain is roughly five sequential calls. Same trade-off as a long pipe-and-filter pipeline.
  • Routing buys you specialization at the price of a classifier you now have to maintain and evaluate. If the router misclassifies, the downstream handler is simply wrong — the same failure mode as a misconfigured gateway.
  • Parallelization buys you latency reduction and diversity (multiple drafts, multiple verifiers) at the price of aggregation logic. Scatter is easy; gather is where the bugs live.
  • Reflection buys you quality at the price of tokens and time, and it can loop indefinitely if you don't bound the number of revision rounds — treat it like a test loop with a retry cap.
  • Human-in-the-Loop is the manual approval gate: it's the pattern you add when the cost of a wrong action exceeds the cost of waiting for a person.

Choosing patterns by task complexity

A practical way to avoid over-designing:

  1. Single well-defined transformation → Prompt Chaining only. Don't add agents.
  2. Mixed input types or intents → add Routing in front of your chains.
  3. Independent sub-tasks or a need for confidence → add Parallelization (voting or multi-source verification).
  4. Output quality matters more than latency → add Reflection.
  5. The agent must act on the outside world → add Tool Use, and add Human-in-the-Loop for irreversible actions.
  6. Long-running or stateful work → add Memory Management and Exception Handling & Recovery.
  7. Genuinely separable responsibilities → only then split into Multi-Agent Collaboration.

The failure mode at each step is the same: adding a pattern before you have the problem it solves. Multi-agent systems in particular are the microservices of this space — they solve organizational and isolation problems, and they introduce coordination problems in exchange.

How to start practicing

The source curriculum is structured as interactive practice rather than reading: it describes itself as "like LeetCode, but for AI agents," with two tracks — 21 patterns for developers and 15 modules for product managers, 36 lessons total. Seven patterns and the first PM module are open without an account; a free account unlocks the rest. Pattern 01 is Prompt Chaining, and there's also a no-signup "Will AI Replace Me?" assessment that produces a personalized action plan.

If you want to work through it, the useful order is: read pattern 01, implement a two-step chain with a real task, then add Routing and observe where classification breaks. That gives you the concrete failure data you need before deciding whether Parallelization or Reflection is worth the added cost in your own system.