MCP Tool Poisoning: Anatomy, Real Attacks, and Defenses
Learn how MCP tool poisoning hijacks AI agents through malicious tool metadata, with real attack research, disclosed CVEs, and defense-in-depth strategies.

Rushali
2026 State of Agentic AI Security
How ready is your organization to secure AI agents?
3 quick questions. See how you compare to other security leaders.
A calculator should add two numbers, not read your SSH private key. In April 2025, Invariant Labs demonstrated how malicious instructions hidden in the description of an apparently harmless MCP calculator tool could manipulate an AI agent into accessing sensitive local files and sending their contents to an attacker-controlled server. They registered an MCP server whose add tool included a normal description followed by hidden instructions to silently read ~/.ssh/id_rsa and ~/.cursor/mcp.json and exfiltrate their contents. Cursor followed those directions. The user saw only a tool named “add” and a friendly confirmation dialog.
This attack class is called MCP tool poisoning. It succeeds when agents treat tool metadata as trusted instructions rather than untrusted data. This article explains how it works, the research and disclosures behind it, where malicious text can hide, and the defense-in-depth controls that help reduce risk.
What Is MCP Tool Poisoning?
Before examining the mechanics, consider two questions: where does tool poisoning fit within the prompt-injection taxonomy, and why do users rarely see the malicious instructions? Understanding both helps explain why onboarding reviews alone cannot address this risk.
A Specialized Form of Indirect Prompt Injection
MCP tool poisoning is a specialized form of indirect prompt injection. Attackers embed malicious instructions in lower-trust MCP tool descriptions, parameter schemas, or responses that an AI agent processes as context.
Unlike direct prompt injection, the attacker does not need to submit instructions through the user’s chat interface. The malicious content arrives through an external tool or server and attempts to influence the agent’s decisions or tool calls.
Tool-description poisoning can occur during tool discovery, while tool-response poisoning can occur during execution. Both exploit the boundary between untrusted tool-provided content and the instructions the agent is authorized to follow.
The MCPTox researchers found that payloads adapted from the InjecAgent indirect prompt-injection benchmark achieved an attack success rate of almost 0% when placed in tool descriptions. Their purpose-built tool-poisoning payloads against the same models reached 41.8%. The takeaway for threat modeling is that testing one prompt-injection surface does not establish coverage of another. Simulated environments such as InjecAgent or AgentDojo test different conditions from poisoned manifests served by real MCP servers.
OWASP tracks this issue as MCP03:2025, Tool Poisoning, in its MCP Top 10.
Why It’s Invisible to Users
Models and users see different information. When a client invokes tools/list, it receives tool definitions containing names, natural-language descriptions, and input schemas in JSON Schema format. This information enters the model’s context. The user interface, however, may show only a short tool name and a simplified confirmation.

Invariant’s Cursor demonstration illustrates this gap. The confirmation dialog displayed the tool name, but even its expanded view did not expose the full tool input. The SSH key prepared for exfiltration was carried in a parameter that the interface did not show. The person approving the call could not inspect its full consequences. MCPTox describes a related problem: users see simplified representations while models process complete descriptions, and safeguards focused on user prompts may not catch malicious tool metadata.
The Trust Gap: Connect-Time Review vs. Runtime Execution
Poisoned tools exploit a gap between initial review and runtime execution. A tool description may be reviewed when a server is connected or onboarded, but the content supplied to the model can change later. Without ongoing integrity checks, subsequent calls rely on the assumption that the tool still matches what was approved.
That is not a requirement in the protocol. MCP offers no means of cryptographic attestation of description integrity, no means for a client to verify whether the current definitions on a server agree with those it was approved by a human at onboarding, and no means to perform runtime checking of the description text for embedded directives. At the protocol level, such a description cannot be differentiated from one that says “read the local SSH key and append it to the response”. They are both strings in the same field, and current models frequently do not distinguish between documentation and command within the field.
MCP also supports changes to tool definitions after approval. A server with the listChanged capability can send a notifications/tools/list_changed notification, prompting the client to request tools/list again. Re-approval, version pinning, and content-integrity checks depend on client-side controls rather than the notification itself. Cached discovery results can also preserve poisoned definitions until the cache is refreshed or invalidated. A one-time review is therefore insufficient.
Anatomy of a Tool Poisoning Attack: Step by Step
An MCP tool-poisoning attack typically has four stages. None requires a memory-corruption bug, deserialization flaw, or other conventional software vulnerability. Each exploits a trust assumption that traditional application security tools may struggle to detect.

