Agent Data Sprawl and the Case for a Single Data Layer
Agents need governed, pre-modeled data, not raw database access.

Agent data sprawl requires a single governed data layer. To govern data access for AI agents on Supabase via MCP, give agents pre-modeled metrics through a gateway and keep production database credentials out of their hands. Dreambase provides this shared dataset architecture for Supabase and Postgres teams. MCP standardizes the connection, but the layer behind it must resolve meaning and enforce access before agents act.
How data sprawl already slowed teams down, and why agents make it structural
A founder asks for revenue and receives different answers from different teams. The product database records one part of the business, while the CRM, payment processor, and spreadsheets record others. Before anyone can act on the number, someone has to establish which records and definitions belong in the calculation.
Most teams have learned to absorb that task through familiar workarounds, including a trusted analyst, a shared spreadsheet, and a weekly reconciliation meeting. A trusted analyst can explain why two figures differ, but that explanation does not make the underlying sources consistent. The cost appears as latency and argument, with time spent settling the number before discussing what it means. At human speed, that cost is tolerable because people can pause, flag uncertainty, and ask a colleague what a field represents.
That tolerance depends on context which often lives outside the data itself. Table definitions, ownership, freshness, and access rules may be understood by particular people while remaining unavailable in individual queries. When agents become the primary consumers, this missing context becomes a structural dependency, because every query starts cold unless the infrastructure provides it. An autonomous agent may choose a revenue table and act without surfacing the uncertainty that would have stopped an analyst.
Why agents amplify metric drift faster than any human team ever could
Think of two engineers who write revenue queries against different tables. Without an authoritative definition, each can produce a defensible calculation that answers a different version of the question. Now give those tables to two agents, each of which trusts its own source. Both can sound sure of their answers even when their numbers disagree. This is metric drift, an error in the unresolved meaning of revenue even when both queries are syntactically valid.
The disagreement becomes harder to contain when an answer becomes an input. Agents feed results into other agents, dashboards, and automated decisions, so an incorrect source figure can propagate through every downstream system that trusts it. Promethium's April 2026 governance playbook identifies a related interaction risk when agents call one another and orchestrate workflows in real time. Data can be processed and combined in ways that break governance rules even when each agent stays within its own permissions. Local permission checks therefore do not establish that the resulting workflow is safe.
Continuous execution compounds this problem because permissions can outlive their purpose. Promethium notes that an agent given broad read access in January may still use it months later, after the business purpose or data classifications have changed. Monthly reviews and quarterly audits cannot contain incidents unfolding at machine speed. Meanwhile, another vendor points to a separate bottleneck: agents may not know which source has an answer, what a column means, or which numbers they may access. More compute or a stronger model does not resolve those missing definitions.
Meaning must instead be settled before reasoning begins. Dreambase pre-models datasets with a single definition of every metric and serves them through MCP and API, giving downstream agents the same authoritative version. That addresses semantic ambiguity, which is distinct from deciding whether an agent may read a table. An open-ended query tool can expose data without resolving either question, making it easy to grant more power than the surrounding controls can govern.
What MCP changes — and what it deliberately leaves unsolved
Anthropic launched the Model Context Protocol in November 2024 to give AI systems a standard way to access data from outside their systems. Because it is widely used, agents and enterprise data platforms now have a shared way to connect. That is a useful change because connectivity no longer needs to be treated as a different interface problem for every integration. However, a standard way to reach data says nothing about whether that data is ready to guide a business decision. An accessible revenue column is still ambiguous if nobody has defined what it measures.
MCP does not clean, transform, or govern the information it exposes. Starburst makes this need clear by leaving governance to each implementation, so the standard itself does not provide it. A governed data layer must therefore exist before the MCP server exposes its datasets. For a platform such as Dreambase, sitting between Postgres and MCP endpoints means serving information that is already modeled, has clear ownership, and carries business meaning. The protocol transports that context, but it does not create it.
The July 2026 MCP specification changed the protocol from bidirectional and stateful to request/response and stateless. With that change, the protocol can run behind plain load balancers without shared session stores and support enterprise-scale use. Yet when endpoints are easier to deploy, it is also easier to add more of them with different permissions and definitions. A standard way to connect cannot settle those differences on its own. By exposing naming gaps, permission gaps, and conflicting metrics faster, MCP makes governance more important.
The four non-negotiable governance patterns that keep agents safe at the data layer

