The Anatomy of an AI Application
A six-tier view of what one AI product is made of, crossed by a trust and operations plane that attaches controls to every tier; what the factory already supplies per tier, how the anatomy maps to the six-layer product portfolio, and how to run an anatomy review.
- Version
- 0.2.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 8 min
For Cto · Ai Architect · Platform Engineer · Product Leader · Risk And Assurance
Sources and details
- Section
- Understand
- Source works
- Book 1 · Book 2 · Research Series
- Source chapters
- 6, 11, 22
- Refresh trigger
- source change
An AI application is more than a model and a prompt. It is a set of connected capabilities with different owners, change rates and failure modes. Use this anatomy during architecture review to locate what a product needs, what the factory already supplies, and where controls must attach. It is the checklist behind question 6 of the decision sequence: which catalogue assets already cover each tier?

The six-tier anatomy and the cross-cutting trust and operations plane. Source: The AI Delivery Factory, Chapter 22, Figure 22.1.
Six tiers, one cross-cutting plane
Research Paper 1 (§4.1) numbers the tiers L0–L5 and the plane X; Book 2 (Ch 22 §4.1) uses the names only. The codes are useful in manifests and queries.
| Code | Tier | What belongs here | What the factory already supplies (Book 2 Ch 22 §4.1) | Questions for design |
|---|---|---|---|---|
| L5 | Experience and channels | Chat, embedded copilots, APIs, batch jobs, event-triggered and IDE surfaces | UI component library, conversation shells, feedback widgets | Who uses the product, through which channel, and what does the interface let them do? |
| L4 | Integration and interoperability | Tools, APIs, events, connectors, MCP servers, agent-to-agent endpoints | Tool broker, tool registry, agent cards, event contracts | Which systems can be called, under whose identity and with what authorisation? |
| L3 | Reasoning and orchestration | Prompts, context engineering, workflows, agents, planners, session state | Prompt library, workflow templates, agent templates, memory managers | Which next steps are fixed in code, and which are selected by a model? |
| L2 | Models | Foundation, small and specialised models, fine-tunes, classical ML, embedding and rerank models | Model gateway, evaluation-backed model cards, model usage registry | Which model is selected for each task, how is it evaluated, and how can it be changed? |
| L1 | Data and knowledge | Sources, ingestion, chunking, embeddings, vector and graph stores, semantic layer, long-term memory | Ingestion pipelines, document parsers, index templates, entitlement-aware retrieval store | What data may enter the request, who is entitled to it, and what may persist? |
| L0 | Infrastructure and hosting | Compute, accelerators, network, tenancy, region, sovereign or on-premises options | Landing zones, private endpoints, model-serving runtimes | Where does processing occur, what reaches the network, and how is the runtime isolated? |
| X | Trust and operations plane | Identity, authorisation, guardrails, evaluation, observability, cost, registries, audit evidence | The services of the enterprise control plane, consumed by the product | Which controls execute at each tier, and what evidence do they leave? |
Integration sits beside orchestration, not below it, because agents call tools and tools can call agents.
The plane is not a seventh tier and must never be drawn as one. It is Book 1’s enterprise agent control plane (Ch 11) seen from the product side — identity, registry, policy, observability, approval and evidence — met by a product as services it consumes rather than planes it operates. Controls attach to tiers and to the plane, so a product composed from catalogued components inherits its controls instead of negotiating them. If a tier can be composed without the plane, the firm gets a working product with controls negotiated separately each time.
One name, two positions. Integration and interoperability is both an anatomy tier (where a component lives) and a pattern family (how a capability is built). The classification line records the anatomy tier and the pattern family as separate fields so the ambiguity never bites.
Do not confuse the product portfolio with the anatomy
Two layered pictures appear in the factory, and confusing them is, per Book 2, the most common error when importing outside architecture material.
| Six-layer product portfolio (Book 2 Ch 6) | Application anatomy (Book 2 Ch 22) | |
|---|---|---|
| Question | What does the factory ship, in what order, funded how? | What is one AI application made of, and which controls attach where? |
| Unit | The factory’s estate | A single product |
| Used to decide | What to fund and who owns it | What not to build |
| Layers | 0 chassis · 1 AI primitives · 2 capability services · 2.5 experience layer · 3 horizontal workflows · 4 domain products | L0–L5 and the plane X |
A research copilot occupies one row of the portfolio (Layer 4) and has every tier of the anatomy. Portfolio Layers 0 to 2.5 are platform-funded roots; Layers 3 and 4 are product-funded and carry business cases (application foundation).

