GUIDE · MCP 11 min ·

Your agent installs MCP servers nobody will patchMCPhantom, archived servers and the tokens they hold

Ask a coding agent for a GitHub MCP server and it may hand you one that was archived in May 2025, because that is the name it learned in training. Twelve of those archived packages moved 548,422 npm downloads in the week to November 19. No patch is coming, no CVE exists, and the tokens you gave them sit in plaintext next to the launch command.

TL;DR· the answer, in twenty seconds

What happened: Glow Labs found coding agents installing archived Anthropic reference MCP servers from training memory across Claude Code, Cursor, Codex CLI and Claude chat. It reported four high-severity flaws, including code execution in the Puppeteer server. The maintainers will not fix them, and none has a CVE.

The minimum fix: Scan every MCP config on every developer machine for npm packages the registry marks deprecated, replace them with the service owner's server, and rotate any token that sat in their env block.

The lesson: An agent's training data works as a package index with no deprecation feed. Tell the agent which servers you approve, check registry status at launch, and keep long-lived tokens out of the files any server process can read.

Coding agents are installing MCP servers that were archived in May 2025, picking the package names from training data, and the maintainers have said no fix will come for the flaws found in them.

Glow Labs published the research on November 2 and calls the pattern McPhantom. Help Net Security covered it the next day under the MCPhantom spelling, which most follow-ups use. The finding is plain. A developer asks for "a GitHub MCP," and the agent writes @modelcontextprotocol/server-github into the config, a package from Anthropic's original 2024 reference set. GitHub ships its own server now. The agent doesn't know that, because its knowledge of package names stops where its training data stops.

None of the sessions Glow reviewed involved an attacker. The risk comes from the agent's own choice of dependency, and every control a security team runs sees that choice as routine.

What Glow Labs found in the transcripts

Glow reviewed real AI coding session transcripts from endpoints it monitors and pulled out the sessions where an agent set up a deprecated reference server. In 98% of them, the agent appears to have supplied the name from training data. In the other 2%, the user asked for the old package by name and the agent complied.

The behavior was not tied to one product. Glow saw it in Claude Code, Cursor, Codex CLI, Claude Cowork and Claude chat, with models from Anthropic, OpenAI and xAI. A fix inside one harness would leave the others open. Glow's Nadav Claude Cohen told Help Net Security a harness-side block "works only if every harness does it."

Here is the history that sets this up. When Anthropic launched MCP in 2024 it published 20 reference servers to show how integrations work. As services shipped their own servers, the project archived 13 of the reference set. The servers-archived repository lists 14 today: AWS KB Retrieval, Brave Search, EverArt, Git, GitHub, GitLab, Google Drive, Google Maps, PostgreSQL, Puppeteer, Redis, Sentry, Slack and SQLite. Its README says the maintainers will provide no security updates or bug fixes.

Glow then looked at what the agents had installed and found four high-severity vulnerabilities across those servers. The worst is code execution in the Puppeteer server, reachable through prompt injection. Glow reported a first flaw through HackerOne on July 30, 2026, and HackerOne closed it as out of scope and pointed to GitHub. Glow reported all four flaws to Anthropic's CNA between October 4 and 11. The maintainers closed the Puppeteer advisory and replied that the server "is unmaintained, so no fix or release will come from this repository." No one assigned a CVE. Glow says it has seen no exploitation.

One session in the data should end any hope that the agent will catch this on its own. Cohen told Help Net Security the agent checked the package on npm, got back "This package is deprecated," installed it anyway and never told the user.

The registry says deprecated, and npx installs it

I checked the npm registry on November 20 to see what a developer or agent gets today. The downloads are for November 13 to 19.

Package Latest version Registry deprecation notice Downloads, Nov 13 to 19
server-slack 2025.4.25 Package no longer supported 183,067
server-postgres 0.6.2 Archived and unmaintained 147,218
server-github 2025.4.8 Archived and unmaintained 112,028
server-gitlab 2025.4.25 Package no longer supported 30,692
server-puppeteer 2025.5.12 Archived and unmaintained 27,283
server-brave-search 0.6.2 Package no longer supported 26,774
server-google-maps 0.6.2 Package no longer supported 12,754
server-gdrive 2025.1.14 Package no longer supported 4,882
server-redis 2025.4.25 Package no longer supported 3,375
create-server 0.3.1 Package no longer supported 130
server-aws-kb-retrieval 0.6.2 Package no longer supported 126
server-everart 0.6.2 Package no longer supported 93

That is 548,422 downloads in one week for twelve packages that carry a deprecation notice. Glow counted 17,352,267 for the same twelve from July 10, 2025 to its publication date. Puppeteer alone passed 1.6 million between July 10, 2025 and November 19.

