The server was archived, the install still worked

Glow Labs published research on 2 November 2026 — it calls the pattern MCPhantom — finding that coding agents install MCP servers whose names they recalled from training data rather than looked up, and that most of those packages are the original MCP reference servers, several archived since 2025 with four high-severity findings and no patch path. The transferable point is not the vulnerabilities. It is that a lockfile pins versions of dependencies you declared, and this dependency was never declared: a name came out of the model, npx resolved it, and a process now holds your filesystem and your tokens. Every control you already own sits on the wrong side of that step.

By Agentic AI Wiki 12 min read

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.

ClaimWhat it saysWhere it comes fromHow 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
Two paths to the same install command Two parallel pipelines ending at the same npx resolution step. The upper, governed path runs from a developer declaring a dependency, through package.json, a lockfile and a dependency scanner, to the install. The lower, ungoverned path runs from the model's training data recalling a package name, through an agent writing an MCP client config, straight to the same npx resolution and then to a server process holding the developer's filesystem and tokens. None of the upper path's controls sit on the lower path. Governed: a dependency you declared Developer picks a package package.json + lockfile SCA scan, review, audit Ungoverned: a name the model remembered Training data recalls a name Agent writes mcp.json No gate here (nothing to scan) npx @scope/pkg resolves, downloads, runs Server process holding your filesystem, your tokens, your network Same resolution step. Same privileges. One of the two paths has a gate on it. An archived package installs exactly as fast as a maintained one.
Both paths end at the same command with the same privileges. Only one of them passes a gate.

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.

Which existing control sees an agent-initiated MCP server install Five rows of supply-chain controls, each scored on whether it sees an agent-initiated MCP server install and whether it blocks one. Lockfiles and pinning see nothing and block nothing because the package was never declared. A repository dependency scan sees nothing for the same reason. Endpoint inventory may see the process but does not block it. An npm deprecation warning is printed but does not stop npx. Only a pre-resolution allowlist both sees and blocks. What your existing controls do about it SEES THE INSTALL BLOCKS IT Lockfile and version pinning No No Dependency scan of the repository No No Endpoint inventory or EDR Sometimes No npm deprecation warning Printed, unread No Pre-resolution allowlist Yes Yes Effective Partial Does nothing here
Four controls on the wrong side of the resolution step, and one on the right side.

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:

Sources: