LetterMCP

MCP Tool Poisoning in the AI Supply Chain

Thousands of MCP servers lack basic security.

· 8 min read · Updated
Cover illustration for “MCP Tool Poisoning in the AI Supply Chain”
Agent Security · August 9, 2026 · 8 min read · 1,838 words

MCP tool poisoning is built into how the protocol decides what to trust, so fixing one operator's setup does nothing to fix the next one. Tool descriptions are read by the model as trusted input, so any server that can place text in front of that model has a way to instruct it directly. That single design choice is also what makes MCP useful in the first place: it lets tools describe themselves to an agent in plain language instead of forcing every integration through custom code.

The stakes change once that agent has real reach. A chatbot that only answers in text has narrow authority over anything, but an agent wired into CRM systems, ticketing queues, code repositories, or production databases can change real things in the world, and that shifts the risk into a different category entirely, not just a bigger version of the same one. The question security teams need answered is no longer whether a model might say something unsafe. It's what a given identity, once connected through MCP, can read, change, or trigger.

The protocol does not answer that question for you. Authentication and authorization are left to whoever builds the server, and the quality of that implementation varies enormously across the thousands of community servers now in circulation. During the rush to adopt AI tooling, most builders skipped the basics: no authentication at all, credentials sitting in plaintext configuration files with far more access than needed, and default network bindings that leave the server reachable from the open internet. Trend Micro's scan found 492 MCP servers exposed to the internet with no authentication whatsoever.

This is the same failure mode the software industry has already lived through once. If a malicious npm package runs, it gets whatever privileges the application that imported it holds, and when a malicious MCP tool runs, it gets whatever permissions the agent that loaded it holds. Software supply chains have understood that pattern for years, but now it has landed squarely inside AI agent infrastructure. Treating it as a configuration issue to patch misses what it actually is: a trust model that was never designed to verify who gets to do what once a connection is open.

The five attack patterns that exploit this structural trust

Tool descriptions carry the same authority as trusted system input, so the resulting attack surface is a family of related techniques, each one a different way of abusing the fact that the model has no reliable way to tell a legitimate instruction from an injected one.

Tool poisoning is the clearest form of indirect prompt injection: a malicious server's tools can look entirely ordinary, but their responses carry hidden instructions that land straight in the model's context window and get treated as trusted input. Rug pulls exploit a different gap: MCP tools can silently change their own definitions after a human has already approved them. An operator signs off on a tool that looks safe on Day 1, and by Day 7 that same tool has quietly rerouted API keys to an attacker. The approval screen showed one version of the tool, but a different version is what's actually running, and no widely deployed mechanism exists today to catch that kind of drift.

Cross-server tool shadowing takes advantage of the fact that an agent session often has several MCP servers connected at once. A malicious server sharing that session can override or intercept calls meant for a trusted one, so a disguised "productivity" server can shadow a legitimate GitHub server's tools and quietly intercept the credentials passing through.

Confused deputy attacks push the manipulation one level up: an agent holding elevated privileges gets tricked into exercising them on behalf of someone who was never supposed to have that access. The Coalition for Secure AI treats this as a predictable structural risk rather than an edge case, because MCP servers are built to act as intermediaries and most don't validate authorization on a per-request basis. If you hold a token without checking each request against it, you get the confused deputy as the default outcome, not just a clever exploit. In June 2025, Asana suffered a tenant isolation flaw that let data cross between organizations and affected up to 1,000 enterprises, and it traces back to exactly this failure.

Broken delegation chains round out the picture. When one agent hands work off to another, the authorization behind that request is supposed to narrow at each step. In practice, many deployments issue fresh credentials at every hop instead, so a downstream agent can end up with permissions the original user never granted. It's the multi-agent version of token passthrough: the original authorization gets passed along and relabeled so many times that its actual source becomes untraceable.

What documented incidents reveal about real-world blast radius

These five patterns are not theoretical constructs. The incidents on record show tool poisoning has already compromised developer environments, hijacked major coding assistants, and surfaced inside an AI framework's own official marketplace and a protocol author's own reference implementation.

The earliest and simplest case came from Invariant Labs in April 2025, testing against the Cursor IDE. Researchers embedded exfiltration directives inside the tool description of what looked like an ordinary calculator server. When a developer called the add function, nothing about the visible output looked wrong, but Cursor's underlying model had silently read the developer's SSH private key along with the Cursor MCP configuration file and sent both to a remote endpoint. The arithmetic came back correct. Nothing in the interface suggested anything unusual had happened. That gap between what the user saw and what actually executed is the attack in its purest form: the tool description is the surface, the payload is invisible, and the blast radius lands at developer-level operating system credentials.

