Executive summary
The context your AI depends on should not belong to any AI vendor. Enterprises are making multi-year commitments to AI platforms that change every few months. The tool that was clearly best in 2025 is not necessarily best today, and the value per dollar keeps moving.
What stays constant is what every one of those tools needs: an accurate account of what the organization runs, how it connects, what versions it is on, who owns it, and which standards apply. When that context is built inside one vendor’s platform, it starts to favor that vendor. Trying anything else means rebuilding it first.
This paper argues for a platform-neutral context layer: one live, reconciled model of the technology estate, served to every agent the organization chooses and to the people who run its systems. It covers what such a layer contains, what lock-in costs, why several platforms will coexist, how a context layer differs from an integration layer, why agents should not assemble context on their own, and how to evaluate one.
Key findings
- The market is too dynamic to lock into. Leading AI tools change every few months, and so does the value they deliver for what they cost.
- Context built inside one platform takes that platform’s side. Moving to, or even piloting, another tool means rebuilding the tooling and data first.
- Coexistence is the realistic operating model. Productivity assistants, coding agents, and custom process agents are different products. Large enterprises will run all of them, and all of them need the same context.
- A context layer is not an integration layer. Its value is in normalizing many sources into one model, reconciling sources that disagree, and keeping the source of every fact.
- Agents that gather their own context pay a tax on every call: wasted tokens, answers that drift from run to run, and delays that time-sensitive work cannot absorb. One customer’s incident response agent needed about 18 minutes to assemble context before it could start.
- The same context has to serve people. In the October 2026 PHP emergency, organizations that already knew where PHP ran could act before vulnerability details were public (DevGrid, Oct 2026).
Recommendations
CIOs and the leaders who own AI, engineering, and infrastructure should:
- Treat enterprise context as infrastructure. It will outlive any one AI platform. Keep it out of any single vendor’s proprietary tooling.
- Plan for several platforms at once. Require that each can consume the same context through open interfaces such as MCP and APIs.
- Price the exit before you sign. For every major platform commitment, estimate what it would cost to move the tooling and data built around it.
- Evaluate context layers on reconciliation and provenance, not on connector counts.
- Measure time-to-context. Know how long your agents spend assembling context before time-sensitive work such as incident response, and set a target.
- Make the context readable by people and by agents. People need to verify what agents are told. Every use case, from incident response to audit and architecture review, should draw on the same context, for people and agents alike.
1. What a context layer is
A context layer is a live, reconciled model of the organization’s technology estate, maintained once and served to every consumer that needs it. It sits between the systems that hold fragments of the truth and the people and agents who act on it.
It holds two kinds of knowledge:
- Context: what is true. Applications and the components and repositories behind them. What each depends on and talks to. The technologies and versions they run, and when those reach end of life. Known vulnerabilities. Who owns what. Recent changes and incidents.
- Instruction: what is expected. The organization’s architecture decisions, standards, policies, and non-functional requirements that apply to a given system or task.
An agent with context but no instruction does the wrong thing correctly. An agent with instruction but no context does the right thing to the wrong system.
A context layer serves both from one place.
The layer draws from the systems the organization already runs: source control, CI/CD, cloud platforms, security and vulnerability scanners, IT asset management, incident tools, and the CMDB. Alongside the organization’s own data, it adds reference data that is not specific to any customer and that the provider maintains, such as a catalog of common technologies with their versions, release dates, and end-of-life dates, and vulnerability advisories (CVE and GHSA records).
It then serves the same model two ways. Agents reach it through MCP and APIs, scoped to the task in front of them. People reach it through dashboards, reports, and plain-language questions. One graph, two consumers.