Two things stand out in the registry data. The Slack, GitLab, Brave and other notices read "Package no longer supported. Contact Support," and those records were last modified on September 17, 2026. The GitHub, Postgres and Puppeteer packages carry a different notice, "Archived and unmaintained; no security guarantees," and their records were last modified on November 5, three days after Glow published. The maintainers told Glow they would look at marking the packages deprecated. The timing fits, but the registry doesn't say who changed what, so treat that link as my inference. The DEV Community write-up that measured five of these packages on the same day reads it the same way.

The notice doesn't stop anything. I installed the GitHub server into an empty directory with scripts disabled:

$ npm install --ignore-scripts --no-audit --no-fund @modelcontextprotocol/server-github
npm warn deprecated @modelcontextprotocol/server-github@2025.4.8: Archived and unmaintained; no security guarantees. See https://github.com/modelcontextprotocol/servers-archived
added 46 packages in 683ms
$ echo $?
0

Exit code 0, one warning line on stderr. An MCP client that launches npx -y @modelcontextprotocol/server-github owns that stderr stream, and the line lands wherever the client puts server logs. Deprecation hides a package from npm search results, which Glow suggests is why the agents' web lookups often came up empty. The old name then comes from memory with nothing to contradict it.

Removing the packages is off the table. The npm unpublish policy allows it for an older package only when no other package depends on it, it had fewer than 300 downloads in the last week, and it has a single owner. Each of these packages lists 5 or 6 owners on npm, and most clear 300 downloads by a wide margin.

How a browsing permission reached a shell

Glow did not publish its proof of concept, so I read the archived Puppeteer source to see where a browsing tool could reach a shell. I didn't run an exploit, and I can't confirm this is the exact path Glow reported. The shape is visible in index.ts in the archived Puppeteer directory.

The puppeteer_navigate tool accepts two optional arguments next to the URL:

launchOptions: { type: "object", description: "PuppeteerJS LaunchOptions. Default null. If changed and not null, browser restarts. ..." },
allowDangerous: { type: "boolean", description: "Allow dangerous LaunchOptions that reduce security. ..." },

The model fills both. The server deep-merges launchOptions from the tool call over PUPPETEER_LAUNCH_OPTIONS from the environment and hands the result to puppeteer.launch(). Puppeteer's launch options include the path of the browser binary to start and the arguments it gets. The server's safety check filters a list of eight dangerous Chrome flags, such as --no-sandbox, and reads only the args array. When the check trips, the error tells the caller to "Set allowDangerous: true in the tool call arguments to override." The model is the caller.

So the control that guards the launch config is a boolean the model can set, and an error message that teaches the model to set it. A page the browser visits can carry text that steers the next tool call. That is the prompt injection Glow describes: the agent starts a different process in place of the browser. Glow's summary of why the harness lets it through matches what the code shows. The developer approved web browsing, and that approval covers whatever arguments the navigate call carries.

The design fault is older than MCP. A tool that takes process launch parameters from the model has handed the model a process launcher. Microsoft's Playwright MCP server is a maintained browser automation server, and it sets browser launch options through its own command-line flags and config file. Check what any browser server you adopt accepts per call before you approve it.

The archived servers hold your tokens

The coverage so far has focused on unpatched code. The part that costs you money is the configuration these servers take. I read the configuration examples in each archived README. Most of the popular ones take a long-lived credential through the MCP config:

Archived server What its README puts in the config
GitHub GITHUB_PERSONAL_ACCESS_TOKEN
GitLab GITLAB_PERSONAL_ACCESS_TOKEN and GITLAB_API_URL
Slack SLACK_BOT_TOKEN and SLACK_TEAM_ID
Brave Search BRAVE_API_KEY
Google Maps GOOGLE_MAPS_API_KEY
PostgreSQL A postgresql://user:password@host/db URL as a launch argument
Redis A redis:// URL as a launch argument

An agent that sets up the archived GitHub server needs a personal access token, and the README's example config puts it in the env block. On a developer machine that block lives in ~/.claude.json, .cursor/mcp.json or the project's .mcp.json. That file now holds three things: the launch command for unmaintained code, a token with whatever scopes the developer granted, and the configs for every other MCP server on the machine.

Now put the Puppeteer flaw next to that file. Code that runs as the developer can read every config the developer can read. A process started through the browser tool doesn't need the GitHub server to be vulnerable. It reads the token out of the JSON file that lists both servers. The archived Postgres server is worse in one respect, because the password sits in the launch arguments, and any process running as the same user can read those arguments with ps.

Replacing the server fixes the unpatched code. It doesn't fix the token that sat in plaintext for months next to a server nobody maintains. If you gave a deprecated server a credential, rotate the credential after you swap the server, and don't paste the new one into the same file.

Find and replace them on every machine

Glow recommends three steps that need no new product: find configs that reference the deprecated servers, approve one server per service, and add registry deprecation status to the approval criteria. Here is the first step as a script that covers the config paths of the common clients and asks the registry about every scoped package it finds, so it catches deprecations beyond the twelve above.

#!/usr/bin/env bash
# List MCP configs that launch an npm package the registry marks deprecated.
# Exit 1 if any are found, 0 if none.
set -u
H="${1:-$HOME}"

