Governed Datasets as the Unit of Agentic Context
Certified datasets, not raw database access, are what agents should act on.

Governed datasets should be the unit of context an AI agent is allowed to act on. For Supabase teams, this means giving agents pre-modeled, certified datasets through an MCP server instead of letting them access the database directly. Dreambase implements this pattern, placing business definitions, policy enforcement, and provenance between production Postgres data and the agent that consumes it.
Why agentic AI systems fail at the data layer, not the model layer
An agent works in a pilot, then stalls when it has to use live business data and act without a person approving every step. The model can reason, but the surrounding system cannot reliably tell it which source holds the answer or what the fields mean. McKinsey's April 2026 analysis describes the gap between experimentation and deployment. Although a majority of organizations are experimenting with or piloting agents, no more than 10 percent report scaling them in any given business function. In production, an answer must be dependable enough to act on.
More compute or a better model cannot fill in the missing business context. A more capable model still needs to know which revenue column is authoritative and which numbers it is allowed to use. These are properties of the data environment. If the environment leaves those questions unresolved, the agent must proceed with incomplete meaning or depend on a person to resolve it. Neither lets the agent work on its own as the pilot promised.
A human analyst brings institutional memory to this task, including knowledge of current reports, unreliable fields, and authoritative sources. An agent starts cold unless the infrastructure supplies that knowledge up front. Where a human would ask a colleague which revenue column to use, an autonomous agent may choose a table and act without flagging the ambiguity. The architecture must carry the knowledge that human analysts would otherwise supply.
What "governed context" actually means and why ungoverned context is the specific cause of failure
An agent can find data even when nobody has said it can be trusted, is up to date, or is approved for AI consumption. Context governance closes that gap by controlling which information is eligible to inform an agent's decision. Certification is the declaration by a named steward that an asset is approved for that use. Provenance establishes which source version informed an output and whether that version was eligible when the agent consumed it.
ContextNest illustrates the distinction with a procurement agent that approves a vendor using an archived risk-threshold policy. The retrieval pipeline finds the archived policy in the same vector index as the current one, and no audit trail records which version the agent consumed. A vector index on its own cannot guarantee version identity, integrity verification, or point-in-time reconstruction. Relevance therefore cannot stand in for permission to act.
Atlan's framework treats these controls as connected parts of the context layer. Context governance supplies ownership and meaning, while classification and policy as code express the rules that constrain use. Access and entitlement determine who may consume the data, and data must meet quality requirements to be fit to support an answer. Lineage and traceability link that answer to its sources, and AI asset governance makes the AI assets themselves subject to these controls. These controls must operate where the data lives, because a policy stored in a PDF cannot enforce an agent's access.
The five quality criteria an agent's context must satisfy — and why ad-hoc queries satisfy none of them reliably