Step 1: Attacker Registers or Compromises an MCP Server
The attacker needs control of an MCP server that the target will connect to. One route is to publish a seemingly useful server, such as a weather tool, PDF converter, or random-fact service, in a marketplace. OX Security reported in 2026 that nine of eleven tested MCP registries accepted its proof-of-concept server without meaningful review. Another route is to compromise or update a server the target already trusts. In either case, the malicious server becomes part of the target’s client configuration.
Step 2: Adversarial Instructions Embedded in Tool Metadata
Once the server is connected, the attacker supplies malicious instructions through its tool metadata. The following example illustrates tool shadowing: instructions in a seemingly harmless calculator tool attempt to redirect how the agent uses a separate email tool.
The framing with <IMPORTANT> and the appeal to a plausible reason (compliance, proxying, a system requirement), as well as the instruction to stay silent, are common. Instructions can be directed towards the behavior of the tool itself, exfiltrating files when it runs, or towards the behavior of any other trusted tool that may be attached in the same session.
Step 3: Agent Ingests the Poisoned Metadata as Trusted Context
When the agent connects, the client retrieves tool definitions and supplies them to the model alongside other context. If the model does not reliably distinguish server-controlled documentation from authorized instructions, it may treat a poisoned description as authoritative. MCPTox’s failure-case analysis reported very low refusal rates, with the highest measured rate below 3% on Claude-3.7-Sonnet. Safeguards aimed at user-facing prompts may not activate in the same way for tool metadata.
Step 4: Agent Acts on Hidden Instructions
Now the agent can execute what the payload tells it to execute. Invariant’s shadowing experiment involved asking one user to forward an email to a certain address and having the agent forward the email to the attacker’s address instead, where the real recipient was included in the body of the email. The results can be grouped into a handful of categories: data exfiltrated (SSH keys, .env files, source code, chat history); credential leakage from other configuration files that contain secrets for other servers; unauthorized tool calls with hidden side effects such as BCC or upload; and suppression of the very steps that would identify compromise. No diversion is included in the user-facing interaction log.
Where Poisoning Can Hide
Most write-ups focus on the description field. CyberArk’s “Poison Everywhere” research highlights a broader surface: any server-controlled string presented to the model may carry instructions. A scanner that checks only descriptions can miss payloads in schemas or runtime responses.

