Every production AI system is built from a small set of reusable patterns. This guide explains all 21 — from the basics to enterprise-scale architecture — in plain language, without a single line of code.
The most common mistake in enterprise AI is treating every deployment as a unique engineering problem that requires inventing the solution from scratch. It is not. The same architectural patterns appear across every industry, every function, and every use case. Once you recognise them, you can apply them deliberately — and avoid the failures that come from applying them accidentally.
These 21 patterns come from the open-source book Agentic Design Patterns by the evoiz team, which covers agent architecture from beginner to enterprise level. Each pattern comes with a Jupyter Notebook for those who want to run code. This guide is for everyone else — the domain experts, the business analysts, the managers, and the operators who need to understand what they are deploying without necessarily implementing it themselves.
Each pattern is mapped to a PSF domain — the Production Safety Framework domain most relevant to getting that pattern right in production.
The seven patterns that appear in almost every production AI system. If you understand nothing else, understand these.
Breaking a complex task into a sequence of smaller prompts where each output feeds the next input. Like an assembly line — each station does one thing well, and the product moves forward.
A classifier that reads an input and decides which specialist agent or pipeline should handle it. The dispatcher of the agent world.
Running multiple agent tasks simultaneously rather than sequentially, then combining the results. What takes 10 minutes sequentially takes 1 minute in parallel.
An agent that reviews and critiques its own output, then revises it. A built-in quality check loop before the result reaches a human.
The pattern that turns a language model from a text generator into an actor. The model can invoke external tools — search the web, query a database, run code, send an email — and use the result to continue.
Multiple specialised agents working together, each owning a domain of the overall task, coordinated by an orchestrator.
The meta-pattern: a controlling agent that directs sub-agents, manages state, handles failures, and decides when the overall task is complete.
The patterns that determine whether an agent works in a demo or works in production — every day, at scale, without supervision.
How an agent stores and retrieves information across sessions, tools, and agent boundaries. The difference between an agent that forgets everything at the end of a conversation and one that builds an accurate model of your business over time.
How an agent detects that something has gone wrong and decides what to do about it: retry, escalate, skip, or fail gracefully.
The patterns for deciding when an agent should act autonomously and when it should pause and involve a human. The checkpoint architecture of production AI.
The input and output filters that prevent agents from receiving or producing content they should not. The bouncer at the door of every agent interaction.
Systematic measurement of whether an agent is actually doing what it should. Not just 'does it run' but 'does it produce the right outputs at the right quality level'.
Strategies for fitting the information an agent needs into the finite context it can process. What to include, what to summarise, what to retrieve on demand.
Connecting an agent to an external knowledge base so it can retrieve relevant information at inference time rather than relying on training data alone.
Advanced patterns for organisations running multiple agents at scale, often in regulated environments.
Agents triggered by events in your systems rather than by direct user prompts. The agent that wakes up when something happens, rather than when someone asks.
Architectures that route the outputs of one agent cycle back as inputs to improve the next cycle. The flywheel of autonomous systems.
Many simple agents working in parallel on variations of the same problem, with a synthesis layer that combines the best outputs.
An agent hierarchy where strategic agents direct tactical agents that direct operational agents. The org chart pattern applied to AI systems.
Agents that analyse their own performance and propose changes to their own prompts, tools, or workflows — with human approval before any change is applied.
Two or more agents take opposing positions on a question, then a third evaluates the debate and produces a verified conclusion.
Agents that are tested against progressively harder evaluation sets, with the difficulty level dynamically adjusted based on performance.
The 21 patterns distribute across the PSF domains as follows. A well-architected production AI system will address all 8 domains.
Every pattern above has a governance implication. In regulated environments — finance, healthcare, government — the question is not just "does this pattern work?" but "can you prove it works, and can an auditor verify it?" The CAIG and CAIAUD credentials certify that ability.
We've built a dedicated page for each pattern — with PSF domain alignment, PAI-8 control mappings, production failure modes, implementation checklists, and certification relevance. Bookmark the full library.
The AIDA examination tests applied PSF knowledge across all eight domains — exactly the gaps and strengths covered in this assessment. 15 minutes. No charge. Ever.