One plug for every tool

Before there was a standard, connecting an AI model to your tools was an N-times-M problem, and the multiplication is what killed you. Every model or assistant you wanted to support, times every tool or data source you wanted it to reach, was a custom integration someone had to write and then maintain forever. Ten assistants and ten tools isn’t twenty pieces of glue; it’s a hundred. Each one a slightly different way to describe “here’s a function you can call, here’s what it takes, here’s what it returns.” Everyone rebuilt the same wiring, badly, in parallel.

The Model Context Protocol is the answer that stuck: instead of custom glue per pair, agree on one protocol for how a model-facing application talks to the outside world, and let everyone build to that. The analogy that spread — “USB-C for AI” — is exactly right about the shape of the win. USB-C didn’t make devices more capable; it made one connector work everywhere, so the peripheral maker and the laptop maker stopped negotiating a new cable for every combination. MCP does that for tools and context: build your integration once, against the protocol, and any client that speaks it can use it.

The pieces are simpler than the acronym suggests. There’s a host — the app the user is actually in (an assistant, an IDE, an agent). Inside it runs a client that speaks the protocol. And out in the world sit servers — small adapters you or a vendor writes that expose some capability: your database, your ticketing system, a file store, an internal API. A server offers a few kinds of things: tools (actions the model can invoke, like “create ticket” or “run query”), resources (data it can read), and prompts (reusable templates). The client discovers what a server offers and mediates the calls. The model doesn’t get raw keys to your database; it gets a menu of well-described capabilities, and something in the middle decides what actually runs.

Why it caught on so fast is boring and correct: it solved a problem everyone had at the same moment, it was published as an open standard rather than one vendor’s moat, and the timing lined up with agents suddenly needing to do things instead of just talk. Within about a year it went from one company’s internal experiment to something the whole ecosystem builds against — the classic sign that a protocol filled a real hole rather than invented one.

The build decision it hands you is twofold. If you make a product, the question is whether to expose your capability as an MCP server — because if agents are how a growing share of users reach software, being one clean plug away from every assistant is distribution, not just an integration. And if you consume MCP servers inside your own agent, the caution is the same one the security world spent this year shouting about: a tool is an API with an actor on the end that will try things you didn’t picture. Each tool you expose is a permission you’re granting; scope it, log it, and review it like the API it is. The protocol makes connection easy. It doesn’t make trust automatic — that part is still yours.

The systems, to look up: the Model Context Protocol — an open standard introduced by Anthropic in late 2024 and widely adopted across the ecosystem through 2025-26; its host/client/server model and the tools/resources/prompts primitives; the “USB-C for AI” framing.