A few months ago, I was reviewing an architecture for an agentic workflow on our team, and something struck me: we’d wired up half a dozen tools to our agent in an afternoon. A year ago, that same integration work would’ve taken a sprint, maybe two. That’s the promise of the Model Context Protocol, and it’s a big part of why it’s spread so fast across enterprise AI stacks.
If you haven’t worked with it yet, MCP is Anthropic’s open standard, introduced in late 2024, for connecting AI models to external tools, data sources, and services. Instead of every team writing a custom integration for every database, API, or internal system their agent needs to touch, MCP gives you one consistent interface. An MCP Host is basically the app running your agent that connects to MCP Servers, each exposing tools the agent can discover and use on the fly.
A simplified view of how an MCP host connects to tools through discovery and an identity layer.
A simplified view of how an MCP host connects to tools through discovery and an identity layer. That’s the part everyone talks about. What gets talked about less is what happens once you actually put this into production at scale. The speed is real, and it’s addictive. Once you’ve built or plugged in an MCP server, any agent that speaks MCP can use it.
Tool discovery happens dynamically, so your agent isn’t locked into hardcoded logic; it figures out what’s available and picks the right tool for the job. And because MCP has caught on so broadly, a lot of platforms now ship with MCP servers already built. What used to be weeks of integration work is often a few hours now. It’s genuinely a good problem to have moved fast on. But it’s also exactly why security tends to become an afterthought.
Where it starts to bite: Here’s the thing about MCP that doesn’t get enough airtime: the properties that make it fast are the same ones that make it risky if you’re not deliberate about security from day one. Tool poisoning is a good example: a malicious or compromised tool description can manipulate how your agent behaves, because that description lives in a part of the context your users never actually see.
There’s also the credential problem: a lot of early MCP deployments still lean on static, long-lived API keys shared across a whole connection. Compromise one key, and you’ve potentially handed over everything that server can touch. Security researchers have started calling this “God-mode by accident,” which is a pretty accurate way to put it.
Then there’s supply chain risk. MCP servers often come from open source registries, the same way npm or PyPI packages do, and a vulnerable or malicious server can quietly become part of your agent’s toolchain without anyone noticing until something breaks. And even when access controls exist, they’re often too coarse: systems that check whether an agent can call a tool, but not what it should actually be allowed to touch once it’s inside. Knowing Agent A can run a tool isn’t the same as knowing it can see File X but should never touch File Y.
This isn’t hypothetical anymore. Earlier this year, OASIS’s Coalition for Secure AI and the Cloud Security Alliance both put out frameworks specifically to help teams assess and mitigate MCP risk, which tells you this has moved from “something to keep in mind” to “something you need a plan for.”
What’s actually worked for us, I don’t think the answer is to slow down. It’s to stop treating speed and security as two separate conversations. A few things that have made a real difference on our side: treating MCP servers the same way we’d treat any third-party dependency, vetting them, pinning versions, watching for supply chain issues, not just trusting that “it’s from a registry” means it’s safe.
Moving away from static credentials toward identity propagation, so every tool call gets authorized based on who’s actually making the request and why, not a broad service account that can do anything, forever. Getting more granular with authorization in general, tool-level access is a starting point, not the finish line. And logging tool calls in enough detail that if something goes wrong, you can actually reconstruct what happened, because “we’re not sure why the agent did that” is not an answer that survives a security review, let alone an audit.
None of this is exotic. It’s the same zero-trust thinking that’s shaped good infrastructure security for years; it just hasn’t fully caught up to how agentic systems actually behave, which is a lot more lateral and a lot less predictable than the systems most of our tooling was built to watch.
Where I land on this MCP has done for agentic AI roughly what REST did for web APIs: it took something fragmented and painful and made it standard. That’s exactly why adoption took off the way it did. But “easy to connect” and “safe to connect” aren’t the same thing, and the gap between them is where most of the current MCP security incidents are coming from.
The teams I’ve seen get this right aren’t the ones bolting security on after the fact. They’re the ones who treat identity-aware, tightly scoped access as part of the architecture from the start, so speed and security stop competing and start being the same decision.
Photo by Jahanzeb Ahsan on Unsplash