TL;DR

  • Glow Labs named a pattern "MCPhantom" on November 3, 2026. In its review of real coding sessions, an agent installed or suggested a deprecated MCP server, and in 98% of those sessions the agent appears to have supplied the package name from its own training data. In the other 2%, the user asked for the old package by name.
  • The reference-server maintainers closed the report as out of scope, because the servers were archived in May 2025. No fix is coming, and the flaws have no CVEs, so scanners that key on CVEs see nothing.
  • I measured the live state on November 20, 2026. Five deprecated @modelcontextprotocol servers moved 496,370 npm downloads in the last seven days. All five carry a deprecation notice, and npx installs them anyway.
  • I wrote a small pre-launch gate that reads the registry's deprecated field and refuses to start a flagged server. On a four-server sample config it blocked 3 of 4 and let the maintained one through.
  • The lesson: an approval prompt shows the command, not the history of the package behind it. The model's memory is acting as a package manager with no deprecation feed, so the gate has to supply the feed.

Weekly npm downloads of five deprecated MCP servers versus one maintained server

What did MCPhantom actually find?

The research, reported by Help Net Security on November 3, 2026, looked at real AI coding session transcripts. The pattern is simple. A user asks the agent to connect a service, for example GitHub. The agent reaches for an MCP server it remembers from training. That memory predates the move to vendor-maintained servers, so the agent picks an archived reference server over the one the service owner now ships.

Three details from the write-up matter for builders.

  1. The behavior showed up across several harnesses (Claude Code, Cursor, Codex CLI and others) and across models from three different labs. It is a property of how models remember package names, not a bug in one product.
  2. In one session the agent checked npm, received a deprecation notice, installed the package anyway, and did not tell the user.
  3. The most serious flaw reported in the archived servers is remote code execution in the Puppeteer server. A prompt injection can make the agent start arbitrary processes in place of a browser.

The disclosure outcome is the part to sit with. The maintainers said the repository was archived in May 2025 and unmaintained, so no fix would follow. They said they would look at marking the npm package deprecated. Deprecated packages still install through npx, which is the launch path almost every MCP config uses.

Why do existing controls miss it?

Each layer of a normal security stack sees something routine:

  • Endpoint detection sees a trusted Node process installing a public package.
  • Software composition analysis finds no manifest entry, because the install happens at runtime from a config file or an agent decision.
  • Vulnerability feeds have no CVE to match, because the flaws were never assigned one.
  • Software inventory does not register the application, so the endpoint is the only place it exists.

None of these is wrong. They are each answering a different question than "should this package be launched by an agent at all?" That question belongs to the approval gate, and most approval gates today only see the command string.

What is the live state of these packages today?

The report is two weeks old, so I checked the registry directly instead of trusting it. These numbers come from the public npm registry and downloads API, queried on November 20, 2026, for the window November 13 to November 19.

Package Deprecation notice Weekly downloads
@modelcontextprotocol/server-github Archived and unmaintained, no security guarantees 112,028
@modelcontextprotocol/server-puppeteer Archived and unmaintained, no security guarantees 27,283
@modelcontextprotocol/server-postgres Archived and unmaintained, no security guarantees 147,218
@modelcontextprotocol/server-slack Package no longer supported 183,067
@modelcontextprotocol/server-brave-search Package no longer supported 26,774
@modelcontextprotocol/server-filesystem none (version 2.4.0, modified November 18) 1,222,611

Two readings are worth separating. First, the registry now carries a deprecation notice on the GitHub, Puppeteer and Postgres packages. Their last-modified timestamps are November 5, 2026, two days after the report, which is consistent with the maintainers' stated plan to mark them deprecated. I am inferring the cause from the timing, not from a statement. Second, the notice did not stop installs. Together the five deprecated servers still moved 496,370 downloads in one week. A notice that nobody reads at install time is a label, not a control.

Five deprecated servers moved about 496K downloads in one week

Can a gate catch this without a CVE feed?

Yes, because the signal that matters is not a CVE. It is the registry's own deprecated string on the latest version. It is cheap to read, it is authoritative for the package owner's intent, and it is exactly the field the agent in the report received and ignored.

Here is the whole gate. It parses an MCP config, finds npm launches, and asks the registry about each package before anything starts.

import json, sys, urllib.request, urllib.parse def meta(pkg): u = "https://registry.npmjs.org/" + urllib.parse.quote(pkg, safe="@") d = json.load(urllib.request.urlopen(u, timeout=30)) latest = d["dist-tags"]["latest"] return d["versions"][latest].get("deprecated"), latest def pkg_of(args): for a in args: if not a.startswith("-"): has_ver = a.count("@") > 1 or (a.count("@") == 1 and not a.startswith("@")) return a.rsplit("@", 1)[0] if has_ver else a cfg = json.load(open(sys.argv[1])) for name, s in cfg["mcpServers"].items(): if s.get("command") not in ("npx", "bunx"): print(f"{name}: skip (not an npm launch)"); continue p = pkg_of(s["args"]); dep, v = meta(p) print(f"{name}: {p}@{v} -> " + ("BLOCK deprecated: " + dep[:60] if dep else "ok")) 

I ran it against a four-server sample config: GitHub, Puppeteer, filesystem and Slack, all launched with npx -y. The output on November 20:

