I’ll admit something: when Anthropic released the Model Context Protocol in November 2024, I didn’t pay much attention. Another open standard from another AI company. Cool. Moving on.
A year later, I was wrong. Very wrong.
MCP is now running in ChatGPT, Gemini, Microsoft Copilot, VS Code, Cursor, and thousands of developer tools. It hit 100 million monthly SDK downloads. OpenAI, Google, and Microsoft — companies that agree on almost nothing — all adopted it. In December 2025, Anthropic donated it to the Linux Foundation, where it now sits alongside Kubernetes and PyTorch as foundational open-source infrastructure.
So what happened? And why should you care?
The Problem Nobody Wanted to Solve
Here’s the dirty secret of AI development: connecting an AI model to your actual tools and data is a nightmare.
Say you want Claude to read your Google Drive files, check your calendar, and create a Jira ticket. Before MCP, you’d need to:
- Write custom code to authenticate with Google’s API
- Write different custom code to talk to Jira’s API
- Figure out how to pass data between them
- Handle all the edge cases when things break
- Do this all over again when you want to add Slack
Now multiply that by every AI app and every tool. If you have 10 AI applications and 50 tools you want them to access, you’re looking at 500 different integrations. Each one custom-built. Each one maintained separately.
This is what developers call the “N×M problem.” N apps times M tools equals an explosion of bespoke code that nobody wants to write or maintain.
The big AI labs tried to solve pieces of this. OpenAI released function calling in 2023. They launched ChatGPT plugins. These helped, but they were vendor-specific. A plugin built for ChatGPT didn’t work with Claude. A function defined for GPT-4 needed to be redefined for Gemini.
Everyone was building their own version of the same wheel. Thousands of times over.
What MCP Actually Is
MCP is embarrassingly simple in concept: it’s a standard way for AI applications to talk to external tools.
Think about USB-C. Before USB-C, you had Lightning cables, micro-USB, mini-USB, proprietary chargers for laptops, different ports for monitors. It was chaos. USB-C said: one connector, one standard, everything plugs into everything.
MCP does the same thing for AI. Instead of building a custom integration for every AI-plus-tool combination, you build one MCP server for your tool. Then any MCP-compatible AI application can use it. Write once, use everywhere.
The architecture has three pieces:
MCP Hosts are the AI applications — Claude Desktop, ChatGPT, Cursor, or whatever you’re building. They’re the things that want to use tools.
MCP Clients live inside those hosts. They handle the actual communication with external services. Think of them as translators.
MCP Servers are lightweight programs that expose tools and data. A Google Drive MCP server knows how to read and write files. A GitHub MCP server knows how to fetch issues and create pull requests. A Postgres MCP server knows how to run queries.
The magic is in the standardization. Every MCP server speaks the same language. Every MCP client knows how to understand it. The protocol handles discovery (what tools are available?), execution (run this tool with these parameters), and context (here’s the data you asked for).
Under the hood, it’s all JSON-RPC 2.0 — the same message format that powers the Language Server Protocol that your IDE uses for code completion. This wasn’t an accident. The team explicitly borrowed from LSP because it’s battle-tested infrastructure that developers already understand.
For the Technical Folks: How It Actually Works
Let me walk through what happens when an AI agent uses MCP to complete a task.
Say you ask Claude: “Download my meeting notes from Google Drive and create a summary in Notion.”
First, Claude’s MCP client looks at its connected servers. It sees a Google Drive server and a Notion server, each advertising their capabilities through a standardized schema.
The Google Drive server exposes tools like search_files, read_file, and upload_file. Each tool has a defined input schema (what parameters it accepts) and output schema (what it returns). The Notion server exposes create_page, update_page, search_database, and so on.
Claude picks the right tools for the job. It calls search_files on the Drive server to find the meeting notes. The server authenticates with Google, runs the search, and returns the results. Claude then calls read_file to get the actual content.
Now it has the text. It generates a summary. Then it calls create_page on the Notion server to write that summary somewhere useful.
What’s powerful here is that Claude didn’t need to know anything about the Google Drive API or Notion’s API. It just needed to understand the MCP interface. The servers handle all the vendor-specific complexity behind a clean abstraction.
This separation is crucial for a few reasons:
Security gets cleaner. Each MCP server only has access to what it needs. The Google Drive server can’t touch your Notion workspace. The Notion server can’t read your email. You grant permissions at the server level, not to the AI model directly.
Maintenance becomes manageable. When Google changes their API (which they do constantly), only the Google Drive MCP server needs updating. Every AI application using it through MCP keeps working.
Development gets faster. Instead of every AI developer learning every API, they learn MCP once. The community builds servers for popular tools, and everyone benefits.
The Adoption Curve That Surprised Everyone
The first few months after launch were quiet. MCP was mainly used by developers improving their AI-assisted coding setups. Useful, but niche.
Then things accelerated.
The origin story helps explain why. MCP didn’t come from a grand strategic initiative. It came from a developer named David Soria Parra who was frustrated with constantly copying code between Claude Desktop and his IDE. He wanted a better way to give Claude access to his development environment. That itch became the protocol.
This matters because MCP solved a real problem that real developers actually had. It wasn’t theoretical. It wasn’t a spec designed by committee. It was built to scratch an itch, then generalized.
By early 2025, the coding assistant ecosystem had embraced it. Cursor, Windsurf, Zed, Sourcegraph — all adopted MCP. Developers could suddenly give their AI coding assistants access to their entire project context, not just the file they were looking at.
Then came the big dominos.
March 2025: OpenAI adopted MCP across the Agents SDK, Responses API, and ChatGPT desktop app. Sam Altman posted: “People love MCP and we are excited to add support across our products.” When your biggest competitor adopts your open-source protocol, you know something significant is happening.
April 2025: Google DeepMind confirmed MCP support for Gemini. The Verge reported it addressed “growing demand for AI agents that are contextually aware and capable of pulling from diverse sources.”
May 2025: Microsoft announced MCP integration in Windows 11, Azure OpenAI, and across the Microsoft 365 ecosystem. At Build 2025, they positioned it as core infrastructure for AI agents.
By this point, the four major AI platforms — Anthropic, OpenAI, Google, Microsoft — had all committed to the same protocol. This almost never happens in tech. OAuth took years to reach this level of adoption. OpenAPI took half a decade. MCP did it in under a year.
December 2025: Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation. The foundation was co-founded by Anthropic, Block, and OpenAI, with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg. This wasn’t just symbolic. It guaranteed MCP would remain vendor-neutral. No single company could steer it for competitive advantage.
Why Did It Win?
A lot of standards try to become universal. Most fail. Why did MCP succeed where others didn’t?
It solved immediate pain. MCP wasn’t a solution looking for a problem. Developers were already drowning in custom integrations. They wanted this to exist.
The timing was perfect. AI agents were moving from demos to production exactly as MCP launched. Companies needed a standard right when MCP offered one.
The technical foundation was solid. Building on JSON-RPC and borrowing patterns from LSP meant MCP felt familiar to developers. The learning curve was gentle.
Vibe coding made experimentation easy. Here’s an underrated factor: by 2025, developers could use AI assistants to quickly build MCP servers. The combination of good documentation plus AI-assisted coding meant the barrier to trying MCP was incredibly low. People could build a working MCP server in an afternoon.
The big labs were aligned. OpenAI, Google, and Microsoft all had the same problem: they needed AI agents to connect to third-party tools, and maintaining proprietary integration ecosystems was expensive. A shared standard benefited everyone. For once, competitive dynamics pushed toward cooperation rather than fragmentation.
Anthropic let it go. Donating MCP to the Linux Foundation was a smart move. It removed the concern that Anthropic would use MCP as a competitive moat. Once it was vendor-neutral, the last objections to adoption disappeared.
What This Means for You
If you’re building with AI — whether you’re a developer, a product manager, or just someone trying to connect your tools — MCP changes the game.
For developers: You no longer need to build custom integrations for every AI platform. Write an MCP server once, and it works with Claude, ChatGPT, Gemini, and anything else that speaks MCP. The ecosystem already has thousands of servers for common tools. Check the MCP Registry before building your own.
For enterprises: MCP provides a governance layer for AI tool access. Instead of AI models directly calling APIs with broad permissions, MCP servers mediate access. This makes it easier to audit what AI agents can do, enforce security policies, and maintain compliance.
For tool makers: If you build software that people use, consider shipping an MCP server. It’s how your product becomes accessible to the AI ecosystem. Salesforce, ServiceNow, GitHub — they’re all building official MCP servers because they understand this is how their tools stay relevant.
For everyone else: Pay attention to which AI assistants support MCP and which don’t. The ones that do will be more capable because they can connect to more of your stuff. The “USB-C of AI” analogy is useful here: you want your devices to use the universal port, not proprietary connectors that limit what you can plug in.
What’s Coming Next
MCP is at version 1.0 and relatively stable, but the roadmap is ambitious.
Better streaming and async operations. The current spec handles simple request-response patterns well. Longer-running tasks — think “monitor my inbox and alert me when something important arrives” — need better support for streaming updates and asynchronous notifications.
Sampling capabilities. This one’s interesting. Today, MCP servers expose tools that AI models call. The next evolution lets MCP servers trigger AI model calls themselves. This enables multi-agent workflows where specialized agents handle specific tasks and coordinate through MCP.
Enterprise registries. Large organizations need private MCP registries with governance controls — who can install which servers, what permissions they get, audit logs for compliance. The spec is adding support for self-hosted registries with enterprise-grade management.
Richer security primitives. The April 2025 security analysis flagged real concerns: tool combinations that could exfiltrate data, lookalike tools that silently replace trusted ones. The community is actively working on better permission models, capability restrictions, and verification systems.
The bigger picture is that MCP is becoming infrastructure for something larger: an agentic web where AI systems can take actions on your behalf across the internet. Google’s Universal Commerce Protocol for AI-powered shopping, OpenAI’s agentic tools, Anthropic’s Cowork — they all build on MCP as the connectivity layer.
The Takeaway
MCP is one of those rare technologies that succeeds by being boring in the right way. It doesn’t do anything flashy. It just standardizes how AI applications connect to tools, and it does it well enough that everyone adopted it.
A year ago, every AI company was building their own proprietary integration layer. Today, they’re all speaking the same language. That shift happened faster than almost anyone predicted, and it happened because MCP solved a real problem at exactly the right moment.
If you work with AI at all, MCP is now part of your world whether you know it or not. The tools you use are built on it. The integrations you depend on flow through it. Understanding how it works — even at a high level — helps you understand how the AI ecosystem actually fits together.
The USB-C analogy isn’t perfect. But it captures something true: MCP is the standard connector that makes everything else possible. And like USB-C, you don’t need to think about it constantly. You just need to know it exists, and appreciate that for once, the industry agreed on something sensible.