The vulnerabilities are not the story. The story is that nobody added this dependency: a package name came out of the model's weights, the agent wrote it into an MCP client config, npx resolved it from the registry, and a process that can read your filesystem and spend your tokens was running — with no entry in any lockfile, nothing for a dependency scanner to scan, and an upstream repository that was archived in 2025 and will not be patched. Glow Labs published the research on 2 November 2026 and calls the pattern MCPhantom. The uncomfortable framing comes from the Cloud Security Alliance research note on it: model knowledge is now a software supply chain, and it is an unpatchable one.
At a glance
Four claims from the research, with what each one actually rests on. The specifics are Glow Labs' account of its own work, relayed through trade coverage; the structure is checkable against any agent and any registry.
| Claim | What it says | Where it comes from | How to check it yourself |
|---|---|---|---|
| Agents name servers from memory | Install commands come from recalled package names, not a live registry lookup | Glow Labs, 2 Nov 2026 | Ask an agent to add an MCP server for a service; watch whether it searches first |
| The targets are mostly archived | Most affected packages are the original MCP reference servers; several archived during 2025 | Glow Labs; the repositories' own archive notices | Open the GitHub repo behind the package your agent just added |
| No patch is coming | Four high-severity findings, including a Puppeteer-server flaw reachable by prompt injection, closed as out of scope on an archived repo | Glow Labs; the maintainer response it quotes | Read the issue tracker on an archived reference server |
| Deprecation does not stop it | A deprecated npm package still installs and runs through npx |
Glow Labs; npm's documented behaviour | Run npx against any deprecated package |
Why a lockfile has nothing to say about this
Supply-chain tooling is built on a single assumption: that somebody declared an intent, and the tooling's job is to constrain how that intent is satisfied. package.json records the intent, the lockfile pins the resolution, a scanner reads the lockfile, and a review reads the diff. Every one of those four controls takes the declaration as its input.
An agent-initiated MCP server install produces no declaration. The package is not a dependency of your project; it is a command in a client configuration file — typically a command and args pair that runs a package runner at startup. There is no version range to pin, because the config does not usually carry one. There is no lockfile entry, because npx is not installing into your project. There is no diff for a human to review if the agent wrote the config itself. And there is nothing in the repository for a scanner to find, because the artefact lives in a per-user config directory, not in the tree.
The deprecation row is the one worth sitting with, because it is where the obvious fix fails. npm's deprecate command marks a package and prints a warning; it does not unpublish it and it does not make an install fail. In an interactive terminal a human might read that warning. In an agent run the warning is one line of stdout among thousands, and the agent's own success criterion — the server started, the tool list came back — is fully satisfied. Glow Labs reports that the maintainers would consider marking the packages deprecated, and notes the limitation plainly: a deprecated package still installs through npx. Marking is a signal to a reader. There is no reader.
This is also why "pin your versions" is the wrong instruction here, and giving it will make a team feel safer without being safer. Pinning solves drift: the thing you chose changing underneath you. The defect here is upstream of version selection entirely — it is that the name was chosen by a process with no access to the present tense. You cannot pin your way out of a recommendation.
Archived is a stronger word than unmaintained
An unmaintained package is a risk you can reason about: someone might come back, a fork might appear, a report might eventually be triaged. An archived repository is a closed door with a notice on it. Glow Labs' finding against the Puppeteer reference server is the illustrative case — a flaw reachable through prompt injection, reported, and closed as out of scope on the grounds that the repository was archived in May 2025. That response is correct. It is also the end of the road: the advisory will not be issued, the version will not be published, and the npx command the agent wrote will keep resolving to the same bytes for as long as the registry serves them.
Be precise about scope, though, because the headline invites over-generalisation. Not every original reference server was archived — the filesystem server, for instance, is still maintained and has published advisories with fixed versions during 2026, which is exactly what a live project looks like. The population at issue is the archived subset, and the reason it matters disproportionately is that those names are the ones most thoroughly represented in training data: they were the canonical examples for a year, in every tutorial and every README, before the ecosystem moved to first-party servers maintained by the services themselves.
That is the mechanism in one sentence, and it generalises past MCP entirely. A model's recall is weighted by how much the internet talked about something, and the internet talks most about whatever was canonical eighteen months ago. Training data is a popularity index with a lag. Any system that lets a model's recall select an artefact to execute inherits that lag as a default, and the default points at whatever has since been superseded. The same shape shows up in knowledge cutoffs and time, and the hallucinated-package-name variant of it — where the recalled name does not exist at all and an attacker registers it — is the older and better-known half of the problem.
The 98% figure, read carefully
Secondary write-ups lead with a number: agents chose deprecated MCP servers in 98% of tracked sessions. Treat it as a figure about a conditional population, because that is what it describes. The reading supported by the coverage is that in 98% of the sessions where a deprecated server was set up, the user had not asked for that server by name. That is a statement about attribution — the choice was the agent's, not the human's — and it is the interesting claim, because it is what makes this a systems problem rather than a user-education problem.
What it is not is a measure of how often agents choose badly overall. One commentator on the research makes exactly this point: the work says nothing about the rate at which agents pick maintained servers correctly. If you want that denominator you will have to measure it in your own environment, and the measurement is cheap — scan the MCP configs on twenty developer machines and count.
Run that scan before you decide how much to care. ~/.cursor/mcp.json, ~/.codex/config.toml, .mcp.json in project roots, the equivalents for whatever clients your team uses — grep for @modelcontextprotocol/, resolve each package to its repository, and check whether that repository is archived. The result is the only prevalence number that matters to you, it takes an afternoon, and an open-source offline detector for exactly this check exists if you would rather not write the script.
What actually works, in order of how much it buys
The controls that help all share one property: they act before resolution, on the name, rather than after it, on the artefact.
- An allowlist of permitted MCP servers, enforced at the client. This is the only control in the matrix above that both sees and blocks. It is also unfashionable, because it means someone maintains a list. Maintain the list. The set of servers a team actually needs is small and changes slowly, and the alternative is that the set is chosen per-session by a process optimising for a server that starts.
- A pre-install hook that refuses deprecated or archived packages. If your client supports a lifecycle hook — and the risk surface of those hooks is its own subject, covered in lifecycle hooks and harness config — the check is a registry metadata lookup plus a repository-status lookup, and it fails closed. This is the pattern several people published within days of the research, and it is the right shape.
- Prefer the service owner's own server. Where a vendor now ships a first-party MCP server, the reference implementation the model remembers is the wrong answer regardless of its security posture, because it is a demo and the first-party one is a product.
- Add registry and repository status to your approval criteria. Deprecation state, last publish date, repository archive flag, and whether the publishing account matches the service it claims to integrate. These are four API calls, and they are a better signal than a star count.
- Assume the server is hostile anyway and contain it. Every item above is a filter, and filters are porous. The property worth engineering is that a compromised MCP server cannot read what it should not — which is a sandboxing and egress question, not a package question. See local MCP servers on the endpoint and egress control for agents.
What does not work, and is the first thing most teams reach for: telling the agent to prefer maintained packages. The instruction competes with the recall that produced the name in the first place, cannot be verified by the agent without a lookup it was not going to do, and leaves no artefact behind. A prompt is not a control.
FAQ
Is this a vulnerability in MCP?
No. Nothing in the protocol is broken. The defect is in the path by which a server gets chosen and launched: a model's recollection of a name, resolved by a package runner, with no gate in between. The same pattern would exist with any extension mechanism that takes a package name from model output.
Does pinning versions fix it?
No, and this is the most common wrong answer. Pinning constrains which version of a package you chose; it says nothing about a package nobody chose. The relevant control acts on the name, before resolution.
Have these packages actually been exploited?
Glow Labs reports no observed attack at the time of publication. The exposure is the structure — unpatchable artefacts with known high-severity findings, running with developer privileges, installed without a record — rather than a campaign in progress.
Should I remove every @modelcontextprotocol/ server from my configs?
Not blindly: some of those packages are actively maintained and have shipped fixes during 2026. Resolve each one to its repository and check whether that repository is archived. The archived ones should go; the maintained ones need the same version hygiene as any other dependency.
Does running MCP servers in a container solve it?
It bounds the damage, which is worth a great deal, and it does not address the selection problem. A containerised archived server with a prompt-injection-reachable flaw still reads whatever you mounted into it and still reaches whatever network you allowed.
Why would an agent install a server the user did not ask for?
Because the task was "connect to this service" and the fastest path to a working tool list is a name the model already knows. The agent's success criterion is a server that starts, and an archived server starts perfectly.
Further reading
On this wiki:
- Agent supply-chain security — the full threat model this sits inside.
- Vetting a third-party skill — the review procedure, applied to the artefact rather than the registry.
- Pinning and verification — what pinning does and does not cover.
- MCP registry and distribution — how servers are meant to be discovered.
- Third-party tool drift — the operational version of the same decay.
- Local MCP servers on the endpoint — containment for servers running beside your editor.
Sources:
- Glow Labs — MCPhantom: AI coding agents are installing vulnerable, deprecated MCP servers from training data (2 November 2026)
- Cloud Security Alliance research note — MCPhantom: model knowledge as an unpatchable software supply chain
- Help Net Security — AI coding agents are installing MCP servers that will never be patched
- modelcontextprotocol/servers — security advisories