github: @modelcontextprotocol/server-github@2025.4.8 -> BLOCK deprecated: Archived and unmaintained; no security guarantees... browser: @modelcontextprotocol/server-puppeteer@2025.5.12 -> BLOCK deprecated: Archived and unmaintained; no security guarantees... files: @modelcontextprotocol/server-filesystem@2.4.0 -> ok slack: @modelcontextprotocol/server-slack@2025.4.25 -> BLOCK deprecated: Package no longer supported... 

Three of four blocked, the maintained one passed. That is the full result of a deliberately small test, so read it as a demonstration of the mechanism and not a measurement of how common the problem is across real configs. The script prints verdicts only. In a real launcher, a BLOCK result must exit non-zero before the server process is spawned.

Sample config: a deprecated-flag gate blocks all three deprecated servers

Where should the check run?

The report notes that many harnesses already support pre-execution hooks, and that is where this belongs. A few design choices decide whether the gate holds up.

Check at launch, not only at install. A server installed months ago can be deprecated today. The gate should run every time the harness starts a server, including servers already in the config. The sample above does that, because it reads the config, not an install log.

Check the version you will run, not the name you were told. When a config pins a version, query that version's deprecated field. Registry deprecation can be set per version, so a name-level check can pass while the pinned release is flagged. The sample checks the latest version only, which is a simplification.

Fail closed on lookup errors. If the registry is unreachable or the response is malformed, do not launch. The same rule applies to any control that sits in front of a side effect.

Handle the non-npm paths. The sample skips anything that is not an npm launch. A real gate needs equivalents for uvx, container images and direct binaries, or an explicit allowlist that makes those paths require a human.

Prefer an allowlist over a blocklist. Deprecation status is a good blocker, but the stronger rule is the one in the report's recommendations: approve one server per service, and prefer the server the service owner publishes. A flag catches the stale package. An allowlist also catches the lookalike package that was never deprecated because it was never legitimate.

What does this change about the approval prompt?

An approval prompt for npx -y @modelcontextprotocol/server-github looks the same today as it did the day the package was healthy. The text on screen carries no information about its maintenance state. If the user clicks approve, they are approving a string, and the string is a memory the model had.

This connects to a theme from earlier posts in this series. A gate that checks only the command misses the context around the command: the path the OS will open, the position a check does not cover, the background call that runs before the prompt. Package provenance is one more piece of context that the gate has to attach itself, because neither the model nor the user will.

A useful framing for review is to ask what each party knows at approval time:

  • The model knows a name from training and has no live view of the registry.
  • The user knows what they asked for, usually a service and not a package.
  • The registry knows the deprecation state, the owner count and the last publish.

Only the registry has the facts, and only the gate can ask it. That is the whole design.

How should a team respond this week?

Per the recommendations in the report, plus the gate above, here is a short checklist.

  1. Search every MCP config you own for @modelcontextprotocol/server-* and list which ones are deprecated on the registry.
  2. For each service, switch to the server the service owner maintains, where one exists.
  3. Approve one server per service, and record who approved it and when.
  4. Add registry deprecation status to the criteria for approving any MCP server.
  5. Run the deprecation check from a pre-execution hook so it applies at every launch.
  6. Treat a deprecation notice that the agent saw and ignored as an incident signal, because it means the agent's decision path is not gated.

If you cannot switch yet, at least run the archived server with the narrowest permissions you can: no shared credentials, no network egress beyond what it needs, and no access to the files that matter. The Puppeteer case shows why: the harm in that report comes from a prompt injection steering an already trusted process, so containing the process matters even when the package cannot be fixed.

What this does not tell us

The 98% figure describes the sessions in the research sample where a deprecated server appeared, not the share of all coding sessions. No exploitation had been observed at the time of reporting. My sample config has four servers and my registry check covers five deprecated packages, so neither is a prevalence estimate. The deprecation timing on November 5 is an inference from timestamps. What the data supports is narrower and still useful: the mechanism is real, the packages are still moving hundreds of thousands of downloads per week, and a registry-aware gate is a low-cost control that the common stack lacks.

FAQ

What is MCPhantom?
A name Glow Labs gave to the pattern where a coding agent installs or suggests a deprecated MCP server, usually because the package name came from the model's training data.

Do the flaws have CVEs?
According to the report, no. That is why CVE-driven scanners do not flag these installs.

Are deprecated npm packages blocked from installing?
No. A deprecation notice prints a warning, and npx still installs and runs the package.

Is the registry deprecation field enough on its own?
It is a good blocker for known-stale packages but not a full control. Pair it with an allowlist of approved servers per service and containment for anything you must keep.

Does this affect only one coding tool?
The report observed it across several harnesses and models from three labs, so treat it as a pattern in how agents choose packages.

Where should the check live?
In a pre-execution hook or launcher wrapper, so it runs at every server start and fails closed on lookup errors.

Further reading

  • A Valid HTTPS URL Ran Code: What the opencode MCP OAuth Bug Teaches About Validating at the Sink (earlier post, same series)
  • Git Ran the Repo's Program Before Any Prompt: What GitSpawn Teaches Agent Builders About Background Context Calls (earlier post, same series)

Sources