Independent AI intelligence Two editions daily · ET
Fervor AI

Analysis · November 15, 2026 · concept

MCPCorelightuvmcpmcp-securityagent-securityclaude-code

Your Pinned MCP Server Isn't Frozen. Here's How to Freeze It

One config line can run a different program every few days. A five-step fix turns it back into one you chose.

Most developers treat the version number in an MCP config as a promise. You wrote ==1.4.2, or a commit hash, so the code that runs tomorrow is the code that ran today.

It often isn't.

MCP (the Model Context Protocol) servers are the small programs your coding assistant starts so it can talk to GitHub, a database, a firewall or your ticket system. They usually start from one line of config, through a one-step launcher like uvx for Python or npx for Node, and that line can pull new code every few days. Corelight, a network security company, watched it happen on a real admin workstation and published the evidence on November 10.

The result is a mental model worth changing: a pinned version pins the package, not the packages it depends on. If that server holds a credential, every one of those unchosen packages runs with it.

The fix is short: install the server once from its lock file, launch the installed program directly and stop the rebuilds. This piece explains what Corelight found in plain terms, why it matters more for MCP than for most software, and the exact commands to freeze a server so the code only changes when you decide it should.

What Corelight actually saw

The workstation belonged to an administrator. Two AI coding assistants on it ran MCP servers that held credentials for security tools and other admin systems.

One server, a community MCP server for a network gateway, was configured to run one specific release, built from one specific commit. Over five weeks, Corelight found the launcher's cache held 19 builds of that same release, and those 19 builds produced 15 different sets of dependencies. Twenty-three of its 69 packages changed version along the way, including the cryptography library, the JSON Web Token library and the MCP software development kit itself.

Nobody touched the config. Nobody ran an install command.

Here is the part that makes it feel unfair. The server's author did the careful thing. They pinned their seven direct dependencies exactly and published a hash-pinned lock file (a list of every package with an exact version and a fingerprint of the file). The launcher simply didn't use it. It installed from the package's declared dependencies, so the roughly 60 packages underneath were resolved fresh from PyPI, the Python package registry, within whatever version ranges the tree allowed.

And it wasn't one server. Every MCP server on that machine launched the same way showed the same pattern, whether it was pinned to a release tag, an exact PyPI version or an exact Git commit. Across 35 MCP servers Corelight reviewed from two vendor catalogs and its own lab, 23 had a recommended install that would resolve dependencies fresh from a public registry.

Node users are not off the hook. Several hosted MCP services ask you to run a small local proxy that attaches your API token to each request, and Corelight found vendor setup instructions that start it with npx <proxy>@latest <url>. That asks npm for the newest version every time the proxy starts. One such proxy shipped six versions in a month, four of them within 14 hours.

Why this matters more for MCP than for your other tools

Software that updates itself and holds credentials is normal. Your browser does it. Your operating system does it.

The difference is a controlled build. A browser update comes from one publisher, gets tested, and carries a version number you can look up. A launcher re-resolving dependencies has none of that. Any maintainer of any package in a 70-package tree can change what runs, and the MCP server's own version number never moves, so nothing tells you it happened.

Two MCP habits make it worse.

First, every dependency runs with the server's access. When an MCP server starts, it loads its dependencies into the same process. Code in any of them can read the API tokens in its environment, your files and whatever the workstation can reach on the network. A malicious package doesn't need to be called; some recent payloads ran the moment Python started.

Second, MCP servers start automatically. You add the config line once. After that, your assistant launches the server at the start of each session. In Corelight's case, the assistant started one server 162 times in a single week. Most launches only checked for changes, but some rebuilt.

That timing matters because supply-chain attacks are short. Corelight's examples include the Ultralytics compromise in December 2024, where malicious PyPI releases were live for about 12 hours, and a 2026 Shai-Hulud wave where six malicious releases went up in under a minute and were quarantined within 30 minutes. Whether you are hit comes down to whether anything rebuilds during that window. A launcher that rebuilds every couple of days, on its own schedule, gets more tickets in that lottery than a server you installed once.

Here is the unglamorous truth: the one-line uvx setup that every README leads with is a demo install. It is great for trying a server for ten minutes. It is the wrong way to run one that holds your firewall password.

The fix: freeze it once, then launch it directly

Corelight's fix fits in one sentence: freeze the environment once, don't just pin the release, and stop rebuilding at launch. It tested this on five servers. Over the next two weeks those servers started 457 times, and each one's installed package list was identical to the day it was installed. The frozen servers also started in about 2 seconds instead of 4 to 11.

The five steps, translated:

  1. Pin to a commit, not a tag. A tag is a label a maintainer can move to different code. A commit hash can't change.
  2. Install from the project's hash-pinned lock file. The hashes mean a package that doesn't match its recorded fingerprint fails to install, instead of slipping in.
  3. Install into its own environment with hash checking on, then install the server itself without letting the installer resolve dependencies again.
  4. Launch the installed program directly from your assistant's config, not through uvx or npx.
  5. Turn off startup update checks. Even a frozen server in Corelight's test made one HTTPS call to PyPI on first launch, because its MCP framework checked for a newer version of itself.