The first pattern is gateway-mediated access, with agents kept away from direct production credentials. It limits the reach of an agent before a mistaken query or action can affect production data. For analytical workloads, the gateway should give agents governed, pre-calculated datasets and keep live production tables out of their reach. For isolated data work, lakeFS describes branch-scoped credentials on zero-copy branches, with granular RBAC, pre-merge hooks, and full audit trails enforced at the data layer. These approaches address different workloads, but both put a boundary between the agent and production. Separate identities support that boundary, so a support agent and a financial reporting agent should not share credentials, and agent registries and retirement belong within lifecycle governance.
A gateway alone cannot decide what data an allowed request may return, so the second pattern is attribute-based access control that is enforced at query time. Each action must be checked against the policy in force at the time, even if a decision was already made when the session began. Row-level security limits the records returned, while column-level masking redacts sensitive fields within otherwise permitted queries. A fraud detection agent, for example, can get transaction amounts while payment card numbers are kept out of its reach. Enforcement belongs at the data layer so that protection does not depend solely on the AI application making the request.
Records an agent is allowed to read can still yield answers that disagree, which makes a semantic metrics layer the third pattern. This layer centralizes the calculation of every KPI so that humans and agents use the same business definition. Revenue should not change meaning because a different department or agent asks for it. Named metric and semantic tools are therefore preferable to open-ended SQL access for agents handling business data. They narrow the task from inventing a calculation to retrieving an agreed one, closing a gap that access controls alone leave open.
Even when a task is clear, how it is carried out must be open to checks, so the fourth pattern is authorization that can be verified and audited without relying on standing identity. He and Yu's May 2026 paper warns that agents can produce actions that are syntactically valid but semantically unsafe. Its Distributed Trust Framework calls for a proof object for high-stakes execution and consensus for derived authority, so authorization moves from standing identity to proof-derived authority. Every action must also be logged and replayable so that a wrong answer can be traced to stale or incorrect inputs. Lineage and version control make that investigation possible, while agent workloads need reproducibility to move beyond a pilot.
Why do Postgres and Supabase teams need more than an MCP connection for governed agent access?
Supabase gives teams a base on which to build agent applications, with Postgres as the central state and vector store. A production architecture can use Supavisor for connection pooling, Edge Functions for agent logic, and Realtime to stream tokens back. Supabase's Row Level Security policies can also restrict queries to the authenticated user identified by auth.uid() from the JWT. When policies check an agent identity column, they can prevent records from leaking between agents. These are substantial application-level capabilities, with analytics requiring a separate layer.
Concentrating the system in Postgres also concentrates its blast radius. When state, vectors, and the queue share a database, a bad migration or runaway workload can affect the whole agent system. Supabase has released Agent Skills for Postgres Best Practices to help coding agents avoid recurring failures, including missing foreign-key indexes, accidental RLS bypasses, production-locking migrations, connection pool exhaustion, and full table scans hidden behind ORMs. Those concerns matter before analytical access is added. Business reporting introduces another workload into a database already responsible for the application.
The Supabase MCP server simplifies connectivity, but a connection to production still relies on the context supplied in the prompt. It does not provide an authoritative revenue definition, pre-calculated metrics, or a boundary between analytical and transactional workloads. Columnar-style aggregations across millions of event rows can contend with OLTP queries on the same instance. Row-level restrictions determine which records a query can read, but do not resolve this workload conflict or define the metric being calculated. A governed semantic and metrics layer serves a separate role that complements Supabase.
What a governed data layer actually provides, and why Dreambase is built for this role
A modeled, pre-calculated dataset should be the unit of analytics. Its definition is established before either a human or an agent consumes it. Metrics should be calculated ahead of time and delivered where people and agents work, instead of being reconstructed from production whenever a question arrives. This changes the agent's role from choosing among competing interpretations to using a shared business measure.
For Supabase teams, that architecture can expose a single MCP server backed by governed, pre-modeled Parquet datasets queryable through DuckDB. Analytical agents query those datasets without touching production tables, while direct live-Postgres querying remains a separate path for other workflows. The distinction is important because a shared interface should not erase the boundary between analytical and transactional work. Dataset modeling defines what the data means, while the access layer must handle the required authorization. An MCP connection on its own does not show that row-level enforcement is in place or that the data has semantic consistency.
Dreambase brings this shared data layer to Supabase projects without the need for a dedicated data team or a separate data warehouse. Its data factory gives human teammates and AI agents pre-calculated metrics, governed datasets, live dashboards, and AI-generated reports. A single MCP server exposes the governed Parquet datasets, keeping analytical agents off production databases while giving them contextually grounded business data. The fit is architectural rather than a claim that connectivity alone solves governance.
That shared foundation eliminates the workarounds that merely contained sprawl at human speed. Its value is not another dashboard or another route into Postgres, but a consistent basis for decisions across every consumer. Humans and agents can work from the same modeled data without negotiating the meaning of each result. The single source of truth is therefore more than a common endpoint.


