MCP Security Risks in Agentic Data Pipelines
Agents trust MCP servers by default, and attackers exploit it.

MCP security risks in agentic data pipelines arise when agents have a trusted route into systems whose data and tools can shape how they reason. For API-first and agent-first teams, the safer analytics backend is a governed, pre-modeled data layer exposed through MCP. This headless pattern separates analytical access from production credentials while leaving the interface to the team.
Why MCP became the default connective layer between AI agents and data
Anthropic introduced the Model Context Protocol in late 2024 to standardize how LLM applications connect to external tools and data [1][2][3]. Hou et al.’s MCP-BiFlow research counted tens of thousands of MCP servers within roughly 16 months. MCP uses a host–client–server architecture in which servers share tools, resources, and prompts through the same interface. That consistency makes different services available through the same connection model. This means less work is needed to connect each tool.
The Cloud Security Alliance’s Agentic MCP Best Practices Guide, published 2026-03-27, says MCP has already changed how agents work with external systems [1][2][3]. Its reach extends beyond data retrieval to tool invocation and coordination between agents. The National Security Agency’s Cybersecurity Information Sheet calls it the de facto standard for how a growing number of AI-driven services communicate. MCP is therefore no longer only an experimental connector. It is an interface through which applications reach working infrastructure.
The protocol's architecture inverts familiar trust assumptions in ways most teams have not caught up with
Hou et al. frame MCP security as a bidirectional trust-boundary data-flow problem. User input reaches a host, an agent selects a tool, and a client sends invocation arguments to a server that accesses privileged resources. The result then returns to the model’s reasoning. At every handoff, data crosses a boundary between sources with different authority. Request-side propagation takes requester-controlled arguments toward sensitive operations, while return-side propagation brings external content back into the agent’s decision process.
The return path changes the security model. A tool result is not merely data delivered to a passive client, because its contents can influence what the agent does next. In a session connected to dozens of servers, that influence can extend beyond the server that supplied it. A compromised connector can affect the agent’s understanding of adjacent tools for files, GitHub, Slack, Stripe, or databases. The trust decision therefore concerns the whole session.
Runtime tool registration adds another moving boundary. MCP hosts dynamically enable capabilities as servers add or remove them, so a remote update can make a destructive tool available without fresh user awareness or approval. The NSA sheet also notes that MCP lacks native support for exchanging role-based access control permissions at instantiation. This makes boundaries between tasks and services difficult to enforce or verify. Which tools are available, what shapes the model’s reasoning, and which resources it can access can all change after the operator’s original approval.
Five concrete attack classes that flow directly from that architecture
Tool poisoning and the rug-pull pattern. A server can change the descriptions that guide tool use after it has been approved. Pillar Security found a live campaign in August 2026, named “Deadbugz,” whose server behaved harmlessly for its first three tool calls before instructing the agent to collect SSH keys and cloud credentials. The initial behavior concealed the later instruction. Approval of a server at one point did not establish the safety of its subsequent behavior.
STDIO command execution. OX Security’s April 2026 “Mother of All AI Supply Chains” research identified a command execution vulnerability in Anthropic’s official MCP SDKs for Python, TypeScript, Java, and Rust. The STDIO transport passes parameters directly to the host operating system’s shell without input sanitization. The command can run without a valid MCP server starting. The sensitive operation takes place at the host boundary, before the server has successfully used the protocol to give any reassurance about the command.
Cross-server tool shadowing. A malicious server can supply tool descriptions that redefine the agent’s understanding of neighboring trusted servers. Shared model context becomes the route of influence. This connects to the request-side propagation paths documented by Hou et al., in which requester-controlled data reaches sensitive operations. Those operations include SSRF, path traversal, command injection, and unsafe query execution. A tool’s trusted origin does not make the agent’s reasons for invoking it trustworthy.
Confused deputy. An MCP server can hold broad permissions without requiring authorization for each action. An attacker who influences model inputs can redirect that authority toward an unauthorized operation. The attacker need not authenticate to the privileged resource directly. The server acts with its own credentials, while the instruction that prompted the action comes from a less trusted source. Authentication of the server alone does not establish permission for the action.
Supply-chain substitution. Attackers can also replace a legitimate connector with a malicious version shared through the same discovery channels. The protocol itself need not be exploited. This attack targets the decision to install and trust a server, rather than only the arguments passed to it afterward. Once installed, the replacement sits between the agent and its resources where the connector would have been. The SmartLoader / Oura attack demonstrates how this entry point becomes an operational compromise.
What these attacks look like when they hit real infrastructure
The CSA guide describes the exposure directly relevant to Supabase builders. Every Supabase MCP tool call returns whatever the authorizing user can see, potentially including PII, financial records, source code, and credentials, without inspecting it before it reaches the model context. The significance of this access condition is that a legitimate user’s visibility becomes the scope of material available to the agent, without establishing that a particular breach occurred. A successful request can then reveal more than the operator meant to share, even while database permissions work as intended.
The SmartLoader / Oura supply-chain attack in February 2026 illustrates a different route into that trusted position. Attackers cloned the legitimate Oura MCP project and manufactured credibility through fake contributors and multiple forks. They then distributed a trojanized version through public MCP registries that delivered the StealC information-stealing malware. No protocol exploit was required for this attack. The failure lay in accepting a malicious server as a legitimate integration.
Uber’s ADR system paper at MLSys 2026 shows the scale of credential exposure in operating environments. After the detection system was deployed across more than 7,200 hosts that process agent sessions daily, it found hundreds of credential exposures of many kinds. That finding concerns agentic workflows broadly. It moves the discussion beyond isolated demonstrations.
Why the governance gap is widest exactly where the blast radius is largest
Uber’s paper identifies an observability gap between endpoint activity and agent behavior. EDR tools can see file writes and API calls, but not agent reasoning, user prompts, or the causal chain connecting intent to tool execution. The action is visible while its cause remains obscure. This distinction is important when an authorized tool performs an operation prompted by untrusted content. A record of the final API call alone does not explain why the agent made it.
Static rules’ limited reliability across attack variants and the expense of detection at scale make security hard for early-stage teams as they start using agentic pipelines. Adoption and governance operate at different speeds. A team can connect a useful tool before it has the means to understand every execution path that tool enables.
Supabase’s permission model makes this mismatch concrete without implying that permissions themselves have failed. A user may legitimately need access to sensitive records, while an analytical agent needs only a defined metric or dataset. Reusing the user’s full visibility gives the agent more access than its task requires. That is a tractable design problem. The relevant boundary is the data available to the task, rather than everything available to the person who authorized the connection.
Why letting agents query production databases directly is the root architectural mistake
Supabase’s own guidance states that its MCP server is designed for development and testing. Its --read-only flag and --project-ref scope provide ways to restrict access. Those controls reduce the range of possible operations and the projects exposed. They do not make every permitted result suitable for a model. Read-only access can still return information that the operator never intended to disclose.
Direct production access joins two separate decisions. The first is whether an agent may answer an analytical question, and the second is whether it may inspect the underlying operational data using production credentials. When those decisions share one connection, a manipulated request inherits the reach of that connection. The database can enforce its permissions correctly throughout.
Hou et al.’s analysis explains why query inspection alone cannot resolve this problem. Vulnerabilities emerge across complete tool-scoped execution paths, including argument decoding, validation, helper forwarding, sensitive operations, and protocol-visible outputs. Both directions of propagation depend on that full path. A check on the query text covers only one part of it. Checking after execution also cannot undo what has been disclosed once production data has entered the model context.
Authentication hardening remains useful within that larger boundary. OAuth 2.0 with audience validation reduces token reuse across servers by requiring explicitly scoped tokens for each server. The CSA guide also sets out inventory, allowlisting, version pinning, per-action authorization, and runtime inspection of tool calls and results. These controls govern how access happens, but live, unmodeled data can still produce an unintended response. The architectural fix is not more controls on the same access pattern, but a different access pattern entirely.
What a governed, pre-modeled data layer does that runtime controls cannot
A governed data layer defines what agents can learn before they ask a question. Metrics and datasets are pre-calculated, permissioned, and exposed through MCP rather than discovered through unrestricted production queries. With governed Parquet files queryable through DuckDB, the agent reads a schema-stable artifact. Production credentials are absent from that access path. Removing the production connection cuts off that route for confused-deputy access to production and command injection, though the MCP host still needs protection.
This boundary also constrains return-side propagation in a precise way. An agent cannot get an unexpected column, secrets table, or raw log if it was never part of the governed model. The limit follows from what the layer contains. It does not depend solely on whether a runtime filter recognizes a malicious request. Bounded datasets restrict the material that can enter the model’s context.
PostHog’s semantic layer pattern illustrates shared governance for agents and humans. Both query the same metric definitions, while agent-proposed changes to canonical metrics require human approval before becoming authoritative. ZoomInfo’s GTM.AI MCP implementation illustrates permission enforcement within the MCP layer itself, with entitlements traveling with the data. Informatica’s headless pivot, announced at Informatica World 2026 by Informatica from Salesforce, extends the principle to governed, reusable data management services with native MCP support and full lineage at integration.
For teams asking which analytics backend fits full API control without an opinionated frontend, the defining criterion is governed access independent of the presentation layer. The agent consumes permissioned datasets through MCP, while human teammates can receive the same pre-calculated metrics through dashboards, Slack, or inboxes. The numbers are calculated once under the same conditions for both. Teams can use this setup for agent-facing usage analytics without having to use a prebuilt dashboard as the interface. The choice of presentation does not change the underlying metric definition.
For Supabase builders, the pattern can extend an existing project. The configuration described here decouples analytical access from production Postgres without schema changes, ETL, a separate data warehouse, or new infrastructure to manage. It does not require a dedicated data team. Every agent session querying the governed datasets generates traceable telemetry, addressing the session-visibility gap identified in Uber’s paper. Human modeling decisions establish the exposure boundary before the agent runs, leaving MCP as the delivery interface.