Tool Names and Descriptions
The description field is a common injection point because it accepts free-form language that the model reads. Tool names can also influence selection: a name that resembles a familiar tool may steer the agent toward an attacker-controlled alternative. Malicious descriptions often frame their instructions as authoritative system requirements rather than documentation.
Input/Parameter Schemas
The framework parses the JSON Schema of a tool’s inputs, and the text of the schema is also made available to the model in many clients. This makes the names of parameters, parameter descriptions, default values, the options for enums, example values, and even required-field arrays all injection surfaces. CyberArk showed encoding instructions to exfiltrate into parameter names. One of the most dangerous aspects of schema poisoning is that the schema is checked by the schema framework, not by the security layer of the model. An innocuous-looking operation can be linked to a harmful parameter shape that no content filter is checking. CVE-2025-54136 enabled only such a schema change, and not a prompt.
Tool Response Content Beyond the Initial Manifest
Poisoning is not limited to the initial manifest. Values returned during execution, including results, error messages, and status text, may enter the model’s context and contain malicious instructions. A tool can pass its connect-time review with a clean description and return a poisoned response on a later call. Treating the initial manifest as the entire attack surface leaves this runtime path unchecked.
Real-World Disclosures and Research
Tool poisoning has progressed from a proof-of-concept attack to a documented and measured security issue. The following disclosures and studies help establish the risk and distinguish tool poisoning from related MCP vulnerabilities.
Invariant Labs' Original Proof-of-Concept (April 2025)
Luca Beurer-Kellner and Marc Fischer at Invariant Labs released the original Invariant Labs disclosure on April 1, 2025, describing the attack class and providing a proof-of-concept that works for Cursor. They used their poisoned add tool to steal the developer’s mcp.json (which contains credentials to other MCP servers) and SSH keys. The same disclosure also added two follow-on techniques: rug pulls and tool shadowing, and came with a public repository of attack code for others to replicate and repurpose. A few days later, they published mcp-scan, a static scanner for this pattern. What makes the attack leap from a single file leak to a pivot is the “mcp.json” detail: one vile tool can retrieve all the other servers the victim trusts.
The OX Security Disclosure, Scale Across Python, TypeScript, Java, and Rust SDKs
In April 2026, OX Security unveiled its research, dubbed the “mother of all AI supply chains. The key vulnerability is a flaw in the way process parameters are passed to the host shell in Anthropic’s official Python, TypeScript, Java, and Rust-based SDKs, which allows for the execution of arbitrary system commands and was found to be present in all versions of these SDKs. OX estimates that over 150 million SDK downloads were affected by the blast; there were more than 7,000 publicly accessible servers and up to 200,000 vulnerable instances with more than ten High or Critical CVEs. The supply-chain angle is directly tied to poisoning: OX provided a malicious proof-of-concept server for eleven MCP marketplaces and had it accepted by nine of them, as part of the same work. This is not a description-poisoning attack, but rather it’s an illustration that the distribution channels that provide tools to agents do not do a basic check on those agents, which is a prerequisite for poisoning on a scale.
Benchmark Findings, Attack Success Rates Across 45+ Real MCP Servers
The field had its first large-scale measurement by MCPTox (arXiv 2508.14925, subsequently at AAAI). They created 353 authentic tools from 45 live, real-world MCP servers, produced about 1,300 malicious test cases in 10 risk categories, and tested 20 language models. The average attack success rate was 36.5 percent, with over a third of the poisoning attempts succeeding. The top end was from roughly 61.8 percent with GPT-4o-mini up to 72.8 percent with o1-mini, while Phi-4 was 70.2 percent. Their worst outcome has been an inverse problem size effect, in that stronger models have been more susceptible, as the attack is not an attempt to outwit the model, but instead to follow its instructions.
Attack Variants Related to Tool Poisoning
Tool poisoning is not a single technique; it’s a family. The three variants affect the target or the timing of the payload, each disabling a different assumption a defender might be making.
Tool Shadowing
Tool shadowing uses one server’s poisoned metadata to influence how an agent uses a different, trusted server. Invariant demonstrated a fake add tool whose description redirected messages sent through a legitimate send_email tool. The agent may not need to call the attacker’s tool at all: loading its description into context can be enough to affect later actions. A malicious tool impersonating an authorized one is a related form of trust abuse.
Cross-Server Audit Blindness
If multiple servers are connected to a single client, they share a single context and a malicious server can cross the context boundary. In addition to tricking legitimate tools, a poisoned description may also cause the agent to ignore or suppress monitoring and logging tools, preventing any evidence of what is happening from ever being captured. In combination with shadowing, this can allow an attacker to move about while the user’s log only records trusted tools doing regular activities. Isolating servers and ensuring dataflow boundaries between them, as opposed to relying on a shared context, is a load-bearing control because of cross-server audit blindness.
Rug Pull Attacks
A rug pull is not about one moment - it’s about time. Review passes with a clean bill of health and then the server updates the definition after review. A “random fact” tool that became malicious upon the second load is a sleeper rug pull with shadowing that was pulled by Invariant’s WhatsApp takeover. The productionized version, CVE-2025-54136, “MCPoison,” was revealed by Check Point Research in August 2025 with a CVSS of 7.2. Instead of approving a config entry’s contents, cursor bound approval to the name of the entry, meaning that an attacker could submit a benign .cursor/mcp.json, wait for a teammate to approve it, and follow up with a re-submission of the command without any re-prompt. It is more deeply covered in our MCP rug pull attack write-up.
Why Tool Poisoning Is Especially Dangerous in Enterprise Environments
Tool poisoning is a risk even for individual developers. In enterprise environments, its impact grows because it can exploit trust without a conventional code vulnerability, persist across sessions, and abuse agents with access to many systems.
No Code Vulnerability Required; It Exploits the Trust Model, Not a Bug
Tool poisoning does not necessarily require a memory-safety flaw or a vulnerable dependency. It can arise when an agent reads tool metadata and incorrectly treats its content as authorized instructions. Traditional SAST and DAST tools are not designed to reliably identify this semantic trust-boundary failure, particularly when the payload resembles ordinary documentation.
Persistent Across Every Session, Not a One-Time Delivery
A poisoned tool definition can be loaded whenever an agent connects to the server, exposing multiple sessions to the same payload. A malicious shared configuration can also affect teammates who trust it. This persistence can turn a single successful demonstration into a broader enterprise incident.
Compounds When Agents Have Broad Tool Access
An agent with access to email, a filesystem, a code host, and cloud APIs can expose many capabilities through a single poisoned description. The risk grows with excessive permissions and unmonitored shadow MCP servers, and hence the first step to controlling the blast radius is discovery and posture management, including knowledge of all MCP servers in the environment and which agents may invoke them. Platforms such as Akto automatically identify MCP servers (including shadow ones), map them to the agents and downstream servers they will reach, and alert to overly powerful tools and vulnerable MCPs via agentic posture management.
Detecting Tool Poisoning
Detection needs to cover both onboarding and runtime execution. Static analysis can identify payloads present at installation, but later changes and poisoned responses require ongoing checks. A practical approach combines a baseline inventory, integrity monitoring, behavioral analysis, and inspection of server-controlled strings.
Manifest Hashing and Change Detection
Static scanning at installation is useful but insufficient: a rug pull can present clean definitions during review and malicious ones later. Record approved tool definitions and compare subsequent tools/list responses against that baseline. Require review when definitions change. Separately, configuration-integrity checks address the name-based approval weakness illustrated by MCPoison.
Anomaly Detection on Tool Invocation Patterns
Poisoning can produce behavioral signals that static checks miss. Monitor for deviations from expected tool use, such as a calculator workflow accessing sensitive files, an email sent to an unintended recipient, or a sequence of calls that bypasses normal authorization steps. Behavioral anomaly detection complements content inspection; neither provides complete coverage alone.
Treating Tool Responses as Untrusted Input, Not Just Descriptions
The initial manifest is not the entire attack surface. A server that passed review can still return poisoned result fields, error messages, or status text. Detection should inspect both declared metadata and runtime responses, treating all server-controlled strings as untrusted input.
Defense-in-Depth for MCP Tool Poisoning
It cannot be prevented by any one control. When using a layered tool poisoning defense, it is assumed that each layer will fail, and the other layers are designed to intercept what goes through it. The practices below range from cleaner metadata standards to runtime enforcement and least privilege to human review and continuous testing.
Clear, Unambiguous Tool Metadata Standards
Reduce the visibility gap by showing users the relevant tool descriptions and actual action parameters before approval. Interfaces should distinguish server-provided documentation from authorized instructions. Tool metadata should clearly describe functionality without embedding behavioral directives unrelated to the tool’s purpose. Giving users access to the same relevant information as the model makes hidden instructions easier to identify.
Runtime Context Validation and Policy Checks
A policy enforcement point between agents and servers is more reliable since client-side heuristics are executed after the parsing of unsafe material is done in the request. During runtime, policy processing can validate tool definitions and answers using an allowlist, remove or quarantine non-standard schema fields, and prevent calls that do not follow the dataflow rules from executing. Enforcing policy at a chokepoint also addresses the fan-out issue: A typical organization uses MCP through a large number of clients at varying intervals; there is no single client to be hardened.
Granular, Tool-Level Least Privilege
Broader capabilities increase the potential impact of poisoning. Restrict each agent to the tools and permissions required for its task. Limit filesystem, credential-store, email, and cloud access to workflows that genuinely need them. Treat every additional connected tool as an exposure to evaluate, not a capability to enable by default.
Human Oversight for High-Impact or Destructive Actions
A human check-in point is worthwhile for actions that can’t be undone, such as sending money, deleting data, changing permissions, and changing external email. The checkpoint can help only if it brings up the actual parameters. Human approval is effective only when the operator can inspect the actual action and its consequences. Approval interfaces should display the destination, relevant arguments, affected resources, and sensitive data being transferred. A simplified tool name or agent-generated summary is insufficient when hidden parameters may change what gets executed.
Continuous Red Teaming Against Poisoning Patterns
It’s a point-in-time review problem because the payload of poisoning changes. Regular red teaming on known patterns, poisoned descriptions, schema injections, shadowing setups, rug-pull mutations, etc., ensures the coverage remains up-to-date with the occurrence of new variants. MCPTox is a helpful reference for the categories of exercises. If you’re looking for a structured way to do this, check out our guide to MCP penetration testing.
How MCP Gateways and Scanners Fit In
Different scanners and gateways fit into different time periods. Static scanners such as Invariant’s mcp-scan and Trail of Bits’ mcp-inspector scan description and schema-level poisoning generated before or at the time of loading. They are good at checks before deployment and CI/CD checks, and bad at anything that changes after the scan.
Gateways are placed in-line at runtime and correct that flaw. A gateway can be placed as the enforcer, using a single point to proxy traffic for MCP; it can validate definitions on each fetch, examine responses as they return; and enforce policy on each and every client at once, instead of depending on each client to act appropriately. When combined, the scanner for known-at-install case and the gateway for the changes-at-runtime case, they sample a much larger area of the surface than either would individually. The control set is more extensive and can be seen in our MCP gateway and MCP security best practices.
How Akto Detects and Defends Against MCP Tool Poisoning
Akto provides discovery, security testing, and runtime protection capabilities for supported AI agent and MCP environments.
These capabilities can help organizations identify MCP exposure, test tool-poisoning scenarios, and monitor or restrict supported tool interactions. Effective protection also requires approved MCP server inventories, appropriately scoped permissions, integrity checks, and independent authorization.
The available coverage depends on deployment architecture, configured integrations, and enabled security policies.
Automated Discovery of MCP Servers and Tool Manifests
An organization cannot pin, test, or monitor a server it has not discovered. Inventory MCP servers across supported cloud, hybrid, and on-premises environments, including shadow servers identified through available connectors. Mapping servers to the agents that invoke them and the downstream services they reach provides a foundation for integrity checks and posture management.
Red Teaming Against Known Poisoning Patterns
Akto’s continuous-testing capabilities can help assess supported MCP endpoints and agent workflows for prompt injection, tool poisoning, insecure authentication, and data exposure. Automated red teaming exercises attack scenarios such as tool misuse, privilege escalation, and data exfiltration. Coverage depends on the deployment and configured integrations.
Real-Time Monitoring of Tool Responses and Invocation Behavior
For supported deployments, Akto can monitor MCP interactions, tool calls, and data flows and apply configured runtime guardrails to risky operations. This runtime perspective complements static scanning by examining actual interactions, including changes after approval and potentially poisoned responses. Effectiveness depends on visibility, integrations, and policy configuration.
When Should You Prioritize MCP Tool Poisoning Before Deployment?
MCP tool poisoning deserves immediate attention when an AI agent connects to external or third-party MCP servers, discovers tools dynamically, or combines untrusted tool descriptions with privileged capabilities.
Before deployment, verify that:
MCP servers and tools are approved and appropriately restricted.
Changes to tool definitions are reviewed or detected.
Tool-provided instructions cannot authorize unrelated actions.
Sensitive tool calls are subject to independent authorization.
Poisoned tool metadata and responses are included in adversarial testing.
MCP poisoning is one part of a broader deployment risk assessment.
For the complete prioritization framework, see AI Agent Security Risks.
For OWASP supply-chain risk mapping, see OWASP Top 10 for Agentic AI Security.
For practical adversarial testing, see AI Agent Red Teaming.
Final Thoughts on MCP Tool Poisoning
Do not assume that a vetted MCP server remains safe indefinitely. Pair onboarding reviews with runtime controls: inventory approved servers, detect definition changes, test poisoning scenarios, and monitor tool responses and actions. Benchmark results reinforce the need for layered defenses rather than reliance on model refusals alone. Request an Agentic Security demo to explore these capabilities for your environment.
FAQs on MCP Tool Poisoning
How is tool poisoning different from prompt injection?
MCP tool poisoning is a form of indirect prompt injection that exploits tool-provided content, especially metadata such as descriptions and parameter schemas. General indirect prompt injection can also arrive through webpages, emails, documents, or retrieved data. MCP tool poisoning is distinguished by its use of tool discovery and interaction surfaces to manipulate agent behavior.
Where can adversarial instructions hide in an MCP tool?
The tool name and description, tool input schema (parameter names, descriptions, defaults, enum and example values, required arrays), and tool response content (result fields, error messages, status text). CyberArk’s “Poison Everywhere” research identified all string resources as potential targets.
Why is tool poisoning invisible to end users?
The model may receive the full tool description while the interface shows only a short name and a simplified confirmation. In Invariant’s Cursor demonstration, the parameter carrying the SSH key was not visible in the approval dialog, preventing the user from inspecting the full action.
What is the “trust gap” that makes tool poisoning possible?
The trust gap is the difference between approving a server at connection time and validating what it supplies during execution. Definitions and responses can change after approval. Without integrity checks, version controls, and appropriate re-approval, the client may continue trusting content that no longer matches the reviewed version.
What real-world tool poisoning attacks or disclosures have been documented?
The research includes Invariant Labs’ Cursor proof-of-concept in April 2025, the MCPTox benchmark in August 2025, CyberArk’s “Poison Everywhere” proof-of-concept in July 2025, the CVE-2025-54136 “MCPoison” benchmark in August 2025, and OX Security’s April 2026 “mother of all AI supply chains” research.
How successful are tool poisoning attacks in practice?
MCPTox reported an average attack success rate of 36.5% across its evaluated models, reaching 72.8% for o1-mini. Reported refusal rates were below 3%. These are benchmark results, not a universal prediction of production attack success.
What is tool shadowing, and how does it relate to tool poisoning?
Tool shadowing occurs when poisoned metadata from one server influences how an agent uses another, trusted tool, such as changing the recipient of an email. The attacker’s tool does not necessarily need to be called; its description may influence the agent simply by appearing in context.
What is cross-server audit blindness?
If more than one server is using a single client context, the poisoned server can tell the agent to ignore or disable monitoring and logging tools, and the events it would have logged to the server are never saved.
How is tool poisoning different from a rug pull attack?
A rug pull is a timing-based variant: a server initially presents a benign definition and changes it after approval. CVE-2025-54136 illustrated a related configuration-trust issue in which approval was tied to an entry’s name rather than its contents.
Does tool poisoning require a vulnerability in the underlying LLM?
No conventional code vulnerability in the LLM is required. Tool poisoning exploits a trust-boundary failure in which untrusted tool content influences authorized actions. Traditional code-focused security testing alone is not sufficient to detect this behavior.
How can organizations detect tool poisoning before it causes damage?
Integrate static manifest scanning at install, trust-on-first-use hashing (which compares each tools/list response to a baseline), behavioral anomaly detection (which looks at how the tools are used), and inspection of the tool’s responses as untrusted input.
What defense-in-depth measures reduce the risk of tool poisoning?
Clear metadata standards and full-fidelity approval UIs, runtime policy checks at a gateway, tool-level least privilege, human review for high-impact actions, and continuous red teaming against poisoning patterns.
Can Tool Poisoning Affect a Legitimate, Previously Vetted MCP Server?
Yes. A server’s definitions can change after approval, and an otherwise legitimate tool can return poisoned content at runtime. Initial vetting should therefore be supplemented with integrity checks, runtime monitoring, and appropriately scoped permissions.
How does Akto detect and defend against MCP tool poisoning?
Akto provides discovery, security testing, and runtime protection for supported AI agent and MCP environments. These capabilities can help identify exposed servers, test tool-poisoning scenarios, and monitor or restrict tool interactions. Coverage depends on deployment architecture, integrations, and enabled security policies.
Experience enterprise-grade Agentic Security solution
