Data Sprawl Risks in Multi-Agent AI Systems

Most organizations can't account for the agents they've built, creating security and data risks.

· 10 min read
Cover illustration for “Data Sprawl Risks in Multi-Agent AI Systems”
Agentic Data Infra · October 12, 2026 · 10 min read · 2,234 words

"We went from 3 agents to 40 in four months. Nobody knows what half of them do." That practitioner account, cited by Atlan, describes the actual condition of enterprise AI deployment today, not an edge case. Multi-agent systems have moved from pilot projects to default infrastructure, and the organizations running them have lost track of what they built.

How agents multiply without multiplying shared understanding

The scale is no longer speculative. Neither figure describes a future state. Both describe a condition already underway inside companies that, in many cases, have not finished writing a policy for how an agent gets approved, let alone retired.

The reason governance lags so far behind deployment has to do with how easy agents have become to build. A product manager or a marketing analyst can build something that queries a database, calls an API, and takes action, without ever filing a ticket with IT or looping in a data governance team. Speed has outrun visibility, and the gap between the two keeps widening because nothing in the toolchain forces a team to slow down and register what it shipped.

The practical consequence is an inventory problem of a basic kind: most organizations cannot say, with any confidence, how many agents they are running, who built them, or what each one touches. The jump from 3 agents to 40 in four months, with nobody able to account for half of them, is the shape sprawl takes when deployment has no checkpoint attached to it.

Governance has not caught up, and the numbers make the shortfall explicit. IBM found that only 13% of organizations believe they have the right AI agent governance in place. OutSystems found that the overwhelming majority of enterprises are worried that sprawl is driving up complexity, technical debt, and security exposure, all at once. Those two data points describe the same organization from two angles: one that has built fast and governed late.

Agent sprawl is really two separate problems, and solving only one is dangerous

