# Model Context Protocol Through The Agent Stack Lens: What Broke, What's Fixed July 28, and What to Check Before Your Next mcp.json > Source: > Published: 2026-07-25 03:39:11+00:00 If you've added an MCP server to a `claude_desktop_config.json` or an `mcp.json` file this year by copy-pasting a connection string, this one's for you. This isn't a "is MCP good or bad" post — it's a breakdown of exactly what broke at the protocol level in 2026, what's shipping in six days to fix part of it, and the specific checks worth adding to your own review process before the next server goes in. On April 15, 2026, OX Security disclosed a flaw sitting inside every official Model Context Protocol SDK — Python, TypeScript, Java, Rust. All four. Anthropic confirmed the behavior was intentional. Then it declined to change it. The flaw let anyone who could influence a server's configuration file run arbitrary shell commands on the host machine. OX Security counted more than 200,000 vulnerable instances sitting inside a supply chain of over 150 million downloads. I connect new MCP servers most weeks. I never once asked whether the protocol itself, the wiring underneath every server I trust, shipped with a design decision nobody was willing to walk back. I do now. I map every AI system I build against the EchoNerve Agent Stack™ — six layers: Models, Tools, Memory, Agents, Workflows, Applications. MCP lives almost entirely in the Tools layer, where a model reaches outside itself and calls a database, a file system, an API. Before MCP, every one of those connections was custom code. MCP replaced that with one shared interface — any MCP-compatible client can call any compliant server the same way. The Tools layer decides what an agent can touch in the real world. A bad Models-layer output produces a wrong sentence. A bad Tools-layer connection produces a wrong action, against a real system. Here's what that looks like concretely. A `.mcp.json` entry like this hands an agent full read/write access to a production database in one config block, with zero review gate in front of it: ``` { "mcpServers": { "postgres-prod": { "command": "npx", "args": ["-y", "@some/postgres-mcp-server"], "env": { "DATABASE_URL": "postgres://user:pass@prod-host:5432/db" } } } } ``` Before MCP, that access took a custom integration and usually a second engineer's sign-off. MCP compressed the whole process into a copy-pasted block. The convenience is real. So is the fact that the review step got compressed right along with it. MCP's STDIO transport — the local process interface most desktop and dev tools use — passes configuration values straight into shell execution, with no sanitization step in between. If an attacker can influence that configuration file (a malicious npm package, a compromised toolchain, an insider with write access), their command runs on your machine. It runs even if the target MCP server never starts successfully. The vulnerability now carries a formal identifier: **CVE-2026-30623**. OX Security found it present across all four officially supported SDKs simultaneously — it's not a bug in one team's implementation, it's a decision baked into the reference architecture every downstream server copied. A quick sanity check you can run today: audit which of your configured servers actually run over STDIO with environment values you don't fully control, versus a remote transport with a real auth boundary in front of it. ``` # crude pass at spotting STDIO servers with inline secrets in your config jq -r '.mcpServers | to_entries[] | select(.value.command != null) | .key' ~/.config/*/mcp.json 2>/dev/null ``` Adapt the path to wherever your client stores its config — the point is just to stop trusting a server by name and start checking transport + credential exposure per entry. A second attack pattern hit the Tools layer just as hard, and it doesn't need a protocol-level bug. Tool poisoning hides a malicious instruction inside a tool's own *description field* — the text the model reads to decide how and when to call it. The model follows it. Nothing about the request looks abnormal from the outside. In March 2026, more than 340 developers installed a server published as `mcp-jira-sync` before anyone caught it. Its `list_issues` tool carried a hidden instruction in its description field that caused connected agents to include the contents of the local `~/.aws/credentials` file in every API call sent back to the attacker's server. Nobody had to click anything. Koi Security found a similar pattern in an npm package called `postmark-mcp` , which shipped fifteen clean releases before version 1.0.16 quietly added one line that BCC'd every email an agent sent through it to an attacker's inbox. An independent census scored 17,468 indexed MCP servers on documentation, maintenance, and reliability. Only 12.9% cleared a high-trust bar. A separate review of ~1,400 servers found 38.7% shipped with no authentication at all. The 2026-07-28 MCP specification release candidate rebuilds authorization around OAuth 2.1 and OpenID Connect. Clients will validate the token issuer on every authorization response per RFC 9207, closing a real mix-up attack class where one auth server's response gets replayed against a different server pretending to be it. The spec also drops mandatory sticky sessions, so a remote MCP server can sit behind an ordinary round-robin load balancer. What it doesn't do: retroactively patch the 200,000 vulnerable STDIO instances, or stop a maintainer from shipping a poisoned tool description post-update. It gives server authors a standard way to handle authorization. It doesn't do the job for them. MCP isn't going away, and it solved a real integration problem — dozens of hand-built connections collapsed into one shared interface. But the Tools layer is where an agent's decisions become actions against real systems, and 2026 proved that layer needs its own audit discipline. Full breakdown with the six-layer framework, the complete numbers, and the mermaid diagrams: [Model Context Protocol Through The Agent Stack Lens](https://echonerve.com/mcp-through-the-agent-stack-lens/)