The CAE Stack: Ten Layers, and the Construct That Governs Each One
The stack diagrams that circulate for AI engineering list models, frameworks and vector databases. None has a row for authority, evidence or the point where a proposal becomes an effect. This is the same stack drawn from the enterprise's side.
Written as at 30 September 2026.
agentic-aienterprise-architecturereference-architecturedeterministic-shelltooling
You have probably seen the picture. Eight rounded rows on a white ground: LLMs, frameworks, vector databases, data ingestion, observability, deployment, evaluation, prompt engineering. Forty logos. It circulates every few months under a title like “The AI Engineer’s Stack”, and it is a fair map of the tools a developer reaches for when building something that answers questions.
It has no row for who is asking. It has no row for what the system is allowed to change, or on whose authority. It has no row for the moment a proposal becomes a payment, a credential reset or a firewall rule, and no row for what you hand an auditor fourteen months later. Those are not omissions of taste. They are the difference between a stack for assistance and a stack for agency, and an enterprise that adopts the first picture as its architecture will discover the missing rows at its first incident.
Figure 1 is the same stack drawn from the enterprise’s side. You can build your own version of it, against what you actually run, in the stack builder.
What changes when you draw it from the enterprise’s side
Two things.
The first is the set of rows. The developer’s picture is organised by tool category. The enterprise picture is organised by the ten layers a production agent system actually has: eight on the request path, from the channel that starts the run (L1) to the systems of record it finally touches (L8), and two that cut across all of them, observability and evaluation (X1) and security and governance (X2). Each layer has an owner. Most incidents in multi-agent systems begin at a boundary between two layers whose ownership was never settled, which is why the rows matter more than the logos inside them.
The second is the right-hand column. Against every layer sits the construct from the book that governs it. The purpose of the column is to make one point visually that the book makes at length: only one row is probabilistic. Models and Inference (L7) is the probabilistic core. It reasons, drafts and proposes. Every other row is part of the deterministic shell, and the shell, not the model, decides identity, authority, schema, state and commitment.
Read down the column and the constructs land on real infrastructure. At L1, the channel is where the principal and the purpose are captured, which every later check depends on. At L2, the gateway is where content is screened and, more importantly, classified as influence rather than authority: a document or an email can shape what the agent proposes; it cannot confer permission. At L3, orchestration holds durable state, and durable state is where continuity is not permission bites, because a workflow that survives an interruption must not inherit the authority it had before it. L4 is where the autonomy staircase becomes concrete, as bounded runs with budgets. L5, context and memory, is where the Context Contract lives, declaring and testing what the model may be shown before it sees a token. L6, the tool gateway, is where the Authority Envelope is enforced and where the Commit Boundary sits, since the typed path to real systems is the only place an action can actually be stopped. L8 is where the Evidence-First Decision Record is written, against versioned evidence and typed claims. X1 carries the Minimum Action-Evidence Bundle and the evaluation-first discipline; X2 is the shell itself: identity, policy and audit across every row.
None of this requires new products. It requires putting the controls in the rows that can enforce them.
The products are illustrative, and the mapping is not
Every product name in Figure 1 is there to show the category, not to recommend a purchase, and the same layer can be filled by an open-source project, a hyperscaler service or something built in-house. That is deliberate, and it is the same rule the Architecture page follows.
The mapping of construct to layer is not illustrative. It is the claim. A Context Contract enforced in a prompt is a request; enforced in L5’s assembly pipeline it is a control that can be tested without the model. An Authority Envelope described in a system message drifts with every model update; enforced at L6 it does not. An evidence record written by the model is an explanation; written at L8 at the Commit Boundary it is a reconstruction. The construct only works in its row.
Which is the real objection to the developer’s picture. Not that it names the wrong tools, but that its rows are the wrong shape for the question an enterprise has to answer: not can it do this, but should it have, and can we show why. The Agentic Stack in Three Planes makes the same point from the other direction, by asking where authority lives; this figure asks where it can be enforced.
Using the figure
Three uses have come up in practice.
As an ownership map, put a team name in every row. Where two rows have the same owner, ask whether the boundary between them is a real one. Where a row has no owner, that is where the incident will begin.
As a gap review, take the right-hand column as a checklist. For each construct, ask where in your current estate it is enforced, in what layer, and whether that layer can actually stop an action. A construct enforced in the wrong layer is the commonest finding. The stack builder does the first pass of this for you and names the missing capability per layer.
As a procurement lens, when a vendor presents a platform, ask which rows it fills natively, which partially, and which it leaves to you. The Architecture page keeps a coverage view of the major platforms on exactly that basis.
The developer’s stack is a good picture of how to build something that answers. This is a picture of how to run something that acts.
References
- The Contextual Agentic Enterprise.
- Model Context Protocol specification. https://modelcontextprotocol.io/specification
- OpenTelemetry. "Semantic conventions for generative AI systems". https://opentelemetry.io/docs/specs/semconv/gen-ai/
Related
The Ten Layers Behind Every Multi-Agent System
A multi-agent demo has three boxes. Production has ten layers, each owning one job and failing in one familiar way. Most incidents start in a layer nobody owned.
Why Enterprise AI Needs a Deterministic Shell
Don't try to make the model deterministic or simply trust it. Let it propose, and put identity, authority, schema, state and commitment in a shell that decides at the Commit Boundary.
The Agentic Stack in Three Planes: Where Authority Actually Lives
The popular AI tool maps list a hundred products in two planes: what the agent knows and what it can do. The plane that decides what it may do is usually missing.
The Commit Boundary: Where AI Recommendations Become Enterprise Consequences
Controls placed at the start of an agent conversation check the wrong thing. The decisive check evaluates the exact action about to become real, at the moment it becomes real.