Understanding Context Platforms

Nov 21, 2026
Sriharsha Chintalapani
Sriharsha Chintalapani
Understanding Context Platforms

Every data and AI vendor now says it is your context layer. Your warehouse has one. Your BI tool has one. Your wiki has one. So does your agent framework.

Each is right about its own slice. That is the problem.

Context is not what one tool knows about itself. It is how things connect across tools: this business term means that column, computed by this code, governed by that policy, changed by that decision last Tuesday. A context platform is the one place those connections are kept.

People used to be the context platform

We have been here before. The industry lets every tool keep its own metadata. The warehouse kept schemas. The BI tool kept metrics. The pipeline tool kept lineage. Definitions went to the wiki and decisions went to Slack.

Nothing connected them, so people did. Every team had the analyst who knew which of four revenue tables was the real one, and the engineer who remembered why retries were turned off. They held the chain in their heads. The full knowledge graph for a company was constructed by people bringing their slice of context when they worked together.

Before AI agents, every tool kept its own metadata and people connected it by asking around

A person in that situation asks around if they don’t have the context. An agent doesn't. It takes what it was handed and answers with confidence. Here are some examples:

  • PocketOS, April 2026. A coding agent was given a routine staging task. It found a production credential in an unrelated file and deleted the production database and its backups in nine seconds.
  • A German clinic, May 2026. Its website chatbot gave two managing directors specialist titles that do not exist. The clinic said it had supplied only correct data. A court held it responsible for the chatbot's claims anyway.
  • Air Canada, 2024. Its chatbot told a grieving customer he could claim a bereavement fare after he flew. The airline's own policy page said the opposite. A tribunal ordered Air Canada to pay.

In each case the company knew the right answer. The agent didn't have it, or couldn't tell it from the wrong one.

Look at the dates. Models improved enormously between 2024 and 2026, yet the failures kept coming. The PocketOS agent was running Claude Opus 4.6, a flagship model. In an October 2026 VentureBeat survey, 78% of enterprises running AI agents had traced at least one confident, wrong answer in the past six months to bad business context.

AI agent failures from 2024 to 2026 at Air Canada, Cursor, PocketOS and a German clinic; 78% of enterprises traced a confident, wrong answer to bad business context

A better model reasons better over what it is given. It can't know what it was never given.

OpenAI described this in its own house: 70,000 datasets, 600 petabytes, more than 3,500 internal users, and tables that look alike but mean different things. One includes logged-out users, another doesn't. Finding the right table was the hard part, not writing the SQL.

What is a context platform?

People held the context chain. Agents need it written down, in one place. Our definition:

A context platform is shared infrastructure that connects your data, what the business means by it, and what the organization knows about it. It serves the right, authorized slice of that to people and agents, and keeps it current as things change.

Your data stays in the warehouse. Your docs stay in Drive and Confluence. Your discussions stay in Slack. The platform connects them. It doesn't move them.

What goes into a context platform, and why agents need it

What goes into a context platform: data, quality, semantics, ontologies, documents, code and memory, served to people and agents

  • The data you already have. Schemas, lineage, ownership, usage. This tells an agent what exists, where it came from and who answers for it. You already own this metadata. It is scattered across the tools that produced it.
  • Data quality and observability. Did the data arrive? Is it fresh? Did a quality test fail, or a pipeline break upstream? A person notices a dashboard that looks off. An agent doesn't. It will compute a confident answer from a table that stopped loading at 3 a.m., unless the platform tells it the data is broken and which metrics sit downstream.
  • Semantics. A glossary says what the business means by Customer. A metric says how churn is counted: which population, which window, which exclusions. Without semantics, an agent picks the column whose name sounds right.
  • Ontologies. A glossary defines terms one at a time. An ontology says how they relate: a customer has accounts, an account holds subscriptions, a subscription refers to a product. That is the difference between looking something up and reasoning about it. An agent that knows the structure knows a cancelled subscription is not a lost customer, and a reasoner can derive facts nobody wrote down.
  • What people wrote down. The policy is in Google Drive or SharePoint. The runbook is in Confluence. The plan is in Notion. The decision, and the argument behind it, is in Slack or Teams. Air Canada's refund rule was on a web page the whole time. Most of what a company knows about why never made it into a table.
  • Code. Documents say what should happen. Code says what does happen. OpenAI's agent reads the pipeline code behind a table to learn what the table really contains. And code has a state: in 2012 Knight Capital shipped new trading code to seven of its eight servers. The eighth ran old code, and in 45 minutes the firm lost more than $460 million. Merged is not deployed.
  • Memory. The corrections people make along the way. With memory on, OpenAI's agent answered one test question in under 90 seconds instead of 22 minutes.