Swapping or adding an agent changes only the right-hand side; the sources and the reconciled model underneath stay put.
2. A market too dynamic to lock into
It is still early in enterprise AI, and no organization can safely pick a single tool for the whole stack. Platforms ship meaningful changes every few months. A coding agent that was clearly the best choice in 2025 is not necessarily the best choice now. The value an organization gets for what it pays is shifting just as fast, and there is little reason to expect the next year or two to be calmer.
That gives a CIO one firm constraint: no single harness provider or platform should own the entire stack. Something underneath still has to stay stable. Its job is to bring the organization’s data together, steadily and carefully, so that whichever tools win can use it. Chasing every new development in AI is somebody else’s job.
That stable foundation is the context layer. The platforms on top can change. The organization’s knowledge of itself should not have to change with them.
3. When context lives inside one platform, it takes that platform’s side
We are already seeing this play out. An enterprise makes a large purchase from one AI vendor, commits to its ecosystem, and builds tooling and data around it. That works until the platform stops being the most cost-effective option, or stops being meaningfully different from the alternatives. Then the organization has to rebuild the tooling around the agent before it can use anything else. The investment meant to accelerate it has made it more dependent.
Context built into one vendor’s platform is biased toward that vendor. Other ways of using AI, from other vendors or built in-house, cannot draw on it without being rebuilt. The first casualty is the ability to experiment.
A team standardized on one coding agent hears that another vendor has shipped something better. Or it wants to run Microsoft Copilot or GitHub Copilot alongside its current tool. Either way, it has to rebuild its tooling before it can run a fair trial. An abstracted tooling layer that is agent- and harness-agnostic removes that step: the new tool connects to the same context on day one.
With a neutral context layer, the organization does not face an all-or-nothing cutover. It can stand up the alternative, pilot it immediately, and move teams over gradually. Or it can run both: the premium platform for the hardest problems, the cheaper one for day-to-day work.
4. Coexistence is the operating model
If organizations want agents to do a meaningful share of their work, one agent platform will not be enough. Different platforms are built for different jobs:
| Form factor | Example | Typical work |
|---|---|---|
| Productivity assistant | Microsoft Copilot in Office, Claude, GPT | Documents, email, meetings, everyday knowledge work |
| Coding agent | Claude Code, Cursor, GitHub Copilot | Writing, reviewing, and upgrading code |
| Custom business process agent | Built on LangChain, Amazon Bedrock AgentCore, or Microsoft Foundry | Incident response, operations, domain workflows |
Large enterprises will run all of these. Some workloads justify the most capable and most expensive platform; most day-to-day work does not.
Coexistence can sound like hedging. In practice it is simply how the work divides. Every one of these form factors needs the same thing: accurate data about the organization’s own systems and the tooling to reach it. A platform-neutral context layer is how they all get it without each team building its own copy.
5. A context layer is not an integration layer
An integration layer moves data between systems. A context layer turns that data into a consistent, opinionated model built to be consumed by agents and by people. The intelligence sits inside the pipes: each integration synthesizes what its source reports, and the layer compiles the results into one answer.
Take a common question: what technology does this application or server run? A context layer combines what is found in the code, what the scanner on the server reports, and what the vulnerability scanners and asset management tools see. It returns each technology with its version and its end-of-life date. No single source could answer that alone.
Three properties separate a context layer from plumbing.
Normalization: opinionated, not biased
The model is opinionated in one specific sense. It takes unstructured, implicit data and makes it structured and explicit. That is the value it adds, and it contains no preference for any agent, model, or AI vendor.
Provenance travels with the synthesis
Synthesized data is only useful if people can trust it, so every fact needs to show where it came from. Even after synthesis, it should be clear which system originally reported each fact. Data should never float without a source.
Provenance also settles who fixes an error. If the error is in reference data the provider maintains, the provider corrects it. If it comes from the customer’s own systems, such as an incorrect ServiceNow record, the customer’s administrators correct it at the source. Feedback loops let users flag problems and get them fixed.
Reconciliation: when sources disagree
Sources disagree constantly. A cloud platform, the CMDB, and an asset management scanner can each describe the same machine differently: one says decommissioned, one says active, one says inactive. The context layer has to help the organization settle it.
The practical approach is to pick a default automatically and let people override it. The default should favor ground truth over derivative records. If the CMDB says a server is decommissioned but AWS reports it running, AWS is right. A record of what should exist does not outrank live evidence of what does.
The CMDB remains the system of record. The aim is not to replace it but to marry it with the other systems that hold part of the picture, so the combined view is accurate and the system of record can be kept that way.
6. Why agents should not gather their own context
The most common objection to a context layer is that agents are now smart enough to connect to every API and MCP server and fetch whatever they need. They can. But an agent that reconstructs the organization’s systems on every task pays a context-fetch tax every time it runs.
| Cost | What happens | Why it matters |
|---|---|---|
| Tokens | The agent rereads the same repositories, tickets, and scanner output on every task | Spend grows with usage, for information that rarely changed |
| Drift | Synthesis done on the fly differs from run to run | Two runs against the same sources can return different answers, which is hard to trust or audit |
| Latency | The agent must research before it can act | Time-sensitive work, such as incident response, cannot wait |
The difference is easiest to see on a single request for context:
| One context request (illustrative) | Agent gathers its own | Served by a context layer |
|---|---|---|
| Time before the agent can act | ~42 seconds | ~1.2 seconds |
| Tokens spent assembling context | ~18,200 | ~1,400 |
| Same answer on every run | Not guaranteed | Yes |
Illustrative example; figures will vary by environment and task.
Latency is the most visible of the three. One DevGrid customer built an internal incident response agent. Given a problem, it took about 18 minutes to gather the context it needed before it could begin work. For incident response, where the point is to understand the situation fast, that is not acceptable. The customer is now moving that agent onto DevGrid’s MCP server.
Ungrounded agents are slow and inconsistent for the same reason: they start from scratch every time. With a context layer in the middle, the information an agent needs (the system, what it talks to, its code, its technology, its owners, and the standards that apply) is already compiled. It is a couple of tool calls away rather than a research project at the start of every task.
What can be deterministic, should be deterministic
With capable agents available, it is tempting to hand them everything. We think that is a mistake. Much of the work of building context has one correct answer: pulling records from a cloud API, mapping fields into a model, matching a server across three systems, applying a precedence rule. Traditional ETL and explicit logic produce that answer the same way every time, quickly and at a fraction of the cost.
Models earn their place where judgment is needed: interpreting unstructured documentation, inferring relationships no system records, explaining findings to a person. Even then, that work belongs upstream. It should run once, with its result stored and its source kept, not repeat in every agent session.
Our rule of thumb: what can be deterministic should be. An agent that re-derives fixed facts at runtime pays in tokens, time, and consistency for an answer a pipeline could have computed once. Deterministic logic is also easier to trust. A rule can be inspected and corrected; a chain of reasoning that differs on every run cannot.
7. Not only for agents: what the PHP emergency showed
A context layer that exists only inside AI systems forces every answer through an agent. Some of the most important moments are the ones where people need the answer directly, on a screen, right now.
The October 2026 PHP emergency is an example. On 20 October, the PHP project warned that an emergency security release was coming for two critical vulnerabilities, before technical details were public (PCWorld). Security scanners had nothing to match against yet. Organizations that already kept a current graph of which applications and servers ran which technology could still act. They could start a threat exposure analysis, take some systems offline, add firewall rules, and add monitoring before they knew the exact nature of the flaw.
As DevGrid described in its paper on the incident, a top 25 bank answered the first question of its response, where it ran PHP, with a small number of lookups. The alternative carries a cost of its own. As one security vendor put it, under DORA and the SEC’s disclosure rule, “we did not know we were running PHP” will be read as an admission (Orca Security).
This is a classic human use case: someone looks at a screen and drives action from it. Agents are becoming more capable every day, and the same graph should serve them too. But it has to be available to people without an agent in between.
Readable by people and agents
Human readability matters outside emergencies, too. It is how the organization checks its agents. When an agent acts on the context layer, a person should be able to open the same record, see the same facts and where each came from, and confirm or correct them. Context that only an agent can read can only be checked by another agent.
It also serves work that no agent owns. Audit and exam preparation, architecture review, ownership questions, and modernization planning all start with a person asking a question. When people and agents read the same model, their answers agree. When each has its own copy, they drift apart, and nobody can tell which one is right.
A place in the defensive stack
Many bank CIOs are focused on vulnerability risk after Anthropic announced Claude Mythos Preview in April 2026. Anthropic reported the model had already found thousands of high-severity vulnerabilities, including in every major operating system and web browser (Anthropic, Project Glasswing). Their question is how to protect the organization when vulnerabilities and attacks arrive at machine speed.
A context layer is not, strictly speaking, a security product. But knowing where every piece is on the board is part of any defense. A reconnaissance satellite is not part of the unit on the ground, yet that unit depends on what it sees. An organization’s knowledge of its own estate belongs in its defensive stack, whether or not the security team owns it.
Security teams already rely on CMDB data. A context layer improves on that by letting the organization know about itself faster, and with the source of every fact attached.
8. Build, buy, and the cost of a side quest
The strongest objection to a dedicated context layer is that the organization would rather commit fully to one platform, or build the layer itself. With AI-assisted coding, building looks easy. There are also legitimate reasons behind the instinct, such as sovereign AI requirements.
The prototype is not the hard part. A capable team can probably stand one up in about a month. The hard part is hardening it and running it: maintaining the integrations, the ETL, the reconciliation logic, and the background agents across every source system as those systems change. AI has made writing code simpler. It has not made running software inside major workflows or business-critical systems cheap or easy. A fair comparison weighs years of that upkeep, not the cost of the first version. It should also weigh the opportunity cost. The engineers who could build and run this layer well are usually the ones the organization most needs on its own products and AI initiatives. Is this where they should be focused?
The target also keeps moving. Internal builds are usually planned as a one-time project, with a maintenance budget afterward. This space does not stand still long enough for that. New agent platforms and protocols arrive every few months, source systems change, and agents keep needing new kinds of context. A context layer has to keep evolving, not just keep running. That makes it a permanent commitment.
Building in-house makes the most sense in three cases: when good commercial options are extremely expensive, when they carry far more than the organization needs, or when the build creates something proprietary the organization can turn into an advantage. None of these usually applies to a context layer. In most respects, no enterprise’s engineering estate is unique. Advantage comes from what the organization does with that context. The plumbing that maps the estate rarely provides any. The problem deserves people who work on it full time, not a side quest competing with everything else on the roadmap.
Speed to value matters as much as cost. A commercial context layer arrives with integrations that are already built and maintained across many customers. Connecting sources takes a few clicks, the initial graph can be built within hours to days depending on the size of the estate, and it is maintained continuously from then on.
9. What neutrality should mean
Neutrality does not mean having no structure. Every context layer has a point of view built into its data model, and it should: turning implicit data into explicit structure is the job. Neutrality means something narrower and more useful.
A neutral context layer is not trying to sell the customer its own agents, its own models, or its own token consumption. It exists to make every agent the organization chooses more effective, not to become another agent competing for the work. It is an AI enablement platform, not an AI platform or an agent platform.
That distinction matters to buyers who are being offered agents from every direction. The context layer should be the one part of the AI stack that does not care which agent wins. A simple test for any provider: does its revenue grow when you use more of its own agents and models, or when every agent you run gets better?
Evaluating a context layer: a CIO checklist
Use these criteria to compare options, including an in-house build. Each one follows from an argument in this paper.
| Criterion | What to ask | What good looks like |
|---|---|---|
| Platform neutrality | Which agents and harnesses can consume it? Does the provider sell its own agents or models? | Open interfaces (MCP, API); no stake in which agent you use |
| Normalization | Does it return one model, or a pile of connector output? | Technologies, versions, dependencies, and owners resolved into one consistent model |
| Reconciliation | What happens when the CMDB, cloud, and asset tools disagree? | An automatic default that favors live evidence, with human override |
| Provenance | Can you see which system reported each fact? | Every fact traceable to its source, even after synthesis |
| Correction path | Who fixes a wrong fact, and how? | Provider fixes its reference data; your admins fix source records; feedback loops close the gap |
| Context and instruction | Does it serve standards, decisions, and requirements alongside system state? | Both, scoped to the system or task at hand |
| Human access | Can responders get answers without an agent? | Dashboards, reports, and plain-language questions over the same graph |
| Time to context | How long does an agent take to get what it needs? | A couple of tool calls, not minutes of research |
| Time to value | How long from connection to a usable graph? | Days or less, with integrations maintained by the provider |
| Coexistence with the CMDB | Does it replace your system of record? | Works alongside it and helps keep it accurate |
Questions for leadership teams
- If you moved a major AI workload to a different platform next quarter, what tooling and data would have to be rebuilt?
- Which of your AI platforms can consume your organization’s context today, and which cannot?
- How long do your agents take to gather context before time-sensitive work such as incident response?
- When your cloud platforms, CMDB, and asset tools disagree about a system, which one wins, and can you see why?
- Could your incident responders find every system running a given technology without going through an agent?
About DevGrid
DevGrid is an AI enablement platform, not an agent platform. It builds and maintains one live, reconciled graph of an organization’s technology estate and serves it to two consumers: the people who run the organization’s systems and any agent the organization chooses. It connects to source control, CI/CD, cloud platforms, security scanners, IT asset management tools, and ServiceNow. It reconciles them into a single model with the source of every fact preserved, and ties technology, version, end-of-life, and ownership data to each application. Agents reach it through MCP and APIs; people reach it through dashboards and reports. DevGrid is delivered as SaaS and can connect securely to systems that run on-premises. It is in production at a top 25 US bank. The CMDB remains the system of record; DevGrid helps keep it accurate.
To see what a platform-neutral context layer looks like for your own estate, request a demo.
Sources
- DevGrid, “Where Are We Exposed, and Who Owns It? Lessons from the October 2026 PHP emergency” (23 Oct 2026).
- Anthropic, “Project Glasswing” (7 Apr 2026).
- PCWorld, “AI helped uncover a security nightmare in the web’s backbone” (Oct 2026).
- Orca Security, “The week the web’s plumbing failed” (Oct 2026).
This publication contains general information only and is current as of its publication date. DevGrid is not, by means of this publication, rendering professional advice, and this publication should not be used as a substitute for such advice.
© 2026 DevGrid. All rights reserved. Product and company names mentioned herein may be the trademarks of their respective owners.