MCP: The USB-C of AI — How Model Context Protocol Is Connecting Everything
From a quiet Anthropic open-source release to 100 million downloads per month, MCP is becoming the universal standard for connecting AI agents to tools and data.
Model Context Protocol (MCP) is an open standard that defines how AI applications — LLMs, agents, coding assistants, chatbots — connect to external tools and data sources through a single universal interface. In November 2024, Anthropic quietly open-sourced it with no keynote and no hype. By early 2026, MCP is downloaded roughly 100 million times per month, over 5,500 servers exist in the wild, and OpenAI, Google, and Microsoft have all adopted it.
Fast forward to early 2026, and MCP is downloaded roughly 100 million times per month. Over 5,500 MCP servers exist in the wild. OpenAI, Google, and Microsoft have all adopted it. Anthropic donated the protocol to the Linux Foundation for neutral governance. MCP has become, in remarkably short order, the USB-C of AI.
When your competitors adopt your standard, it stops being your standard and becomes the standard — that's why MCP won as the USB-C of AI.
What Is MCP?
The Model Context Protocol is an open standard that defines how AI applications — LLMs, agents, coding assistants, chatbots — connect to external tools and data sources. Any MCP-compatible client can discover, authenticate with, and invoke any MCP-compatible server without custom integration code.
The USB-C analogy earns its keep here. Before USB-C, every device had its own connector — Micro-USB, Thunderbolt, Mini-USB, USB-B. Before MCP, every AI integration was bespoke. Claude needed a custom plugin for your database. GPT needed a different one. Gemini needed another. None of them were compatible.
MCP replaces all of that with one protocol. Build an MCP server once, and it works with every AI client that speaks MCP — Claude, ChatGPT, Copilot, Cursor, your own custom agent, anything that comes along.
Why MCP Won
Plenty of AI standards have been proposed. Most went nowhere. MCP succeeded for a specific combination of reasons.
Timing. MCP arrived exactly when AI agents were taking off. Through 2024 and 2025, every major lab shipped agent capabilities — tool use, multi-step reasoning, autonomous execution — but every implementation was bespoke. MCP filled the vacuum at precisely the right moment.
Simplicity. MCP is built on JSON-RPC 2.0, the same lightweight protocol that powers the Language Server Protocol in every code editor. It is a thin, well-defined messaging format easy to implement in any language. If you have built a REST API, you can build an MCP server in an afternoon.
Backing. Anthropic open-sourced MCP from day one, but the real inflection point came when competitors adopted it. OpenAI integrated MCP into ChatGPT and the Agents SDK. Google added it to Gemini. Microsoft brought it to Copilot and VS Code. When your competitors adopt your standard, it stops being your standard and becomes the standard.
Open governance. Anthropic donated MCP to the Linux Foundation — the same model that made Kubernetes, GraphQL, and OpenTelemetry successful. Enterprise adopters got confidence that this wouldn't become a proprietary lock-in play.
Developer experience. The TypeScript and Python SDKs were excellent from the start. The spec was clear. Building an MCP server felt familiar, not alien.
How MCP Works
MCP follows a client-server architecture. AI applications (hosts) contain MCP clients that connect to MCP servers. Each server exposes capabilities through three primitives.
Resources are data the server exposes for the AI to read — think GET endpoints. A database server might expose tables as resources, identified by URIs and readable by the client.
Tools are actions the AI can invoke — think POST endpoints. A database server might expose a query tool that executes SQL. A GitHub server might expose a create_issue tool. Tools have defined JSON Schema input schemas and return structured results.
Prompts are reusable prompt templates the server provides — pre-built instructions optimized for specific tasks, like a "review this pull request" template that structures the AI's analysis consistently.
Transport Layers
MCP supports two primary transports. stdio runs the server as a local subprocess communicating via standard input/output — simple, no network configuration required, ideal for local tools. Streamable HTTP runs the server as a remote HTTP service, using HTTP POST with optional Server-Sent Events for streaming — the right choice for cloud-hosted or shared servers.
The Protocol Flow
A typical interaction goes: client connects and they exchange capabilities → client calls tools/list to discover available tools → AI model decides which tool to call → client sends tools/call with the tool name and arguments → server executes and returns the result → AI incorporates the result into its response. The whole thing is JSON-RPC 2.0 messages over whichever transport you've chosen.
Building and Consuming MCP Servers
The TypeScript SDK makes building a server straightforward. You create an McpServer instance, register tools with server.tool(), register resources with server.resource(), register prompts with server.prompt(), then connect a transport and start listening. Each tool registration takes a name, description, a Zod schema for inputs, and an async handler that returns structured content.
On the client side, most developers consume MCP servers through existing hosts — Claude Desktop, VS Code, Cursor — rather than building clients from scratch. But for custom agents, the SDK provides a Client class that connects to servers, calls listTools() to discover capabilities, and calls callTool() to invoke them.
The real power emerges in an agent loop: the client discovers tools from one or more MCP servers, converts them to the format the LLM expects, runs the model, and when the model requests a tool call, routes it to the right server and feeds the result back. An agent connected to a weather server and a filesystem server can check the weather and write a report to disk — all through the same standard interface.
Real-World Use Cases
MCP servers have spread across every domain where AI needs to interact with external systems.
- Database access — PostgreSQL, MySQL, SQLite, and MongoDB servers let agents query databases directly, explore schemas, and analyze results without copying data into prompts.
- File system and code analysis — Agents can read, write, search, and navigate codebases, and combined with tree-sitter or LSP servers, understand code structure at a deep level.
- API integrations — GitHub, Jira, Slack, Linear, and Notion servers let agents interact with the tools teams already use — creating issues, updating tickets, sending notifications.
- Monitoring and observability — Datadog, Grafana, and PagerDuty servers let agents monitor infrastructure, query metrics, and correlate errors across services without a human navigating multiple UIs.
- Browser automation — Playwright and Puppeteer servers give agents the ability to browse, fill forms, take screenshots, and scrape data.
Popular community servers include Filesystem, GitHub, PostgreSQL, Playwright, Slack, Google Drive, Docker, Kubernetes, Sentry, and Stripe. As of early 2026, over 5,500 community-built MCP servers exist across every domain.
Security Considerations
MCP servers expose real capabilities to AI systems. Security is foundational, not optional.
MCP supports OAuth 2.1 for remote servers, enabling proper authentication, scoped permissions, and per-user authorization. For local stdio servers, the security boundary is the OS process model. The ecosystem recommends a layered trust model: local servers in sandboxed subprocesses with limited filesystem access, remote servers over HTTPS, user confirmation before destructive operations, and audit logs of all tool invocations.
One risk specific to MCP: because servers return data that feeds into LLM context, they're a potential vector for indirect prompt injection — a malicious data source including instructions that try to manipulate the AI. Defenses include input sanitization, output validation, and keeping tool results in structured formats the LLM treats as data rather than instructions.
Key best practices: principle of least privilege, read-only access by default, explicit opt-in for writes, rate limiting on remote servers, strict input validation with Zod or JSON Schema, and human-in-the-loop confirmation for irreversible actions.
What's Next for MCP
The protocol is still young. Several major developments are in flight.
Streamable HTTP replaces the original SSE-based transport with bidirectional streaming, better error handling, and session resumption — making remote servers more robust for long-running operations.
Improved authentication brings full OAuth 2.1 support including PKCE flows, dynamic client registration, and token refresh, making multi-tenant MCP servers practical.
Agent-to-agent communication is one of the most exciting directions: using MCP not just to connect AI to tools, but to connect AI to AI — enabling multi-agent systems where specialized agents collaborate through well-defined interfaces.
Elicitation will allow servers to request additional information from the user during tool execution, enabling interactive workflows beyond simple request-response.
Conclusion
MCP started as a quiet open-source release and became the standard protocol for connecting AI to the world. It succeeded because it was simple, open, and arrived at exactly the right moment.
The implications are significant. Before MCP, every AI integration was a custom project. After MCP, integrations are composable, reusable, and universal. A tool built for Claude works with GPT works with Gemini works with your custom agent. The ecosystem effect is just beginning — 5,500 servers today will be 50,000 by end of year.
For developers, the message is clear: learn MCP now. If you build tools, APIs, or services, expose them via MCP. If you build AI applications, consume MCP servers. If you build agents, use MCP as your universal tool interface. The standard has won.
The best infrastructure is invisible. MCP is becoming the invisible layer that connects AI to everything — and like the best standards, once it is everywhere, we will wonder how we ever built anything without it.
Continue reading
Hermes Agent Desktop Free With Local LLMs: The Claude Code Alternative Nobody's Billing You For [2026]
Hermes Agent runs a full coding agent on your local machine with zero API costs. Here's which models actually work, the hardware you need, and how to set it up.
MCP vs OpenAI Function Calling 2026: Which Tool Protocol Wins?
MCP wins for multi-model, cross-vendor agent ecosystems; OpenAI function calling wins for teams already deep in the OpenAI stack. Your choice depends on how vendor-locked you're willing to be.
AI Slopageddon: How AI-Generated Code Is Destroying Open Source
Open-source maintainers are shutting down contributions as AI-generated submissions flood projects with low-quality code. From cURL's killed bug bounty to GitHub's proposed kill switch, the crisis is real.
Frequently Asked Questions
What does MCP actually do in plain terms?
MCP gives AI assistants a standardized way to connect to external tools and data — things like databases, GitHub, or internal company systems — without needing a custom-built connection for each one. Think of it like a universal charging cable: instead of needing a different cable for every device, one standard works for all of them. Developers build a tool once using MCP, and any AI that supports the standard can use it immediately.
Why did MCP take off when other AI standards failed?
MCP launched at exactly the right moment, when AI agents were becoming mainstream but no common standard existed for connecting them to tools. It was also deliberately simple to build with, and Anthropic open-sourced it from day one rather than keeping it proprietary. The decisive moment came when OpenAI, Google, and Microsoft all adopted it — once competitors embrace a standard, it effectively becomes the industry standard.
Does MCP only work with Claude, or does it work with other AI models too?
MCP works across all major AI platforms, not just Claude. OpenAI integrated it into ChatGPT and their Agents SDK, Google added support in Gemini, and Microsoft brought it to Copilot and VS Code. Any AI client that supports MCP can connect to any MCP-compatible server, regardless of which company made either one.
Who controls MCP now — is it still Anthropic's project?
Anthropic donated MCP to the Linux Foundation, which now provides neutral, independent governance over the protocol. This is the same model used for major open-source projects like Kubernetes and GraphQL. The move was specifically intended to assure businesses that MCP would not become a proprietary tool controlled by a single company.
How hard is it to build something with MCP?
MCP is designed to feel familiar to developers who have already built standard web APIs. It runs on JSON-RPC 2.0, a lightweight and well-established messaging format, and official SDKs are available in both TypeScript and Python. According to the post, a developer comfortable with REST APIs could build a working MCP server in a single afternoon.
What are the main things an MCP server can expose to an AI?
An MCP server can offer three types of capabilities: resources, which are data the AI can read (like database tables or files); tools, which are actions the AI can trigger (like running a search or creating a support ticket); and prompts, which are pre-built instruction templates optimized for specific tasks. Together these three building blocks let developers define exactly what an AI is allowed to see and do through their server.
Kunal Ganglani (2026, February 28). MCP: The USB-C of AI — How Model Context Protocol Is Connecting Everything. Kunal Ganglani. Retrieved August 13, 2026, from https://www.kunalganglani.com/blog/mcp-model-context-protocol-usb-c-of-ai