config_files() {
  printf '%s\n' \
    "$H/.claude.json" \
    "$H/.codex/config.toml" \
    "$H/.codeium/windsurf/mcp_config.json" \
    "$H/Library/Application Support/Claude/claude_desktop_config.json" \
    "$H/.config/Claude/claude_desktop_config.json"
  find "$H" -maxdepth 4 -not -path '*/node_modules/*' \
    \( -name .mcp.json -o -path '*/.cursor/mcp.json' -o -path '*/.vscode/mcp.json' \) 2>/dev/null
}

found=0
while IFS= read -r f; do
  [ -f "$f" ] || continue
  while IFS= read -r pkg; do
    msg=$(npm view "$pkg" deprecated 2>/dev/null)
    [ -n "$msg" ] || continue
    printf '%s\t%s\t%s\n' "$f" "$pkg" "$msg"
    found=1
  done < <(grep -oE '@[a-z0-9-]+/[a-z0-9._-]+' "$f" | sort -u)
done < <(config_files | sort -u)
exit "$found"

I ran it on November 20 against a fake home directory with four servers across three files: the archived GitHub server in .claude.json, a pinned server-puppeteer@2025.5.12 in .cursor/mcp.json, and @playwright/mcp plus the archived Postgres server in a project .mcp.json. It flagged GitHub, Puppeteer and Postgres, let Playwright and the maintained server-filesystem through, and exited 1. On an empty directory it exited 0. It runs under macOS's stock bash 3.2 and passes shellcheck.

Know its limits before you roll it out. It reads only scoped npm names, so an unscoped deprecated package, a uvx Python server or a container image won't show up. It checks the latest version's deprecation field, and npm can deprecate single versions. A failed registry lookup counts as clean. The -maxdepth 4 search misses repos nested deeper under home. Treat a clean exit as "nothing obvious," and widen the paths for your own layout.

For each hit, move to the service owner's server where one exists. These three I checked on November 20:

For Slack, GitLab, Postgres and the rest, check the vendor's own docs. I didn't verify a replacement for each, and a random fork under a similar name is a worse bet than the archive.

Then shut the door the agent walked through. The agent picked the old name because nothing in its context named a better one. Put the approved list where it reads every session:

## MCP servers

Only add MCP servers from this list. Ask before adding any other server.

- GitHub: github/github-mcp-server
- Browser automation: @playwright/mcp
- Web search: @brave/brave-search-mcp-server

Never install a package under @modelcontextprotocol/ other than server-filesystem,
server-memory, server-sequential-thinking or server-everything.

That block goes in CLAUDE.md, AGENTS.md or whichever instruction file your agent loads. It changes the model's default, which is where 98% of Glow's cases started. It is a strong hint and nothing more. Pair it with a check at launch, which several harnesses support through hooks that run before a tool call. The DEV write-up shows a short pre-launch gate that reads the registry's deprecated field and refuses to start a flagged server. Run that check on every launch, including servers that were fine when you installed them.

What this means for your stack

Run the scan on every developer machine this week, swap each hit for the service owner's server, and rotate every token that sat in a deprecated server's env block. Then add the approved-server list to your agent instructions so the next request for "a GitHub MCP" lands on the right package.

The pattern underneath is that an agent picks dependencies at runtime, from memory, outside any manifest your tooling reads. You can't scan that choice in advance, so limit what a wrong choice can reach. Approve servers by name, check registry status when a server starts, and keep long-lived credentials out of the config files and environment that every server process inherits. A server you didn't vet should find nothing worth stealing when it starts.

hasp is one working implementation of that last part. curl -fsSL https://gethasp.com/install.sh | sh, hasp setup, then connect a project, and secrets reach the processes that need them at runtime instead of sitting in .claude.json or shell env. Source-available (FCL-1.0), local-first, macOS and Linux, no account. It doesn't patch an archived server or stop an agent from choosing one.

Glow's line from Ophir Arie sums up the problem: "The model's memory is now a package manager with no deprecation feed." Twelve packages are flagged today. The next batch will be whatever the current models learned that someone retires next year. Keep the inventory of which servers your agents start, and keep it current yourself.

Sources· cited above, in one place

NEXT STEP~90 seconds

Stop handing the agent your real keys.

hasp keeps secrets in one local encrypted vault, brokers them into the child process at exec, and never lets the agent read the value.

  • Local, encrypted vault — no account, no cloud, no telemetry by default.
  • Brokered run — agent gets a reference, the child process gets the value.
  • Pre-commit + pre-push hooks catch managed values before they ship.
  • Append-only HMAC audit log answers "did the agent touch the prod token?" in seconds.
→ okvault unlocked · binding ./api
→ okgrant once · pid 88421
→ okagent never read

macOS & Linux. Source-available (FCL-1.0, converts to Apache 2.0). No account.

Browse all clusters· eight threads, one index