Enterprise Agentic AI Adoption: Why Contextual and Agentic Have to Arrive Together
Most adoption programmes buy one half of the name. The agentic half without the contextual half is a fast demo that cannot be let near a system of record; the contextual half without the agentic half is knowledge management with a chat window. The two are one requirement, and the reason is in the nature of the machine.
Written as at 30 September 2026.
agentic-aienterprise-aiai-adoptiondeterministic-shellai-governance
Every enterprise adoption report on agentic AI ends the same way: what works, what doesn’t, and how to move forward. This one has a different shape, because the pattern underneath most of the failures is not a maturity gap or a skills gap. It is that organisations adopt one half of the thing, and the two halves do not work in sequence. They only work together.
The name of this book is not a brand. It is the requirement. Agentic is what the machine can now do: propose an action and, if allowed, take it. Contextual is what the enterprise has to supply for that to be safe: what the machine may know, what it may change, on whose authority, and what it must leave behind as evidence. Adoption programmes tend to buy one and defer the other, and both orders fail.
What doesn’t work, in two directions
The first failure is agentic without contextual. It is the demo loop: a capable model, a tool-use runtime, an integration to the ticketing system or the pipeline, and a prompt that describes the rules. It is fast and it is impressive, and it cannot be let near a system of record, because every control it has is a sentence the model was asked to obey. The programme stalls at the first consequential action, the release meeting turns into a change advisory board, and the organisation concludes that agents are not ready. They were ready. The shell was missing.
The second failure is contextual without agentic. It is the knowledge programme: a retrieval layer over the document estate, a chat window, a taxonomy project, an information-governance workstream that runs for a year. Everything the agent would need to know is being assembled, and nothing acts. The business sees a search engine with better manners, the sponsors see cost with no outcome, and the organisation concludes that the value is not there. The value was there. It needed an actor.
Both failures produce the same sentence in the board paper: we are not seeing the return. They have opposite causes.
Why the halves cannot be sequenced
The reason is not organisational. It is in the nature of the machine.
A language model is probabilistic. That is not a defect to be engineered away; it is the source of its value. It handles the case nobody wrote a rule for, and it does so by proposing, not by knowing. A perfectly repeatable wrong answer would still be wrong, and a model constrained until it is deterministic is a model that can no longer do the work you bought it for.
An enterprise system of record is deterministic. It has to be. Identity, authority, schema, state and the moment of commitment are not things an organisation can afford to have re-derived, plausibly, on every request. They are decided once and enforced every time.
Put those two facts together and the adoption problem stops looking like a roadmap and starts looking like an architecture. The probabilistic thing needs a deterministic thing around it before it can touch anything real, and the deterministic thing has no reason to exist until there is a probabilistic thing inside it. A shell with no core is a governance project. A core with no shell is a demo. Neither is the enterprise agent. The two arrive together or not at all, which is why the book’s central construct is a shell around a core rather than a phase before one.
That also answers the question every programme asks in its second quarter: which do we build first? The answer is that you build the smallest of both. One decision, one agent, one Context Contract that says what it may see, one Authority Envelope that says what it may change, one Commit Boundary where the proposal becomes an effect, one evidence record written there. Then widen. The staircase is climbed with both feet.
What works
The programmes that get past the second quarter share a shape, and it is not the shape of a platform purchase.
They start with a decision, not a use case. Not “customer service” but “goodwill credits up to a limit, for these customers, on this evidence.” A decision has a principal, a scope and a consequence, which is exactly what a Context Contract and an Authority Envelope need to be written against. A use case has none of those, which is why use-case programmes generate demos.
They put the controls in the layers that can enforce them. Screening at the edge, the Context Contract in context assembly, the Authority Envelope at the tool gateway, the evidence record in the system of record, evaluation before code. Not in the prompt. A control in the prompt drifts with every model update; a control in the shell does not. The CAE Stack is the map of where each one lives.
They measure per successful outcome, not per token or per seat, because that is the only unit that makes the shell’s cost visible as an investment rather than an overhead, and the only one the board can compare with doing the work by hand.
They keep a human at the gates, not in the loop. “In the loop” means a person reviewing everything, which is the traditional lifecycle with a chatbot attached. “At the gates” means a person holding authority at the Commit Boundary for consequential change, with the deterministic checks doing the rest. That is what lets the governed loop be as fast as the demo loop.
And they treat evidence as a product of the system, not an afterthought of the audit. The question that will be asked fourteen months later, why did it act?, is answered at the moment of action or not at all.
How to move forward
Pick the smallest consequential decision an agent could take in your estate and write down four things for it: what it may see, what it may change, who delegated that, and what record exists afterwards. If any of the four is hard to write, that is the adoption programme, and it is neither a model selection nor a taxonomy project. It is a shell, and the model is the reason to build it.
The frameworks the industry already has, the NIST AI Risk Management Framework, the OWASP guidance for agentic applications, describe the risks well and the mitigations generously. What they leave to you is the question between them: not can it act but should it have, and can you show why. That question is answered by supplying context to a machine that acts. Contextual, and agentic. At the same time.
References
- The Contextual Agentic Enterprise.
- National Institute of Standards and Technology (2023) AI Risk Management Framework (AI RMF 1.0). https://www.nist.gov/itl/ai-risk-management-framework
- OWASP GenAI Security Project (2025) Securing Agentic Applications Guide 1.0. https://genai.owasp.org/
Related
Better Models Won't Fix the Enterprise: Why Context Must Come Before Autonomy
Most enterprise AI programmes begin with a model question. The question that decides whether the initiative becomes useful and trusted is what the system is allowed to know, decide and do — and how anyone will prove it acted appropriately.
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.
From Assistance to Agency: Why Enterprise AI Creates a New Architectural Problem
Letting a service desk assistant reset MFA is not phase two of the same programme. Once an agent can change state, the question becomes what it may change, and on whose authority.
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.