Put this into practice

Start with an inventory. Open your assistant's MCP config (for Claude Code that is your .mcp.json or user settings; other clients have their own file) and look for any entry whose command is uvx, npx, pipx run or anything tagged latest. Those are the ones that can pull new code. Then rank them by what they can reach. A docs-search server with no credentials is low on the list. Anything with a token for production, a firewall, a SIEM (the security log system your team watches for attacks) or your cloud account goes first.

For a Python server whose repo ships a uv.lock, the frozen install looks roughly like this. Replace the names and the commit with your own.

# 1. Get the exact commit you want to run
git clone https://github.com/<org>/<server>.git && cd <server>
git checkout <commit-sha>

# 2. Export the lock file as a hash-pinned requirements file
uv export --frozen --format requirements.txt --no-emit-project --output-file requirements.txt

# 3. Make a dedicated environment and install with hashes enforced
uv venv ~/.mcp/<server>
uv pip install --python ~/.mcp/<server> --require-hashes -r requirements.txt

# 4. Install the server itself without resolving dependencies again
uv pip install --python ~/.mcp/<server> --no-deps .

uv export writes the lock file out in the classic requirements.txt format (uv docs), with a hash for each package unless you pass --no-hashes (uv CLI reference). --require-hashes makes the install fail if any package in that file is missing a hash or doesn't match, and --no-deps installs the server without touching the dependency set you just locked. One gap to know: hash checking covers the runtime packages in the file, not the build tools uv may fetch to build the server itself in step 4, which uv controls with a separate --require-build-hashes option (uv CLI reference).

Then point your assistant at the installed program instead of the launcher. The command in your MCP config becomes something like ~/.mcp/<server>/bin/<server-command>, with no uvx in front of it. Check the server's README for any setting that disables its startup update check, and set it.

Two things to expect. If the author's lock file targets a different operating system, uv export may not match your platform; Corelight hit exactly this and generated a lock for its own OS, constrained to the author's versions, where only platform-specific packages differed. And if a server ships no lock file at all, Corelight's advice is blunt: that is worth knowing before you give it your credentials.

For a Node proxy that a vendor told you to run with @latest, swap it for an exact version installed once. Install into a folder you control with npm install --prefix ~/.mcp/<proxy> <proxy>@<exact-version> --ignore-scripts (npm docs) so install scripts can't run, then launch it from that folder's node_modules/.bin. This pins the proxy's own version, not a reviewed copy of everything under it, so keep the package-lock.json npm writes and reinstall from it with npm ci when you rebuild. Test the proxy afterward too: a package that needs its install scripts may break with --ignore-scripts. And if any setup tells you to turn off TLS certificate checks for the proxy (the check that proves you are talking to the real server), don't. Corelight found one vendor doing exactly that.

Don't want to type all this? Corelight's post ends with a setup prompt you can paste into your coding assistant that asks it to do the frozen install for you and show you the installed versions and config change before applying anything. It is the fastest path for one server, and the "show me first" part is the reason to use it.

Check that the freeze actually held

A quiet network log is not proof. A cached, unfrozen install can also be quiet between rebuilds.

The real test is boring and decisive: record the installed package list on the day you freeze the server (uv pip freeze --python ~/.mcp/<server>), then compare it after a week of normal use. If the two lists match and the server still connects to your assistant (completes its MCP handshake) and offers the same tools, the freeze held. That is the check Corelight called the one that mattered most.

Honest limitations

Freezing swaps one risk for another. When Corelight froze the community server, 40 of its packages were older than what the launcher would have pulled that day, some of them security-sensitive. Frozen code ages. Someone has to own re-locking on a schedule, reading what changed and checking the pinned versions against known vulnerabilities. If nobody owns that, you have traded silent drift for silent rot.

Freezing doesn't shrink what the server can do. A perfectly frozen server with a full-admin token is still a full-admin token on a laptop. Give each server its own account or API client with the least access its tools need, read-only where it supports it, with tokens that expire.

It also takes effort the one-line install doesn't. Expect your first freeze to take real time, mostly spent reading the server's README and fixing the platform mismatch. Every one after that goes faster.

And none of this is a flaw in MCP itself. Corelight is explicit that each case was a choice in setup instructions, and some vendors already ship the frozen pattern by default. The fix is mostly on maintainers: publish hash-pinned requirements with every release, make the frozen install the README's main example and label the one-liner as a quick trial.

The question to ask this week

Look at the MCP servers your assistant starts every morning and ask one thing of each: if this code changed tonight, would I know?

For most setups the honest answer is no. You can change that for the two or three servers that hold real credentials in an afternoon, and leave the harmless ones on the convenient launcher.

Treat your agent's tools the way you would treat any admin account: know what each one can reach, what it runs, and where its code came from.

Sources: Corelight, "The supply-chain risk hiding in your MCP servers" (James Lagermann, November 10, 2026); uv docs, Exporting a lockfile; uv CLI reference; npm install docs. Commands checked against uv and npm documentation as of November 15, 2026.