I have been waiting for this book, or one like it, for about eighteen months. Agentic Architectural Patterns is the first serious attempt at a patterns catalogue for systems built around autonomous, goal-directed, tool-using agents. It comes from the right authors — Ali Arsanjani has been writing about AI engineering patterns for years, and Juan Bustos brings the implementation perspective — and it is dense in the way good patterns books are dense.

This is the implementation-level companion to Enterprise Architecture in the Age of Agentic AI. Where Dahdour gives you the EA-level framing, Arsanjani and Bustos give you the patterns you actually need at the system-design level.

What a “pattern” means in this book

The book uses the classic Gang-of-Four-style pattern format: context, problem, forces, solution, consequences, related patterns. This is the right choice. Agentic systems are still new enough that the patterns are not stable enough for the form to feel forced, but the GoF format provides the rigour to make the patterns comparable in a way that a more essayistic treatment would not.

The catalogue itself is organised into roughly four groups:

  • Single-agent patterns: the building blocks. Tool-use loops, reflection patterns, structured-output patterns, planning patterns.
  • Multi-agent coordination patterns: orchestrator-worker, manager-of-managers, peer-to-peer, blackboard, contract net. Many of these are re-discoveries from the classical multi-agent systems literature with modern LLM-shaped twists.
  • Memory and state patterns: working memory, episodic memory, semantic memory, the distinction between agent-private state and shared world state.
  • Safety and control patterns: guardrails, circuit breakers, human-in-the-loop checkpoints, the trade-offs between each.

The patterns I have actually used

A patterns catalogue is only as good as the patterns you reach for. Three from this book have already changed how I review designs.

The Verifier Pattern. A second agent (or a deterministic checker) that validates the first agent’s output before it is acted on. The book is clear that the verifier needs to be cheaper, simpler, and less powerful than the agent being verified, or you have just doubled your problem. This is correct and is the failure mode I see most often in internal designs.

The Bounded-Autonomy Pattern. Explicit, per-action policies that define what an agent is allowed to do without human approval, what requires asynchronous review, and what requires synchronous review. The pattern is not new — every serious agentic system needs something like it — but the book’s articulation of the forces (cost of false negatives vs. cost of human interruption) is the sharpest I have read.

The Episodic-Compaction Pattern. The pattern for managing long-running agent memory by summarising past episodes into compact representations that can be cheaply rehydrated. The book is honest that this is an open research area and that the failure modes (loss of important context, confabulation in the summary) are serious. The pattern is presented with appropriate humility.

What the book gets right

The patterns are honest about trade-offs. Every pattern has a “Consequences” section that names the costs. This is the part most patterns books get wrong; this one gets it right.

The book takes evaluation seriously. Most agentic-systems literature treats evaluation as an afterthought. Agentic Architectural Patterns devotes a substantial section to evaluation patterns — golden-set evaluation, online evaluation, judge-model evaluation, the trade-offs between them. This is genuinely useful material that I have not seen catalogued elsewhere.

The cross-references work. The patterns reference each other in non-trivial ways, and the cross-references are accurate. Some patterns books advertise their interconnectedness and then fail to deliver. This one delivers.

What the book gets less right

It is uneven on cost. Some patterns are presented with detailed cost analysis (typical token-cost ranges, expected latency implications); others are not. A reader trying to do back-of-the- envelope sizing for a real system will have to fill in the gaps.

The treatment of failure modes specific to particular model families is weak. The book is mostly model-agnostic, which is the right choice for longevity, but in practice the failure modes of (say) a frontier reasoning model on multi-step planning differ from those of a smaller open-weight model, and the book does not give you much purchase on that.

The book is dense. Even by patterns-book standards. I read it in chunks of two patterns at a time, which felt right. Trying to read it linearly is a mistake.

How it pairs

The natural pair is Enterprise Architecture in the Age of Agentic AI, which provides the EA-level framing this book mostly assumes. Read Dahdour first if you are trying to convince a CIO; read Arsanjani and Bustos first if you are trying to design an actual system.

The less-obvious pair is Building Evolutionary Architectures. The fitness-function framing turns out to be exactly the right mental model for agentic systems: you cannot fully specify the behaviour, but you can specify properties the behaviour must continue to satisfy. Several of the patterns in Agentic Architectural Patterns are, in effect, fitness-function patterns under another name.

Reading note

This is a reference book first and a read-it-cover-to-cover book second. The print edition is the better purchase if you can find it; the patterns format works much better when you can flip between related patterns. The Kindle edition is fine for linear reading but frustrating for the cross-referenced use I actually do most.

Who I’d give this to

  • A principal engineer or staff engineer responsible for the architecture of an internal or customer-facing agentic system.
  • A platform team building agent infrastructure (memory, tool registries, evaluation harnesses).
  • An EA who wants to engage substantively with implementation-level conversations about agentic systems rather than staying at the governance altitude.

I would not give it to:

What it changed for me

It gave me a vocabulary for the patterns I was already using. This is the highest compliment I can pay a patterns book. Several of the patterns in this catalogue are things I had been informally designing into systems without a name for; having the name makes the design reviews faster and the documentation cleaner.

It also gave me the Verifier pattern in its fully-articulated form, which I had been getting wrong (by using verifiers that were too capable, which created their own verification problem). One pattern, used correctly, has already paid for the book.

Bottom line

The first serious agentic patterns book, written by the right people, with the right rigour. Buy it. Do not try to read it in one sitting. Use it as a reference when you are designing or reviewing.

For the EA-level framing, see Enterprise Architecture in the Age of Agentic AI. For the architectural-evolution framing that turns out to underwrite the whole book, see Building Evolutionary Architectures.