Patterns of Enterprise Agentic Application Architecture: Classic Enterprise Patterns for the Professional Agentic Architect — Pre-Release Preprint

Agents are now writing enterprise software faster than any human team can review it. Most of what they ship has no pattern vocabulary behind it.

The last time the industry faced a velocity crisis of this shape, a single catalog held the line: Fowler's Patterns of Enterprise Application Architecture, in 2002. That book gave enterprise teams a shared vocabulary — Service Layer, Repository, Unit of Work — and turned architecture from individual intuition into communicable structure.

Writing code is no longer slow. But a confused agent doesn't write confused code in one place. It writes confused code everywhere it was directed, consistently, before anyone notices. The structural problems Fowler named haven't gone away. They compound at machine speed.

This book is the continuation of that catalog, updated for the actors of the present decade.

Patterns of Enterprise Agentic Application Architecture catalogs 59 production-tested patterns mapped 1:1 to Fowler's original entries — Task Script, Agent Model, Orchestration Layer, Command Center, State Mapper, Token Budget, HITL Gate, Implicit Isolation. Each pattern names a recurring structural problem, documents its solution, and records where it appears in production. Eleven additional patterns with no Fowler analog — the Decaying Priority Signal, the Learned Approval Gate, the Ralph Wiggum Loop, and others — are cataloged in the appendix.

This is not a prompt engineering guide. Every pattern addresses the architecture around the prompt: how to layer agent responsibilities, where to put state, how to hold context across invocations, when to gate output for human review, and how to prevent two agents from producing contradictory decisions that each look correct in isolation.

A single tradeoff runs through every pattern: control costs development velocity, and velocity costs control. Agents produce output faster than human engineers, which means wrong decisions compound faster. Every pattern documents this tradeoff explicitly so the decision is made deliberately, not by default.

The catalog covers:

• Agent logic — Task Script, Agent Model, Tool Module, Orchestration Layer
• Context sourcing — Context Gateway, State Mapper, Active Context, Lazy Context
• State management — Unit of Execution, Context Cache, Persistent Agent State
• Concurrency — Optimistic Task Lock, Queue Lock, Implicit Isolation
• Distribution — Agent Facade, Task Transfer Object
• Interfaces — Model-Orchestrator-Worker, Command Center, Workflow Controller
• Foundation — Token Budget, Fallback Agent, Agent Registry, Three-Config Stack

Every pattern has a production implementation. The primary reference is the Software Factory — a real multi-agent system running six to twelve parallel workers under a single architect's oversight. No candidate without observed production use was included. This is not a thought experiment; it is a field manual extracted from a running system.

For the enterprise architect who needs decisions already made, tested in production, documented with their trade-offs. For the solo developer who now has the capability to build what used to require a team. For any team where AI agents do real work — scheduling, synthesizing, deciding, executing.

The ratio changed. The principle didn't.