New research shows the Model Context Protocol (MCP)—the interface that lets large-language-model (LLM) agents call external tools—can be hijacked through “tool-poisoning” attacks that succeed more than one-third of the time. Across 20 popular agents the average success rate was 36.5 %; the o1-mini model fell in 72.8 % of attempts, while Claude-3.7-Sonnet refused malicious calls under 3 % of the time. For anyone deploying LLM agents that rely on MCP, the findings turn a convenience feature into a supply-chain risk that can be exploited before any code ever runs.
Why MCP matters to developers today
MCP standardises how agents discover, register, and invoke tools such as file readers, web APIs, or email senders. By publishing a tool’s name, input schema and a short description, a server makes the capability available to any client that understands the protocol. The promise is simple: an agent can look up a tool, send a request, and receive a response without hard-coding each integration.
That flexibility also creates an implicit trust relationship. The specification tells clients to treat tool descriptions as trustworthy only if they come from a server the client already trusts. The new study shows that this trust can be abused.
How tool-poisoning differs from ordinary prompt injection
Traditional prompt injection inserts malicious instructions into the text that the model generates or receives at runtime. The model then follows those instructions because they appear in the same token stream as the user’s request.
Tool-poisoning, by contrast, hides the payload in the tool’s metadata—the name, description, or parameter schema that registers before any agent call. When an agent later selects the tool, it treats the description as part of the “trusted context” and may follow the hidden instruction without any runtime check. Because the injection occurs during registration, there is no point in the execution flow where a model can flag the payload as suspicious.
Scale of the problem – the MCPTox benchmark
The researchers behind MCPTox (arXiv:2508.14925) evaluated 45 MCP servers offering a total of 353 distinct tools. They scripted attacks against 20 widely used LLM agents, measuring how often the agents executed the poisoned tool call.
- Average success rate: 36.5 %
- Peak success: o1-mini at 72.8 %
- Best refusal: Claude-3.7-Sonnet, still under 3 %
The numbers reveal a stark reality: most agents do not refuse a poisoned call because the request looks like a legitimate tool invocation. The agents assume the tool description is a benign piece of documentation, not a vector for code execution.
Why agents rarely refuse poisoned calls
OWASP’s LLM01 guideline explains that LLMs do not differentiate between instructions and data—both are just tokens in a sequence. When a tool description says “send an email to admin@example.com with the subject ‘Update’”, the model cannot tell whether that line is a harmless comment or an instruction it should obey later. Consequently, the model treats the description as part of the trusted environment and follows any embedded command when the tool is invoked.
Existing guidance and its gaps
The MCP specification already advises clients to treat tool descriptions as untrusted unless they originate from a trusted server, and to keep a human in the loop for high-impact calls. The benchmark shows that many real-world deployments ignore or loosely interpret these recommendations.
Concrete steps developers can take today
- Figer les versions des serveurs – Référencez une image de serveur ou un hash spécifique et immuable plutôt qu'une balise mobile. Cela empêche un attaquant de remplacer un registre sain par un registre empoisonné après le déploiement.
- Commencer avec une liste d'autorisation vide – N'activez que les outils qui ont été explicitement validés. Tout ce qui ne figure pas sur la liste est bloqué par défaut.
- Contrôler les outils modifiant l'état – Exigez une approbation supplémentaire pour tout outil qui écrit, envoie ou supprime des données. Séparez les capacités « lecture seule » des capacités « écriture » dans le schéma.
- Ajouter une approbation humaine pour les appels à fort impact – Pour les actions susceptibles d'affecter des systèmes externes (par exemple, l'envoi d'e-mails, l'exécution de commandes, la modification de fichiers), sollicitez un réviseur humain avant que l'appel ne soit envoyé.
- Journaliser chaque invocation d'outil – Enregistrez le nom de l'outil, les arguments, l'horodatage et l'agent à l'origine de l'appel. Une piste d'audit immuable rend l'analyse post-mortem réalisable et peut dissuader les attaquants qui savent que leurs actions seront visibles.
Traitez chaque description d'outil comme du code source — soumis au linting, à la revue de code et au contrôle de version — afin d'aligner la chaîne d'approvisionnement MCP sur les pratiques standard de développement logiciel.
Contre-arguments et questions ouvertes
Le benchmark montre toutefois que même le modèle le plus avancé de l'étude a refusé moins de trois pour cent des appels empoisonnés. Le fine-tuning peut améliorer la détection, mais il ne peut garantir la sécurité contre de nouvelles charges utiles intégrées dans des champs de schéma que le modèle n'a jamais vus.
À surveiller ensuite
- Normes émergentes – Surveillez les propositions de la communauté de sécurité des LLM visant à exiger des signatures cryptographiques sur les schémas d'outils.
- Renforcement des registres d'outils – Les fournisseurs pourraient commencer à proposer des registres immuables et en lecture seule en tant que service, réduisant ainsi la surface d'attaque.
- Défenses au niveau du modèle – La recherche sur les techniques de prompting ou les modèles auxiliaires qui signalent les métadonnées d'outils suspectes pourrait compléter les mesures de protection côté hôte.
La conclusion pratique est claire : tout déploiement basé sur MCP devrait auditer les descriptions d'outils avec la même rigueur appliquée aux bibliothèques tierces. Ignorer le risque lié à la chaîne d'approvisionnement transforme une abstraction pratique en une porte dérobée silencieuse. En figeant les serveurs, en imposant des listes d'autorisation basées sur le principe du moindre privilège, en contrôlant les actions modifiant l'état, en impliquant des humains lorsque nécessaire et en tenant un journal immuable, les développeurs peuvent empêcher leurs agents LLM de devenir des complices involontaires.