Collected is not connected: why a folder of markdown files isn’t a context layer

This is the part most "context layers" skip.

A lot of what is sold as a context layer today is a folder of files. Markdown descriptions of tables, a rules file, some docs, synced into a repo or a vector index and handed to the agent as text. It beats having nothing, and it demos well.

But a file only knows what someone wrote in it. Ask it the questions that matter in production:

  • Two files define revenue differently. Which one is approved?
  • A table failed its freshness check at 3 a.m. Which metrics and dashboards sit downstream?
  • The churn definition changed in July. Which calculations still use the old one?
  • A column was renamed yesterday. Which descriptions are now wrong?
  • Is this person allowed to see what this summary was built from?

Search returns similar passages; a knowledge graph returns how a revenue policy, term, metric, model and quality check connect

None of those is a question about a passage of text. Each is a question about a relationship, and text search can't answer it. Search returns what looks similar. Similar wording is not the same meaning, and it is never lineage.

A folder of filesA connected graph
What it storesText about your assetsThe assets, and typed links between them
How it stays currentSomeone edits the fileChange events from the source systems
What the agent getsPassages that look relevantThe path: term, metric, model, table, quality result
When two definitions conflictBoth get retrievedThe conflict is flagged and sent to an owner
When something changesNothing knowsEverything downstream is one traversal away

Markdown is a fine way to write context down. It is not a way to keep it connected.

The relationships are the context. We keep them in a knowledge graph: a glossary term maps to a column, a metric depends on a model, a quality result applies to a dataset, a decision changes a rule, a document defines a concept. The ontology supplies the types. The graph holds the actual links, each with its source and its dates.

Because the links are typed, a reasoner can work over them. If a customer has accounts and an account holds subscriptions, the agent can be told which customers a failed billing table touches without anyone having written that sentence down.

And the links outlive the session. Once one agent has connected a metric to its definition and its code, and an owner has confirmed it, the next agent starts from there.

Here is a quick way to tell the two apart. Drop a column in the warehouse. A graph knows by the next sync what broke. A folder of markdown doesn't know anything happened.

Why one context platform and not ten context silos

Count the context layers launched in the last year. The warehouse has semantic views. The lakehouse has metric views. The BI tool has a semantic model. dbt has a semantic layer. The catalog, the document tool and the agent framework each have a context layer of their own.

So net revenue gets defined in Looker, again in dbt, again in a Snowflake semantic view, and again in a Databricks metric view. Each layer knows its own slice and defines Customer for itself. Ten context layers is not ten times the context. It is ten inconsistent answers to the same question.

Looker, dbt, Snowflake and Databricks each define net revenue differently

That is the fragmentation we already lived through, under a new name. What changes is who pays for it. Last time people held the chain. This time the agent has to, on every question, with nobody to ask.

How teams try to build a context layer today, and why it falls short

The folder of files. Covered above: text about your assets, with nothing connecting it.

The vendor's own context. Every warehouse and lakehouse is now building context for itself. Snowflake has semantic views. Databricks has metric views in Unity Catalog. Both are good inside their own walls, and both stop there. A Snowflake semantic view can't read Databricks, and a Databricks metric view can't read Snowflake.

That would be fine if your company ran on one vendor. Almost nobody does. Modern data infrastructure is heterogeneous: Snowflake and Databricks side by side, Postgres and Kafka underneath, dbt and Airflow in the middle, Tableau and Power BI on top, and the reasons for all of it in Drive, Confluence and Slack. No single vendor holds all of that, so no single vendor's context layer can describe it. A vendor's context ends where the vendor ends. Your questions don't.

The one you build yourself. Data teams see the gap and start stitching: a wiki of definitions, a YAML repo of metrics, a vector index over documents, a custom MCP server for each source. Each piece works. Together they are the same fragmentation with a maintenance bill, and usually a different version in every team. OpenAI can build and maintain six layers of context in-house. Most companies can't, and none should have to rebuild what can be shared.

MCP doesn't fix this. MCP is the plug: it standardizes how an agent calls a service. An agent can call the warehouse, the metrics service, Drive, GitHub and Slack, and every call can succeed. It still has to work out which definition, which code version and which decision belong together. The next agent repeats the work and may land somewhere else.

