[KongchangAI]
· 1 min read· 892 words

Is Your "Pinned" MCP Server Really Pinned?

Is Your "Pinned" MCP Server Really Pinned?

An MCP server ran with 15 different dependency sets over five weeks despite unchanged config, exposing silent runtime drift risk.

Based on a five-week monitoring experiment on Reddit, an MCP server used at least 15 different dependency sets while its configuration files remained untouched, and 23 other servers in the same lab showed similar drift. This "silent drift" shows that pinning config files does not equal pinning the code that actually executes. Traditional artifact scanning only inspects deployment artifacts and cannot reflect runtime state, so drift is discovered only after execution has already occurred. The article reviews periodic hash checks, invocation-time verification, and network-layer monitoring along with their limitations, and notes that while the community agrees static pinning is insufficient, there is no consensus on best practices—teams must extend security boundaries from deployment time to runtime.

Introduction

In the supply chain security of AI infrastructure, a hidden risk is emerging: you think you've pinned the version, but the code actually executing may have already quietly changed. Recently, an experiment on Reddit sparked widespread discussion. Researchers tracked an MCP server for five weeks without changing any configuration, and found that it had been running with 15 different dependency sets—and the administrator had no idea.

reddit source: Your pinned MCP server may not be as pinned as you think

The Silent Drift Revealed by the Experiment

Over five weeks, the researchers continuously monitored an MCP server without touching its configuration files. Yet during that time, the server executed with different dependency combinations at least 15 times. The administrator saw no changes and received no alerts or configuration diff notifications. Even more concerning, another 23 servers in the same lab exhibited similar silent drift. The servers looked "pinned" only because the configuration files were pinned—but the code actually executed against agent contexts had changed at least 15 times.

MCP (Model Context Protocol) is an open standard proposed by Anthropic in late 2024 to let large language model applications connect to external data sources and tools in a unified way. An MCP server is essentially a lightweight process that communicates with clients via stdio or HTTP and exposes resources, prompt templates, and tool invocation interfaces. Since MCP servers are typically deployed as containers or virtual environments, their dependency resolution is often done dynamically at startup—for example, pulling the latest compatible versions from remote repositories, or loading plugins on demand at runtime. This design improves flexibility, but it also means that "pinning the configuration file" does not equal pinning the code that actually executes: as long as dependency resolution policies, repository metadata, or transitive dependencies change, the set of dependencies loaded at runtime may differ from what was deployed, creating silent drift.

The Blind Spot of Traditional Scanning

Traditional artifact scanning only checks what you deployed, but knows nothing about what is currently running. By the time periodic scans finally catch the drift, execution has long since occurred. This lag prevents security teams from responding in time when risk arises. For teams running MCP servers in production environments, this is a challenge that must be confronted.

Artifact scanning is a common practice in supply chain security, typically performing static checks on software bills of materials (SBOMs), container image layers, and dependency manifests during CI/CD pipelines or image build stages to detect known vulnerabilities or unauthorized components. However, such scans inspect "build artifacts" rather than "runtime processes": they cannot perceive a process re-resolving dependencies after startup, dynamically loading modules, or pulling code from the network. Runtime security, by contrast, relies on techniques such as process-level monitoring, file integrity monitoring (FIM), or eBPF to continuously observe the libraries and modules actually loaded. The fundamental difference between the two lies in the time dimension—artifact scanning is a snapshot at deployment time, while silent drift occurs in the runtime interval between two snapshots, which is precisely where traditional scanning is blind.

Feasible Detection Strategies

So how can this silent drift actually be caught? The discussion mentioned several approaches:

  • Periodic hash checks: periodically computing dependency hashes to compare changes, but short-lived drift between two checks may be missed.
  • Verification at invocation time: verifying dependency integrity on every call, which can detect problems in real time but may incur performance overhead.
  • Network-layer monitoring: capturing anomalous requests at the network layer, but it is difficult to correlate them precisely to specific dependency changes.
  • No solution yet: some teams say there is currently no effective means, highlighting how widespread the problem is.

Dependency hash pinning is one of the foundational measures for mitigating silent drift. Taking the Python ecosystem as an example, pip-compile --generate-hashes can generate a lock file with hashes; uv lock and Poetry's poetry.lock also record the exact version and hash of each package, and with --require-hashes or an equivalent mechanism, integrity can be verified at install time. However, hash pinning only covers the "install moment." If the server dynamically pulls dependencies during runtime or uses an unpinned plugin mechanism, the lock file becomes useless. Therefore, hash pinning needs to be combined with runtime integrity verification: for example, comparing the hashes of loaded modules before each tool invocation, or using the kernel-level Integrity Measurement Architecture (IMA) to record and verify measurements of executable code, so that pinning extends from the deployment stage to the execution stage.

Multi-Source Verification and Consensus

Although the main discussion is currently concentrated on Reddit, similar issues have been mentioned sporadically in the AI infrastructure community. Multiple independent sources point out that dynamic dependency loading in MCP servers is a weak link in supply chain security. The consensus is that static configuration pinning is insufficient to guarantee runtime security and that more fine-grained monitoring is needed. However, no agreement has been reached on best practices, and different teams have chosen different strategies based on their own environments.

Conclusion

The risk of silent drift in MCP servers reminds us that the security of AI infrastructure needs to extend from deployment time to runtime. Traditional scanning tools cannot cope with this kind of dynamic change, and teams need to explore more proactive detection mechanisms. Is your MCP server really pinned? Perhaps it's time to take another look.

#MCP server#silent drift#supply chain security#dependency pinning#runtime security
Share:

Related articles