
MCP is becoming the global AI agent standard — and is also becoming the biggest backdoor that few people lock
In just the first four months of 2026, researchers have disclosed more than 40 security vulnerabilities (CVEs) in Model Context Protocol implementations — an average of one new vulnerability reported approximately every four days throughout the year. It's worth noting that this number doesn't come from a protocol with few users. MCP currently has more than 97 million SDK downloads per month, more than 10,000 active public servers, and has just been handed over to the Linux Foundation by Anthropic at the end of 2025 to become an open standard governed by the community - almost every major AI tool today, from Claude, ChatGPT to IDEs like Cursor, VS Code, supports it.
In other words: the communication standard between AI agents and the real world is developing at breakneck speed, and the accompanying security layer is running behind, quite far behind.
MCP solves a very real problem — but the solution to that problem is opening up another problem.
Before MCP, connecting an AI agent to an external tool — GitHub, Postgres, Slack, Notion — meant having to write separate integrations for each pair of tools and each AI client. The more tools, the more clients, the number of integrations that need to be written increases exponentially. MCP solves exactly that problem with a single standard interface — like USB-C for AI, it can be plugged in anywhere. It is precisely because of solving the right pain that the speed of application is so fast.
But the rapid adoption rate brings with it a worrying reality: according to a survey by Clutch Security, 86% of MCP servers are currently running right on developers' personal machines, only about 5% are deployed in truly controlled production environments. It sounds safe — "If it runs on your computer, no one can touch it" — but this is the most dangerous misconception. A study that scanned more than 7,000 publicly available MCP servers found that 36.7% were at risk of SSRF attacks, and in a real-world test case targeting Microsoft's MCP servers, the research team obtained AWS IAM access keys and session tokens from just one exposed endpoint metadata — a misconfigured MCP server that became the gateway to the entire cloud infrastructure.
The authentication numbers are even more worrying: only 8.5% of MCP servers currently use OAuth, with the majority relying on weak or almost non-existent authentication mechanisms. Another survey of more than 2,600 MCP deployments found that 82% used file manipulation that was at risk of being exploited through a path traversal bug — an error that allows an attacker to read or write files outside the allowed scope. As for the command injection error, nearly half of the tested MCP servers were considered vulnerable to exploitation.
Attack techniques that are exploiting this gap have their own names: tool poisoning (poisoning describes a tool so that the agent voluntarily does something it shouldn't do), rug pull (a tool that is initially harmless and then silently changes its behavior after being approved), tool shadowing (impersonating a legitimate tool to gain execution rights). What all three have in common: they exploit the gap between when an agent is approved to use a tool and when that tool actually runs — a gap that traditional security tools like WAFs or API gateways are not designed to see.
So what should the team that is building or about to build an AI agent using MCP do this week?
First, inventory all MCP servers running in the team — including those running "temporarily" on personal computers for testing. Many of the vulnerabilities exploited come from servers that no one remembers turning on.
Second, block public IP access for any MCP servers that don't really need to be open to the internet, and put the remaining servers in a sandbox instead of running directly on the machine containing sensitive data.
Third, for any MCP server with access to real data or production systems, OAuth or equivalent authentication is required instead of the default — the current 8.5% of servers with OAuth is the number that needs to change first in any team that prioritizes security.
The most common mistake today is to consider "installing a community MCP server" like installing a normal npm library — download it, use it immediately, rarely read carefully what permissions it is asking for. While an MCP server, in essence, is being given authority to act on behalf of the agent — the right to read files, call APIs, even execute system commands. Granting that permission without checking the source is like giving a house key to a stranger just because they wear the same uniform as an acquaintance.
MCP deserves to be studied seriously — it is the standard infrastructure for the next generation of AI agents, not a trend that will disappear in a few months. But learning to use it properly must come with learning to lock it properly. The team that can do both will be the first team, not because they use MCP earlier, but because they don't have to pay for the part that most others are ignoring.