The factory’s six-layer product portfolio. Source: The AI Delivery Factory, Chapter 6, Figure 6.2.
Where the portfolio supplies each tier
The crosswalk below is Book 2’s (Ch 6 §4; the author labels the mapping his own). Use it in review to find the portfolio product that should cover a tier before a squad builds its own.
| Anatomy tier | Where the portfolio supplies it |
|---|---|
| Infrastructure and hosting | Layer 0: paved-road infrastructure, infrastructure module library |
| Data and knowledge | Layer 0 classification services; Layer 1 document ingestion and entitlement-aware retrieval store; Layer 2 retrieval-augmented generation service |
| Models | Layer 1: model gateway and the models behind it |
| Reasoning and orchestration | Layer 1 prompt registry; Layer 2 agent runtime and structured extraction |
| Integration and interoperability | Layer 0 API conventions; the tool broker beside the Layer 2 agent runtime |
| Experience and channels | Layer 2 UI component library and human-review console; Layer 2.5 portal platform and web pattern |
| Trust and operations plane | Layer 0 identity and telemetry backbone; Layer 1 evaluation harness and gateway policy; Layer 2.5 catalogue |
Read three things from it.
- Layers 3 and 4 do not appear in the right-hand column. They are whole applications with complete anatomies. A well-built one owns only its upper-tier specifics — prompts, workflow, evaluation cases, screens — and inherits the rest by reference.
- No portfolio row is labelled “governance”. The plane’s services are spread across Layers 0 to 2.5.
- A private copy of a portfolio-supplied tier is duplication. A Layer 4 product with its own model gateway, retrieval store or evaluation set is, in Book 2’s phrase, the “fourth file upload, one tier up”.
Keep five words apart
The anatomy only attaches ownership cleanly if five terms mean one thing each (Book 2 Ch 22 §4.5; definitions in the glossary). Book 2 names the owners of the model, agent and tool; the owners shown for the vendor and the AI system are this page’s recommendation.
| Term | What it does | Where it sits in the anatomy | Owner |
|---|---|---|---|
| Model | Computes; stateless, no tools, cannot act | Models tier | Platform model team; model catalogue and usage registry |
| Agent | Decides and acts inside an envelope | Reasoning and orchestration, with an identity on the plane | Named wrangler |
| Tool | Executes deterministic code with real permissions, classified by effect (read-only, draft, reversible write, irreversible action) | Integration and interoperability | Owner of the system behind it |
| Vendor | Supplies; the model developer and host may be different parties | Outside the anatomy; recorded in third-party registers | Procurement and third-party risk |
| AI system | The whole product around the model | All tiers plus the plane | Product owner; the unit put into production and regulated |
Run the anatomy review
Before review — count what the squad poured (Book 2 Ch 6 §7). For each tier, ask whether the squad inherited it from the portfolio or built it privately. Every private gateway, retrieval store or evaluation set needs a reason in the design record, or becomes a contribution back to the catalogue.
For each tier, record:
- The selected component, its catalogue identifier (or “new”) and its owner.
- The interface and identity used at the boundary.
- Data classes, entitlements and retention constraints.
- Policy checks and the evidence they leave on the plane.
- Evaluation and failure behaviour.
- Version, lifecycle and replacement path.
These rows feed design record fields 4 (patterns per tier) and 5 (assets reused and proposed) on choose the AI product shape, and the BOM on BOM and recipes.
Then review the seams. A model may evaluate well while its retrieval layer crosses entitlements. A tool may be authorised while the agent identity is not attributable to a person. A safe runtime may still send sensitive context to an unapproved endpoint. Walk one request end to end and test each control where it executes, not where it is documented. For class 3 and 4 designs, the cut-set review on the shape page names the plane each control sits on; controls that share a tier and a plane are rarely independent.
Acceptance checks.
- Every tier has a named component and owner, or an explicit “not used”.
- Every tier covered by a portfolio product uses it, or the design record states why not.
- Every boundary names the identity used and the policy check that executes there.
- One end-to-end request has been walked and each plane control observed producing evidence.
Failure modes
| Failure | How to recognise it | Recovery |
|---|---|---|
| Portfolio and anatomy conflated | Funding arguments in a design review, or tier questions in a funding review | Use the portfolio to fund, the anatomy to design |
| Importing someone else’s stack whole (Book 2 Ch 22 §8) | Two people use “layer 3” for different things and neither notices | Translate imported material at the door; hold the mapping centrally |
| The plane drawn as a tier | A “governance layer” team owning controls that never execute in the other tiers | Attach each control to the tier where it runs and to its plane |
| Private tiers | Repeated private gateways, stores or evaluation sets across products | Count per tier at review; route to the portfolio owner |
What this model does not decide
The anatomy is a design checklist, not a deployment topology or a compliance conclusion. It does not prescribe a cloud, model, vector store or agent framework. Hosting route, risk tier and permitted data use depend on the workload and the institution’s own policy and obligations; resolve them through choose the AI product shape and the relevant build guides.
Source status. The tier model is the author’s design proposal, presented in Research Paper 1 as a reading of the convergent published reference architectures. The “what the factory already supplies” column is from Book 2 Ch 22; the portfolio crosswalk is from Book 2 Ch 6, where the author labels it his own mapping.
Source material
- Book 2 (The AI Delivery Factory), Chapter 22, The Shape of an AI Product (§4.1 application anatomy; §4.5 five words; §8 importing someone else's stack)
- Book 2 (The AI Delivery Factory), Chapter 6, The Standard Application Foundation (§4 six-layer product portfolio; portfolio-to-anatomy table; §7 tier count)
- Book 1 (Building Organizations for the Age of AI), Chapter 11, The Enterprise Agent Control Plane
- Research Paper 1, A Taxonomy for a Reuse-Driven AI Factory (§4.1 Axis 1: layers)
Related research
Related guidance
-
The AI Delivery Factory: Operating ModelThe factory's six connected parts, the control gap it closes, the handover curve that governs what agents may take over, and how to start one without rebuilding your tooling. -
The Enterprise Agent Control PlaneThe firm-owned services that make every agent action identifiable, decidable, approvable and reconstructable: the ownership boundary, six planes and their contracts, the Policy Decision API with its latency budget, the persistence schema, the build sequence and the tests that show it works. -
Choose the Shape of an AI ProductA least-agency decision sequence for choosing a product design: agency classes and their trade-offs, the eight questions, evidence for every step up, the consequence matrix that caps action scope, the cut-set review for agents, the other selection dimensions, and the design record. -
Build a Living Product Bill of Material and RecipeDescribe what an AI product contains and how the firm builds it in one versioned specification shared by pipelines, agents and assurance teams, including the classification line, readiness grades and reuse generations. -
Build the Standard Application FoundationRun the shared identity, telemetry, deployment, data and AI capabilities as a funded product that humans and agents both start from, with a contract, evidence-computed trust, a cheap promotion boundary and reuse measured by consumption. -
Design and Operate the Model GatewayBuild the model gateway as the governed edge for every model call: per-client identity, per-request highest-class routing, tokenisation, pinned models, a conformant wire contract, a correlated evidence record, a tested concentration answer, and day-two cost, latency and reliability operations across two estates and three meters. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer. -
The Ten AI Product Recipe FamiliesThe ten recipe families and their design cards (flow, action scope, data classes, controls, evidence, evaluation, anti-patterns), how to fit a request and choose between neighbours, the pattern catalogue beneath them, the human duties each recipe must staff, who governs the catalogue, and the pipeline checks that catch family drift, families of one and orphans.