Everyone is building a context layer.
Gartner has named its components. Forrester has proposed a definition and started evaluating the market. SAP has redrawn its architecture around it. Vendors are racing to connect models to knowledge graphs, semantic layers, operational data and institutional memory.
For good reason.
The first generation of enterprise AI generated answers. The next generation is expected to make decisions and execute work.
That changes the architectural requirements.
An AI system that summarises a sales call can survive incomplete context. An AI system that acts on that call, by changing a forecast, triggering a commercial approval or advancing an opportunity, cannot.
The difference isn’t model intelligence.
It’s whether the system understands the business it is operating in.
And the industry is about to make an architectural mistake.
We are treating the ability to access context as if it were the same as being architected around context.
They are not the same thing. The difference decides which enterprise AI systems scale.
1. Context Is Not Something You Retrieve. It’s Something You Operate Within.
For decades, enterprise software organised information around applications.
The CRM owned customer records. ERP owned financial transactions. Marketing automation owned campaigns. Knowledge management owned documentation.
Each application held its own representation of the business.
Humans were the connective tissue. An experienced operator moved between systems, reconciled contradictions, interpreted exceptions and decided what happened next. The business depended on that person to reconstruct context.
Now we are asking AI agents to do the same work.
The first response has been to connect everything. Give the agent the CRM. Connect the warehouse. Index the documents. Expose the APIs. Add retrieval.
But access isn’t understanding.
Take an opportunity marked Commit in Salesforce.
The CRM holds the stage. The call transcript holds the conversation. The contract repository holds the agreement. The approval system holds the commercial constraints.
An agent can retrieve every one of those records and still not know whether the deal belongs in Commit. The answer depends on something else: the customer’s procurement behaviour, an exception
to the standard approval path, a decision made three weeks ago, the judgement of a sales leader who has seen this pattern before.
Context is not the collection of available information. It is the meaning of that information inside a particular operating reality.
And that reality keeps changing.
2. Context-Aware AI Still Inherits an Application-Centric Architecture
Most enterprise AI is context-aware by design.
An agent receives a task. The system retrieves relevant information. That information is assembled into a context window. The model reasons over it, then answers or calls a tool.
For many jobs this works well.
But the architecture has one structural limit: context is assembled for the interaction, not maintained as a shared representation of the business.
That limit shows up the moment several agents have to coordinate decisions across functions and over time.
One agent retrieves the customer record. Another retrieves the qualification criteria. A third retrieves the latest conversation. Each gets a different slice of information, applies different assumptions and reaches a locally reasonable conclusion.
Nothing guarantees they are working from the same understanding of the business.
The problem isn’t hallucination. It’s architectural fragmentation.
We have recreated the enterprise application silo inside the AI layer.
Only now, instead of humans reconciling the inconsistencies, we expect probabilistic systems to do it. When they fail, we add more prompts, more retrieval, more rules and more orchestration.
Each fix rebuilds, at runtime, the shared context the architecture never kept.
3. Everyone Agrees on the Parts. Nobody Has Defined the Building.
The industry has converged on what a
context layer contains.
Gartner names three components: semantics,
operational state and provenance (Gartner, March 2026). Forrester’s proposed definition adds ontological modelling, policies and processes, and runtime events, decisions, actions and outcomes, forming what it calls a living model of the enterprise (Forrester, August 2026). SAP describes its foundation layer as moving from a system of record to a system of context (SAP, June 2026).
The vocabulary has multiplied faster than the agreement. One count found six new terms for the same idea in fourteen months: context engineering, context database, context graph, context mesh,
context layer and AI context platform (Fluree).
All of them define context by its contents.
A list of contents is an inventory, not an architecture. A warehouse holding every part of a building is not a building.
Compressed, the three components become three things the system must hold:
Context = meaning + state + authority
Meaning is what the business’s concepts are: what a Commit is, what counts as an exception. State is what is true right now. Authority is who may decide what, under which policy, on which precedent. Provenance belongs here, because provenance is how authority is proven after the fact.
A context-aware system assembles meaning, state and authority for each request, then lets them dissolve when the request ends.
A context-native system maintains them as one representation that every agent reads from and writes back to, and keeps that representation intact as work moves through it.
One representation does not mean one database, or even one ontology. State can live in a dozen systems: federated, event-sourced, owned by separate domains, each with its own model. What has to
be coherent is what crosses the boundaries. When Sales and Finance both say “customer”, that concept must resolve to one authoritative meaning, and every write must resolve against one authority model.
The difference doesn’t show at the moment of retrieval. Both systems can look identical when an agent asks a question. It shows at the moment of hand-off: when context passes from one agent to another,
from reasoning into action, from action into memory, and from one version of the business to the next.
That is the definition. Context-native doesn’t require one ontology everywhere. It requires continuity wherever context crosses a hand-off: of meaning, of authority, and of the record of what changed.
Continuity is not constancy. Meaning should change when the business does. What must survive is the line from what was true
to what is true now.
Call that requirement context continuity.
It is a property any system can be measured against. Context-native is the architecture that meets it by construction. A context-aware system can only meet it by rebuilding context at every hand-off.
One question sits upstream of all four hand-offs: who owns meaning?
Forrester’s definition includes ontological modelling. Modelling is not ownership. An ontology is a decision about what the business is, and it has to be made by someone with the authority to make it.
Without an owner, every agent infers its own meaning from whatever it
retrieved, and the system holds as many ontologies as it has agents.
The causal order runs one way: ontology → meaning → state → authority → action.
An architecture that starts at retrieval starts in the middle.
4. The Survival Test
Context-aware systems are judged when they look. Context-native systems are judged when they let go.
There are four hand-offs, and they cross three axes: space (agent to agent, domain to domain), mode (reasoning to action) and time (backward into memory, forward through change). Each has a
characteristic failure, and a test a system either passes or doesn’t.
context-aware vs context-native · four hand-offs around one shared core
The four hand-offs below run clockwise from the top left.
Hand-off 1: Agent to agent
The failure: two agents, two realities. One agent retrieves the opportunity record. Another retrieves the qualification criteria. Each reaches a locally reasonable conclusion from a different slice of the business, and nothing forces the slices to agree.
This is the failure that dominates in practice. An analysis of more than 1,600 execution traces across seven multi-agent frameworks found that failures come mostly from system design and misalignment between agents, not from the limits of the underlying models. Its
authors expect better base models to leave most of these failures in place (Cemri et al., NeurIPS 2025).
A smarter model does not repair a fragmented representation.
The test: give two agents the same deal without telling them how to classify it. Do they reach the same stage, from the same definition of that stage?
Hand-off 2: Interpretation to action
The failure: reasoning under one rule, acting under another. An agent decides an opportunity belongs in Commit. Between that judgement and the write sit an exception route, an approval threshold and a sign-off requirement. A context-aware system checked authority when it retrieved the record. It does not check again when it acts.
Forrester describes the destination as AI orchestrating business capabilities within guardrails, with a context tier taking the place experience APIs used to hold (Forrester, April 2026). A guardrail checked only at the start of a task does not bound the action at the
end of it.
The test: at the moment of action, can the system name the policy version it is acting under, the exception route that applies and whether a human must approve, and does it stop when it can’t?
Hand-off 3: Action back into memory
The failure: the outcome is written, the reason is lost. The forecast changes. The CRM records the new stage. Nothing records why.
Foundation Capital puts the gap precisely: a CRM stores current state, so it knows what an opportunity looks like now, not what it looked like when the decision was made, and by the time the data reaches the warehouse the decision context is gone (Gupta and Garg, December 2025). Their answer is the decision trace: the inputs gathered, the policy evaluated, the exception invoked, the approver and the state written, all captured at the moment of execution. Gartner makes the same demand of provenance: agents must be able to reference past decisions and their results.
A context-aware system logs actions. A context-native system writes precedent.
The test: three weeks later, can a different agent find why the deal moved, under which policy and on whose approval, and use that as precedent rather than reading it as a log line?
Hand-off 4: Across business change
The failure: last quarter’s right answer, applied this quarter. Territories move. Approval rights change. A policy is rewritten on Tuesday. An agent working from Monday’s context makes a decision that was correct on Monday.
The reverse failure is quieter and worse. A bad decision is written back as precedent, and the system learns it.
Surviving change takes two clocks: when a fact was true in the business, and when the system learned it. Temporal knowledge graphs already do this. Zep’s Graphiti engine tracks both timelines
and marks superseded facts invalid rather than deleting them, so the system can answer what is true now and what was true then (Rasmussen et al., 2025).
The test: when an approval right changes on Tuesday, does every agent act on Tuesday’s version, and can you still reconstruct why Monday’s decision was right on Monday?
What the test does
A context-aware system breaks at the first hand-off and gets patched: more prompts, more retrieval, more orchestration, each one rebuilding context the architecture failed to keep.
A context-native system passes all four by construction. It needs no more intelligence than the other system. It needs one representation of the business that survives being used.
The survival test is, in effect, a test of context continuity: four places where it either holds or breaks.
The test also replaces a debate with a measurement. A vendor can claim to be context-native. A buyer can run two agents on the same deal and find out.
5. Context Engineering Becomes ContextOps
Forrester draws a line between two disciplines (Forrester, October 2026).
Context engineering designs and delivers structured, relevant, timely context to AI systems. ContextOps governs, monitors and improves that context across its whole lifecycle: at design time, at runtime and in the updates between.
The second discipline exists because of the fourth hand-off.
An enterprise doesn’t stand still. Sales territories change. Approval rights change. Customer relationships evolve. Products are repositioned. Policies are rewritten. Exceptions become precedents.
Forrester compresses the problem well: data describes reality, knowledge explains it, and context applies knowledge to a specific situation. Application is where things go stale. The context that made a decision right last quarter makes the same decision wrong today.
So a context layer is not an implementation. It is an operating discipline, and its hardest questions are management questions. Which source is authoritative? How are conflicting interpretations resolved? How does the system learn that a policy changed? How
are outcomes written back without bad decisions becoming institutional knowledge?
Ownership of meaning heads that list, and section 3 answered it: meaning has to be owned by someone with the authority to
decide what the business is.
ContextOps runs the system. Ontology decides what the system is running.
An enterprise can have excellent models, sophisticated agents and extensive integrations and still operate on an inaccurate representation of itself.
The failures will look like model failures. They are architectural ones.
The same lesson, from inside the agent
The model builders are reaching the same conclusion from the other direction.
In November 2026, Anthropic’s engineering team published its findings on agent memory: how an agent should keep what it
learns across sessions (Anthropic, November 2026). It read like the survival test, run from inside a single agent.
More memory was not better memory. An earlier model playing Pokémon Red wrote 413 files of detailed records. They went stale, and it spent steps reorganising them. A later model kept about ten files of strategy and tested rules, and went further. Detail without maintenance is not context. It is inventory.
A wrong record became learned behaviour. An incorrect note about a landmark’s location sent the agent off the same one-way ledge three times. Only when the note was corrected against the original transcript did it get past the mountain. That is the reverse failure of the fourth hand-off, at the scale of one agent: a bad record written back as knowledge, and acted on as precedent.
Shared slices lost facts. Owned
structure kept them. When parallel agents wrote
contract terms into one shared table, they preserved 41 of 57 graded facts.
When each contract got its own page with its terms verbatim, they preserved all
57. That is the first hand-off, measured.
Purpose beat rules. Telling stronger models what memory was for worked better than prescribing what to store. A rule to record only failures reduced their gains. Meaning first, then state.
The article’s answer was what it called dreaming: an offline pass in which the agent reviews its own record, corrects what it wrote and reorganises what it knows. That is ContextOps for a single
mind. And its open question is the enterprise question: raw transcripts may be the foundation, with structured representations built on top only if they are carefully maintained, because unmaintained structure accumulates errors.
These are one lab’s engineering findings about its own models, on its own tasks. But they point the same way as everything above. Even inside one agent, context that is assembled and left alone decays. Context that is maintained, against the record and for a purpose,
compounds.
6. The Value Is Not Better Answers. It’s Different Operating Capacity.
What does a context-native architecture make possible?
Not more accurate retrieval. Not another layer of enterprise search. Not a growing population of agents.
It makes business-specific intelligence reusable across decisions, workflows and systems.
In a context-aware implementation, every new use case repeats the same work: assemble the knowledge, integrate the systems, define the rules, validate the behaviour. In a context-native architecture that work is done once and kept, so the next agent inherits it.
The first approach scales the number of implementations. The second scales the organisation’s capacity for autonomous execution.
The survival test tells you which one you have, and each hand-off has a business measure attached:
The fifth measure is the economics of the work itself, and it follows from the other four.
The market consequence
There is likely a market consequence too, in how enterprises buy AI.
A context-aware tool is portable. Its retrieval works against anyone’s data, so switching costs little, and buyers treat it that way: pilots, short terms, opt-outs, then the next vendor.
A context-native system holds meaning, state and authority that exist nowhere else. Removing it means losing the business’s working representation of itself.
Architecture is unlikely to be the only reason buyers rent. Rental behaviour has many causes: models change quickly, returns are unproven, vendors are consolidating, and finance increasingly
releases capital in stages rather than committing it once.
But architecture should be one of the causes, and it makes a testable prediction. Once those other factors are accounted for, systems that hold meaning, state and authority should convert
from rental to commitment more often, stay longer, and be replaced less often than systems that only retrieve.
Buyers can rent either kind. They should find it much harder to leave the second.