A year later, in April 2026, the pattern reached further. Researcher Aonan Guan of Wyze Labs, working with Johns Hopkins co-researchers Zhengyu Liu and Gavin Zhong, hijacked Claude Code, Gemini CLI, and GitHub Copilot by planting malicious instructions inside GitHub pull request titles, issue bodies, and HTML comments. None of this required a malicious MCP server at all. The agents simply read PR data as part of the task they'd been asked to do, followed the instructions hidden inside it, and exfiltrated GitHub Actions secrets, posting the results back as PR comments for Claude Code, issue comments for Gemini CLI, and git commits for GitHub Copilot. The lesson here extends past MCP servers specifically: any content an agent reads as part of its trusted context is a potential injection vector, whether or not it ever touches a formal MCP connection.

The first compromised a single developer's machine through a tool the developer had explicitly approved. The second compromised three of the industry's most widely used coding agents through content those agents were already authorized to read, with no attacker infrastructure required beyond a GitHub comment. The attack surface did not need to grow more sophisticated to produce a bigger outcome. It only needed to exploit the same structural gap in a context with more reach.

What attackers take: credentials, identity, and shadow agent persistence

None of this would matter much if agents operated with narrow, temporary permissions, and they don't. What makes tool poisoning a first-tier enterprise risk is the ambient authority agents are routinely given: developer-level operating system credentials, broad service account permissions, and the ability to keep operating inside an organization long after whoever built them has moved on.

Credential exfiltration is often the first and most immediate payoff. When agents run inside IDE environments, they typically inherit the full set of privileges their developer has on the host machine. A single successful exploit chain can pull out cloud CLI tokens, SSH keys, and API credentials all at once, just as the Cursor and Invariant Labs case showed. None of those credentials expire on their own. They stay valid indefinitely until someone actively rotates them, so a breach discovered weeks later can still be exploited with keys stolen on day one.

Behind that sits a deeper governance problem. Most enterprises have no consistent process for provisioning, tracking, or retiring the credentials assigned to AI agents. Every agent deployed without that process adds to an identity surface nobody is actively accounting for, and that surface compounds with each new rollout.

The sharpest version of this problem is the shadow agent. A large majority of enterprises already have AI agents or automated workflows running that their security teams never knew existed. An agent built quietly by a business user, with no formal review, can read, write, and post data across systems throughout the company, and it keeps running even after the person who built it has left the organization, with nobody watching the credentials it still holds. It's the MCP-era version of shadow IT, except this version has write access to production systems rather than just an unsanctioned spreadsheet. The scale of the gap matches that risk: the overwhelming majority of organizations now use AI in some form, only a small fraction have anything resembling a comprehensive governance framework over it, and recorded AI incidents climbed sharply year over year.

Why identity is the load-bearing wall

Every pattern described above, tool poisoning, rug pulls, shadowing, confused deputy, broken delegation, collapses into the same unanswered question: when a request gets honored, can the system say who authorized it, through what chain, and with what scope? At RSAC 2026, the Coalition for Secure AI reported that practitioner questions kept converging on exactly that, identity and authorization, rather than on new kinds of attacks. That convergence confirms identity is the load-bearing wall of MCP security, and it confirms most production deployments haven't poured that foundation yet.

The protocol's own evolution reflects that recognition directly. If authorization is implemented, the current specification calls for OAuth 2.1, and PKCE is required for authorization-code flows. Every authorization server endpoint has to run over HTTPS, with redirect URIs limited to localhost or HTTPS. Protected Resource Metadata under RFC 9728 must be exposed wherever authorization is in use. Clients are required to implement and send the resource parameter from RFC 8707 on every authorization and token request, and servers are required to validate that any token presented to them was issued specifically for that server.

That last requirement targets the single most common mistake found in production today: token passthrough. It happens when an MCP server receives a user's OAuth token from an upstream client and forwards it unchanged to a downstream service. The downstream service has no way to tell that token apart from one it obtained the normal way. Any hop along that chain can impersonate the original user. Binding tokens to specific resource servers is the direct architectural answer to that failure, and it marks the industry treating this not as a collection of isolated server bugs but as what it actually is: a gap in the chain of identity that has to be closed at every hop, not patched after the fact at whichever hop happened to fail first.

Sources

  1. MCP Tool Poisoning: Adversarial Hijacking of AI Agent Workflows
  2. After RSAC™ 2026: The MCP Security Question Everyone Kept Asking - Coalition for Secure AI
  3. Model Context Protocol Threat Modeling and Analyzing Vulnerabilities to Prompt Injection with Tool Poisoning
  4. Formal Analysis and Supply Chain Security for Agentic AI Skills
  5. MCP Pitfall Lab: Exposing Developer Pitfalls in MCP Tool Server Security under Multi-Vector Attacks
  6. Authorization - Model Context Protocol
Filed underAgent Security

More in Agent Security