One open context platform: unifying context for accurate AI agents

The answer is one context platform that belongs to none of those vendors and connects all of them. Data stays in the warehouse and documents stay in Drive. The meaning and the relationships live in one open, governed knowledge graph that every agent, from every vendor, reads through MCP or an API.

That is what we built OpenMetadata to be: the open context layer for AI.

What a context platform has to do: seven requirements

Seven requirements a context platform has to meet

  1. Resolve identity. Know when two records are the same thing, and which mapping applied in which quarter.
  2. Tie meaning to implementation. Glossary, metric and ontology point at real columns and real code.
  3. Keep the evidence. Every claim leads to its source, marked as recorded, inferred or confirmed. Five pages repeating one sentence is one source.
  4. Track what is true now. Versions, effective dates, deployment state. A workaround approved until Friday expires on Friday.
  5. Enforce access. The PocketOS agent had project rules telling it what not to touch, and a credential that let it. The credential won. Permissions are enforced by the platform, and they follow summaries and memories, not just sources.
  6. Route conflicts to owners. In 2025 Cursor's support bot explained a login problem with a one-device policy that did not exist. The newest or most confident statement must not silently become the rule. A person with authority should decide, and record the decision centrally.
  7. Govern memory. Every memory carries its evidence, its scope and a review condition, so it can be corrected or retired.

Why your context layer has to be open

Your definition of a customer will outlive your current warehouse, your BI tool and your model vendor. It should not be locked inside any of them.

Open means you can inspect it, extend it and take it with you: JSON Schema for structure, RDF and OWL for meaning, PROV-O for provenance, SHACL for validation, MCP for access. Standards won't settle what churn means at your company. They make the disagreement visible and the agreement portable.

Open standards for a context layer: JSON Schema, RDF and OWL, PROV-O, SHACL and MCP

Where OpenMetadata is today

We built OpenMetadata to be this platform. What is there today:

  • An RDF-based knowledge graph, with a reasoner. Every entity, relationship and event has a published schema and an RDF and OWL representation. RDF is what the graph is built on, not an export format. A reasoner runs over that graph, so an agent can ask what follows from the facts, not only for the facts someone typed in.
  • 150 connectors. They bring context from API services, ML models, LLMs and AI agents, data warehouses, pipelines and dashboards, Drive, Notion, Confluence, and everything in between. One graph is only useful if everything can reach it.
  • Metrics in one place. Metric definitions from Snowflake, Databricks, dbt, Power BI, Tableau and Looker come into one model, linked to glossary terms and to the data they are computed from. An agent sees one definition of revenue, and where each tool's version differs.
  • Semantics and ontology. Glossaries with approval workflows. Ontology Explorer shows how concepts relate and which data assets implement them.
  • Data quality and observability. Tests, freshness and volume checks across 30 data sources, tied to lineage. Incident management an agent can read: what broke, who owns it, what it affects and whether it is resolved. And a data profile for every table, with row counts, null rates, distinct values and distributions, that an agent uses to write more accurate and far more efficient queries.
  • Context from the other services you use. Context Center holds Articles, Documents and Memories. Knowledge from Google Drive and Confluence joins the same graph, and with Collate, MCP plugins reach GitHub, Slack, Confluence and Notion.
  • Served to any agent. An MCP server returns business context, lineage and quality together, under your identity and access policies.
  • Still your work. Domain mappings, conflict rules and approval paths. No platform ships knowing who at your company gets to redefine churn.

How to evaluate a context platform: change one thing

You don't need a feature matrix to evaluate a context platform. Pick one thing that matters: a metric, a customer commitment, an incident, a business rule. Trace it through the system: the definition, the source data, the code, the quality checks, the documents and conversations behind it, the owner.

Then change one input. Revise the definition. Rename a column. Fail a quality check. Approve an exception in Teams. Deploy a fix.

The change-one-thing test for evaluating a context platform

Watch what happens:

  • Does it show you what is affected?
  • Does it keep the evidence?
  • Does the decision reach the person who owns it?
  • Does the next agent get a different answer because of it?
  • Does a question about last quarter still get last quarter's rules?
  • Do access rules still hold on the summaries and memories built from that data?

If yes, you have a context platform. If every agent has to work that out again, you have a set of connectors.

Sources

Ready for trusted intelligence?
See how Collate helps teams work smarter with trusted data

Keep Reading