A useful test of any context-access pattern has five criteria, namely relevance, sufficiency, integrity, provenance, and policy constraint. These conditions must all hold simultaneously. An accurate value from an unauthorized source is still unsuitable context, just as an authorized value with the wrong meaning is unsuitable.
Relevance requires context scoped to the question. Ad-hoc SQL can over-fetch or under-fetch according to how the query is written. Sufficiency requires enough business meaning, including table definitions, ownership, freshness, and metric definitions, for the agent to reason without guessing. A live query over a raw schema exposes structure but does not reliably supply that meaning.
Integrity calls for validation that flags broken data before an agent reasons on it. Live query access alone does not establish that validation has run where the data lives. Provenance requires a trace from the output to the source version and its approval status at the time of consumption. An ad-hoc query does not by itself preserve that version identity or establish eligibility for AI use.
Policy constraint means that rules for access, masking, retention, and purpose must filter context before the agent sees it. A raw query interface does not reliably provide this boundary when enforcement is left to client logic. Atlan makes the entitlement test concrete by requiring persona-based permissions to apply identically to a human in a BI tool and an agent calling through an API. If the agent can see more than the person it serves, the entitlement model has failed.
ContextNest's controlled stale-version experiment shows why selection governance matters independently of retrieval quality. Governed selection outperformed BM25 sparse retrieval on answer-quality pass rate at approximately one-third the input-token cost. Its 2026 determinism experiment also found that a dense retrieval baseline configured with realistic production parameters was non-deterministic on 80 percent of queries, while deterministic selectors returned stable document sets. These findings concern governed knowledge retrieval. They nevertheless sharpen the architectural question of whether context is selected from approved artifacts or assembled before its eligibility has been established.
Why the pre-modeled, certified dataset is the structural answer to all five criteria
The pre-modeled, certified dataset must be the smallest unit of context an agent may consume. Pre-modeling embeds metric definitions, ownership, freshness guarantees, and approved column semantics in the artifact, freeing the agent from reconstructing them. Certification then records a named steward's approval for AI consumption. The agent receives a bounded business asset. The supplied context has relevance and sufficiency built in, so they no longer depend on how the query happens to be written.
This boundary also gives validation and policy a defined place to operate. Data quality can be evaluated before the dataset is made available, and classification and masking rules can be built into it at write time. Atlan's framework calls for ownership, business definitions, glossary terms, READMEs, and certification status to be attached to assets. Together, these distinguish an approved source from an abandoned copy that happens to have a convincing name. The dataset carries both its meaning and the terms under which that meaning may be used.
Version identity gives the same artifact an audit boundary. ContextNest uses stable addressable references and SHA-256 hash-chained version histories to support reconstruction of the context used in an output. Its audit traces connect agent consumption to those versions, making approval at the time of use inspectable. The important distinction is between establishing provenance as part of the context artifact and trying to infer it afterward from a query log. Governance decisions precede the agent's action.
The access interface must keep that boundary in place by accepting only a metric name, filters, and dimensions. The query service enforces policy and returns results with provenance, while the certified dataset supplies the approved meaning. This prevents semantic bypass, where an agent avoids an approved metric by calling a raw query tool. Requests still run at runtime, but they follow decisions already made about what the data means and whether it may be used. That is an architectural shift from reactive governance to governed access.
How do Supabase and Postgres teams give agents governed access without direct database access
For Supabase and Postgres teams, this architecture extends the existing authoritative state store. Supabase is a Postgres-first platform that startups use for application data and are also pressing into agent-memory and analytical service. The governed-dataset pattern puts an analytical boundary between that state and the AI that uses it. Metrics are pre-calculated into certified Parquet datasets, queried through DuckDB, and exposed through a single MCP server. The agent consumes those datasets without touching production tables, and the pattern requires no ETL, schema changes, or separate warehouse.
In late January 2026, Moltbook, a social network for AI agents, had a misconfigured Supabase database that allowed full read and write access to platform data. The incident illustrates why agent identities must be treated like high-value credentials. Read-only access narrows the permission, but prompt injection can still manipulate an agent with legitimate read access into surfacing data it should not.
MCP supplies the interface. It does not decide which table is trusted, define a revenue metric, or enforce policy by itself. For a team evaluating an MCP server for row-level access controls, the relevant distinction is how the implementation enforces entitlements before returning context. A common protocol does not establish that an agent sees only what the person it serves may see. Giving agents certified datasets instead of raw tables keeps that evaluation focused on how governed access is enforced.
Dreambase implements this pattern as the governed data layer between a team's Postgres data and AI workflows. It pre-models metrics into governed datasets, enforces policy before agent queries, and exposes the datasets through a single MCP server. Agents get context that is fast, accurate, and cheap to query without needing credentials for the production database. For startups that have no dedicated data team, the same artifact gives them board-ready numbers and context that is safe for agents to use without extra data engineering work. When one engineer defines a revenue metric and Dreambase certifies it, dashboards, agents, and automated reports use the same number, making the dataset a single source of truth.
What becomes possible when humans and agents share the same governed data layer
When each dashboard, agent report, and workflow derives its answer from one metric definition, a definition updated once stays aligned across those consumers. The alternative is each system maintaining its own version of ARR and leaving operators to reconcile the results. Shared context prevents those numbers from disagreeing, so an agent does not have to explain the differences afterward. The operational gain is less time resolving definitions and more time making decisions from them.
That gain depends on sequencing. Automating a broken metric only makes the error easier to distribute at scale, so the governed dataset must precede the agent. Once the definition is certified, automation can reuse it without working out its meaning again for each destination. The number of consumers can grow without multiplying the definitions they depend on.
When an agent output points to a certified dataset version, a board-level question about how a number was derived has an identifiable basis. Atlan describes lineage and decision traceability as the record of upstream sources, transformations, and the policy applied to an answer. That record makes an audit request answerable through a query. The same foundation supports both the person responsible for the number and the agent acting on it.
The forward-looking implication is headless analytics, meaning data infrastructure decoupled from any single front end and accessible through MCP or API. As with headless CMS, the underlying asset is not tied to one presentation. A governed dataset can serve a Slack digest, a board report, an AI analyst agent, and a live dashboard without rebuilding the metric each time.