Diagram: Two Dimensions of Agent Sprawl. Visualizes: Illustrate that agent sprawl splits into two distinct, compounding problems: Identity Sprawl (agents nobody discovered, no audit trail, excess access — the dimension current tools like AWS Agent…

Agent sprawl is not a single problem with a single fix. It splits into two distinct dimensions, and treating them as one produces exactly the false sense of security that lets the more dangerous half go unaddressed.

The first dimension is identity sprawl: agents nobody discovered, agents with no audit trail, agents holding more access than their task requires. This is the dimension the market has moved fastest to address, because it is the one most legible to existing security tooling. AWS launched its Agent Registry, part of Amazon Bedrock AgentCore, reaching general availability on August 31, 2026, as a governed catalog spanning agents, tools, skills, MCP servers, and custom resources.

What none of them answer is the harder question. A registry can tell an organization that an agent exists and who owns it. It cannot tell anyone what that agent knows, or whether the number it just returned agrees with the number a different agent returned five minutes earlier from a different pipeline. Prukalpa Sankar, co-founder of Atlan, named that second question context sprawl: agents each building their own isolated, often conflicting understanding of the business, with no shared semantic layer underneath them, no agreed definition for a metric as basic as "active user," and no mechanism for resolving it when two agents disagree.

Anyone who has lived through the era of dashboard proliferation will recognize the pattern instantly, because this is that pattern again, one layer down. Agent sprawl reproduces the exact same fragmentation of definitions, except the outputs no longer sit passively in a spreadsheet waiting for someone to catch the error. They get consumed, trusted, and acted on by other software, automatically, at whatever speed the agent operates.

That is why solving identity sprawl alone is not just incomplete, it is actively dangerous. A registry gives an organization a clean list of well-credentialed agents, each with a name, an owner, and a permission set. None of that tells anyone whether those agents agree on what the business's core numbers actually are. An organization can roll out Okta's identity model, adopt Databricks' Unity Gateway, and register every agent in AWS's catalog, and still have forty agents operating on forty different versions of the truth. The paperwork is in order. The underlying disagreement is not.

The emergent failure modes that only appear when multiple agents interact

Some failure modes appear only when multiple agents interact, not when a single agent is tested in isolation. They only appear once agents start interacting with each other, because the interaction itself, not any one agent's individual behavior, is where the danger originates.

The clearest mechanism is cascading error. When each agent maintains its own data pipeline and its own calculation of a shared metric, an error produced by one agent does not stay contained to that agent. It becomes input for the next agent in the chain, which treats it as fact, builds on it, and acts on the result. The fragmentation that looked like mere inefficiency when it was just redundant pipelines becomes an active channel for propagating mistakes, because nothing downstream pauses to check the number against anything else.

This is structurally different from a human making a spreadsheet error. The autonomy that makes multi-agent systems valuable, their capacity to act without waiting for a human to review each step, is the same property that removes the checkpoint that would have caught the bad number before it did damage.

The access-pattern version of this risk is the confused-deputy pattern: an agent that holds more trust and more access than its actual task requires becomes a vector for actions nobody authorized, simply because another agent or process can induce it to act on the deputy's behalf. An agent connected to systems it was never meant to touch on its own, carrying credentials broader than its task, is a liability waiting for the right trigger.

Risks and Controls for Multi-Agent Systems frames the deeper issue as one of organizational boundaries. The blast radius of a multi-agent failure is set less by what any single agent can do and more by how much of the data landscape it can reach without a boundary to check it.

Letting agents query production databases directly makes every risk worse

One architectural decision sits upstream of nearly every risk described so far: whether agents get direct access to production databases. Where they do, every failure mode above gets harder to contain, and several new ones appear.

Start with credentials. Most still inherit a user's full database credentials wholesale. An agent built to answer one narrow question walks in holding the same access as the human who set it up.

Direct production access also slows queries down, compounding the security exposure described above. Most agent deployments skip that step entirely, because the agent simply uses whatever credentials it was handed and nobody built the routing layer that would have redirected it.

Session-level access control cannot close this gap. A connection string either lets a query through or it doesn't. It has no concept of whether this particular query, from this particular agent, in this particular context, should be allowed.

The protocol most teams are using to wire agents to data has its own documented gap here. The U.S. The National Security Agency stated that MCP's rapid proliferation has outpaced the development of its security model. The transport layer connecting most agents to most data was not built with a mature security model, so wiring it straight into a production database compounds that weakness.

Infrastructure requirements for safe agentic data access

Diagram: Three Properties of Safe Agentic Data Access. Visualizes: Show a three-step infrastructure sequence that must hold simultaneously (not as a sequential checklist) for safe agentic data access: (1) Least-privilege access — each agent gets…

Safe agentic data access cannot be bolted onto an existing pipeline after the fact. It requires a different infrastructure architecture, built around three properties that have to hold simultaneously, not as a checklist to work through one at a time.

The first property is least-privilege access scoped to each agent's identity. Each agent needs its own credentials and its own permission set, scoped to what its task requires, rather than inheriting the full access of whatever human or service account set it up. A fraud-detection agent, for example, can be given transaction amounts and timestamps without ever being able to see the payment card number or the customer's name attached to them. That is a meaningfully different posture than handing the agent a full database login and trusting it to behave.

The second property is gateway-mediated access that routes queries to read replicas. Agents should never hold production database credentials directly in their configuration. Every query an agent issues should pass through a centralized gateway that enforces permissions and logs what happened, and analytical workloads should land on a read replica, not the production instance itself. Supabase also changed its defaults on April 28, requiring explicit Postgres grants for any table exposed through PostgREST or GraphQL, a change that became the default for new projects on May 30. That is a platform-level move in exactly the direction this property requires.

The third property is runtime policy enforcement at the query level. Every action an agent attempts has to be checked against policy before it runs, using attribute-based access control that looks at the content and context of the specific request rather than relying on a static role assigned once and never revisited. This is the property most commonly missing from current deployments. Teams set up role-based access, decide it is sufficient, and stop. A static role has no way to evaluate whether this particular query, in this particular session, given what the agent has already done, should be allowed to proceed. That evaluation has to happen at the moment of the request, not once at account setup.

MCP is emerging as the transport layer capable of implementing all three properties together, but MCP by itself solves none of them. Connecting an agent to a data source over MCP says nothing about whether that data source is clean, correctly modeled, or governed. The common mistake is assuming the protocol substitutes for the semantic layer. It does not: an agent connected by MCP to a set of uncertified tables will still return a confident, fluent, wrong answer, because MCP governs the connection, not the content flowing through it.

A single pre-modeled data layer is the structural answer to both dimensions of sprawl

The fix that closes both identity sprawl and context sprawl at the same time is a single, pre-modeled data layer that every agent draws from, rather than the current default of each agent building and maintaining its own pipeline into the data it needs.

Context sprawl is, before anything else, a definitional problem, not a technical one. A poorly defined metric produces a misleading answer no matter how capable the model generating that answer happens to be. Agreed definitions for core metrics, clearly designated source-of-truth tables, consistent access rules, and data quality checks applied before an agent ever touches the data: these are not refinements layered on top of a working system. They are the precondition for any agent returning a correct answer. A pre-calculated, governed dataset solves the problem at its source. If a metric is modeled and certified once, before any agent queries it, then every agent drawing from that layer gets the same number back. The disagreement between agents disappears structurally, because there is no longer a second, independently built version of that metric sitting somewhere else to disagree with.

Pre-modeled datasets, made queryable through something like DuckDB and exposed through a single MCP server, satisfy the three properties described above simultaneously. Agents never touch production directly. Access is governed centrally at the layer itself rather than negotiated separately for each new agent that gets built. The semantic meaning of each dataset, what "revenue" or "active user" actually means, gets defined exactly once and shared by everything that queries it afterward. For Supabase teams specifically, this extends an existing Postgres project into full analytical capability without ETL, without schema changes, and without standing up a separate data warehouse. Postgres stays the operational home for the data. The governed layer sits above it as the surface every agent actually interacts with.

The alternative, building dashboards first and worrying about definitions later, fails in a predictable way. Stale or conflicting data spread across agents manufactures false confidence at exactly the scale an organization can least afford it. Every KPI feeding an agentic decision should come from a live, automated, governed connection back to the source system, not from whatever snapshot a given agent's own pipeline happened to capture the last time it ran.

Founders and small teams without a dedicated data engineer carry the most exposure to this failure, precisely because they are deploying agents at the same pace as larger companies without any governance function to catch the gap. A patchwork of separately built, per-agent pipelines will produce conflicting numbers, and that conflict tends to appear at the worst possible moment: a board meeting, a fundraising conversation, a product decision that depends on one number being right. The sequence that avoids this starts small and in order: identify the three to five data sources that actually matter, confirm that the data reconciles against a known source of truth, and certify the core KPIs inside a semantic layer before connecting a single agent to any of it. Skipping that sequence to deploy the agent faster is how an organization ends up with 40 agents and no one able to say what half of them actually know.

Sources

  1. Agent Sprawl and Context Sprawl: Causes, Risks, Fix [2026]
  2. AI agent sprawl: What it is and how to control
  3. Risks and Controls for Multi-Agent Systems: an analytical framework for deployment of AI agents across organisational boundaries

More in Agentic Data Infra