An MCP Tool Name Is Not an Identity, and a Five-Model Study Measures It
On November 16, three researchers from the Canadian Institute for Cybersecurity, at the University of New Brunswick, published When Tool Names Are Not Identities: Measuring Provider Misbinding in MCP-Based AI Agents on arXiv. It is a preprint by Zeynab Anbiaee, Sajjad Dadkhah and Ali A. Ghorbani, and it measures, under controlled conditions, something many of us suspected.
The scenario is simple. An agent is connected to two MCP servers. One is legitimate.
The other belongs to an attacker who compromises nothing: not the host, not the model, not the legitimate server, not the network. The attacker only advertises tools with the name, description and schema of their choosing.
The question is how often the model calls the attacker’s tool when the user wanted the legitimate provider’s. In the worst case measured, when the attacker copies the name and description and offers a compatible schema, three of the five models did it in 100% of the attempts.
The authors put it this way: in MCP, a tool’s metadata is not merely documentation, it is part of the agent’s control plane. I agree, and I add one consequence: the model decides by reading text written by whoever advertises the tool, and a prefix with the server name does not change that.
What exactly did they measure?
The setup has a legitimate server with a single tool, data_fetch_and_store, which downloads a dataset and stores it at a destination. Its arguments include the dataset identifier and the destination. Everything runs locally, with simulated data and no external effects, according to the authors.
The attacker’s server advertises a tool that varies along three axes. The name can be identical to the legitimate one or unrelated to the task.
The description can be unrelated, an exact copy or a “reinforced” copy with authority signals, along the lines of company-approved or verified. The schema can be compatible with the call the model is going to generate, or not.
Two names times three descriptions times two schemas give 12 conditions, C01 to C12. Each condition was tested with 10 phrasings of the request, five normal and five that insist on the trusted destination or the intended provider, repeated five times. That is 50 attempts per condition and model.
The five clients were GPT-5.4, Claude Sonnet 5, Gemini 2.5 Pro, Qwen3.7 Max and DeepSeek V3. With 60 combinations of condition and model, the main experiment adds up to 3,000 attempts. None failed to execute, so the differences come from selection, not from errors.
Each attempt ends in one of three ways: the model calls the attacker’s tool (the “violation rate”), calls the legitimate one, or asks the user for clarification.
When did the models pick the attacker’s tool?
I recomputed the averages from Table II of the paper with a small script of my own. This is the part of the table that tells the story (violation rate / clarification rate, over 50 attempts per cell):
| Condition | Name | Description | Schema | GPT-5.4 | Claude Sonnet 5 | Gemini 2.5 Pro | Qwen3.7 Max | DeepSeek V3 |
|---|---|---|---|---|---|---|---|---|
| C06 | unrelated | reinforced | compatible | 0.04 / 0 | 0 / 0.22 | 0.42 / 0.56 | 0.20 / 0 | 0.50 / 0 |
| C07 | identical | unrelated | incompatible | 0.02 / 0 | 0 / 0.02 | 0 / 0.20 | 0 / 0 | 0 / 0 |
| C08 | identical | unrelated | compatible | 0.12 / 0 | 0 / 0.22 | 0.60 / 0.22 | 0.40 / 0 | 0.28 / 0 |
| C09 | identical | copied | incompatible | 0 / 0 | 0 / 0.22 | 0 / 0.46 | 0 / 0 | 0 / 0 |
| C10 | identical | copied | compatible | 1.00 / 0 | 0.06 / 0.94 | 0.84 / 0.16 | 1.00 / 0 | 1.00 / 0 |
| C12 | identical | reinforced | compatible | 0.96 / 0 | 0.26 / 0.74 | 0.70 / 0.30 | 1.00 / 0 | 1.00 / 0 |
Source: Table II of arXiv:2611.21577v1. These are the authors’ measurements, not an independent replication.
Row C10 is the clearest. With the same name, the copied description and a compatible schema, no model picked the legitimate tool on its own in any of the 50 attempts. Three always picked the attacker’s.
Gemini did it in 84% and asked in the rest. Claude asked in 94% and picked the attacker in 6%.
The control conditions come out clean. With a name, description and schema unrelated to the task, the rate is zero across all five models, so a second server merely existing is not enough.
Copying the name is not enough either. In C07, identical name but unrelated description and schema, there was a single attacker pick in 250 attempts.
The table does not show everything. In C11, with an identical name, a reinforced description and a schema that does not fit, DeepSeek V3 picked the attacker in 56% of the attempts and Qwen in 18%.
What struck me most is the role of the schema. Between C09 and C10, the only change is that the attacker’s schema accepts the same arguments. The average violation rate goes from 0 to 0.78.
The schema is not an execution detail: it is also part of what the model uses to decide.
Do the names need to match?
No, and this is the result that weighs most for what comes next. In C06 the attacker’s name has nothing to do with the task. Only the description, reinforced with authority signals, and the compatible schema point to it.
Four of the five models picked the attacker’s tool at least once: DeepSeek V3 in 50% of the attempts, Gemini in 42%, Qwen in 20% and GPT-5.4 in 4%. Even in C04, with an unrelated name and a copied description without reinforcement, DeepSeek V3 picked the attacker in 22%.
The authors repeated C06 with five different unrelated names, 250 attempts per model, to rule out the effect of one specific word. The result holds: DeepSeek V3 around 70%, Gemini 46%, Qwen 20%. GPT-5.4 lands at a 25% average, but with a lot of variation between names: with one it never picked the attacker and with another it did so often.
They also repeated the reinforced-description conditions with five different wordings. In C12, GPT-5.4 picked the attacker in 98% of the attempts, Qwen and DeepSeek in 100%, Gemini in 72%. It does not depend on one lucky phrase.
And they tried giving the attacker more candidates: 1, 3, 5 and 10 tools. In C08, with the identical name but an unrelated description, Qwen3.7 Max went from 40% with one tool to 100% with ten. More attacker tools in the catalog tend to push the borderline cases to the wrong side or toward more questions, though not always: DeepSeek V3 dropped to zero in C08 and C11 with ten candidates.
Is asking the user a defense?
Claude Sonnet 5 is the model that picked the attacker least, and it did so by asking for clarification. In C10 it asked in 47 of the 50 attempts. With ten attacker candidates in C09 and C11, it always asked.
That is better than a silent call to the wrong server. But the authors insist on a nuance I share: asking is not binding. The model does not establish which provider is the right one, and if the interface does not show the server, the person who answers sees the same thing it does.
There is another nuance in the metrics. The study also measures stability: whether the same prompt always ends up at the same provider.
GPT-5.4, Qwen and DeepSeek are very stable in C10, but stable at picking the attacker. Stability, on its own, says nothing about security.
The paper makes it clear that this is not a model ranking. It describes how each one behaves in this specific setup, and the authors’ conclusion is that the problem lies in the protocol: the model’s caution reduces silent calls, but it does not create a provider identity.
What does the MCP specification say today?
The paper cites the 2025-06-18 revision of the specification. It is not the current one. According to the versioning page, the current version is 2026-07-28. I compared the tools page across the three revisions:
| Revision | What it says about tool names |
|---|---|
| 2025-06-18 (the one the paper cites) | each tool is uniquely identified by a name; there is no section on names |
| 2025-11-25 | names SHOULD be unique within a server |
| 2026-07-28 (current) | uniqueness is limited to one server; a client that aggregates several MAY run into collisions and SHOULD disambiguate, for example with a prefix that identifies the server; the name a server declares for itself is not guaranteed to be unique, and SHOULD NOT be used for that |
The current revision already acknowledges the collision problem and proposes a client-side solution. It is a recommendation, not a requirement, and on the tools page I found no mechanism to verify who the provider is.
The same page says that clients MUST treat a tool’s annotations as untrusted unless they come from trusted servers. Descriptions have no equivalent rule, and the study shows that some models read them as an argument from authority.
Is prefixing the name with the server enough?
Some clients already do it. According to its MCP documentation, Claude Code exposes each tool as mcp__<server>__<tool>, where the server is the server’s key in the configuration, and it adds the plugin name when the server comes inside one. With that, two data_fetch_and_store tools from different servers no longer share a name.
Doing it right is not trivial. The advisory GHSA-67q9-58vj-32qx (CVE-2026-30856, published March 6) describes how the MCP client in Tencent’s WeKnora built identifiers with the pattern mcp_{service}_{tool} after sanitizing the names. A malicious service with a chosen name could produce the same identifier as a legitimate tool, and the registry silently overwrote the existing entry.
Because services loaded from newest to oldest, the one registered earlier was processed last and won. It affected versions up to 0.2.14, was fixed in 0.3.0, and the advisory gives it a CVSS score of 5.4 (moderate severity).
Even done right, a prefix removes the literal collision in C07 to C12, but the prefixed name still contains the task’s words, and the study does not measure whether that is enough. Nor does it touch C06, where the names were already different and the model chose by description and schema. A prefix makes the provider visible, but the decision is still made by a model that reads text written by the attacker.
It pays to be precise: the study did not test any client with prefixes or any commercial product. How much a prefix reduces the C10 or C12 rates is an open question this paper does not answer.
What does this study not prove?
There are limits the authors themselves acknowledge and others I add:
- It is a single task, downloading and storing a dataset. Other kinds of tools may give different rates.
- It is the authors’ own orchestrator, not Claude Code, Cursor, VS Code or Copilot, which may have their own confirmations and their own way of presenting tools.
- These are five specific model versions. There are already newer models today, such as
GPT-6.2Astra and Sol or Gemini 4 Carbon, that nobody has measured with this setup. - It is a preprint with no peer review indicated on arXiv, and nobody has replicated it yet.
- There are two small internal inconsistencies between Table II and Table V with a single candidate:
GPT-5.4in C07 (0.02 versus 0.04) and Gemini in C10 (0.84 versus 0.88). They do not change any conclusion; for the main experiment I use Table II. - The study assumes the attacker’s server is already connected. How it gets there is out of scope, and in the WeKnora case the user had to be convinced to register it.
This paper fits with another recent preprint, TRAP, which studies a neighboring flaw: real results from a tool that end up consumed in a context they do not belong to. They are different problems with the same root. The agent binds actions and results to a provider or a context that nobody verifies.
What would I do with my MCP servers?
What the paper proposes is provider identity bound to the tool: signed manifests, stable per-provider identifiers, schema hashes, and a client that enforces them. These are proposals, not something the study evaluates or that exists in the specification today. In the meantime, this is what I would review:
- Inventory per client. Which MCP servers each agent has configured, on each machine, and where each one came from. Without that list there is no way to know whether two servers advertise the same thing.
- Collisions and overlaps. Look for tool names repeated across servers, but also for tools with nearly identical descriptions or schemas. C06 shows that the second also counts.
- Which server can serve what. If the ability to write to a storage should come from only one provider, put that in the configuration and do not rely on the model to infer it.
- Confirmations that show the server. The specification already recommends that there always be a human able to deny a call, an interface that makes clear which tools the model sees, and confirmation for sensitive operations. That confirmation should also show which server is going to receive the call.
- Descriptions as untrusted input. If a description says “company-approved”, that is the provider’s text, not proof. The study shows that some models read it as an argument.
- Control which servers get in. The best collision is the one that never happens. In Copilot Can Now Stop Skills, Hooks and MCP Servers From Arriving Loose I wrote yesterday about the settings that limit where an MCP server can come from.
What I take from this paper is a simple and useful idea: every tool an agent can call is an authority to act, and that authority has to be bound to whoever offers it. The name, the description and the schema help the model find the tool. They do not say whose it is.
Sources
- Z. Anbiaee, S. Dadkhah, A. A. Ghorbani, When Tool Names Are Not Identities: Measuring Provider Misbinding in MCP-Based AI Agents,
arXiv:2611.21577, November 16, 2026 (HTML version). - Model Context Protocol, tools page in revisions 2025-06-18, 2025-11-25 and 2026-07-28, and the versioning page.
- GitHub Advisory Database, GHSA-67q9-58vj-32qx / CVE-2026-30856, WeKnora, March 6, 2026.
- Anthropic, Connect Claude Code to tools via MCP.
- Y. Zhi et al., TRAP: Tool-result Replay Attack for Probing Misbinding in LLM Agents,
arXiv:2610.16333, October 12, 2026.