The MCP protocol and the toolbox for AI

Standards are the most boring and most important things in technology.

USB didn’t get a Super Bowl ad. HTTP didn’t have a launch event with a leather-jacket-wearing CEO. TCP/IP wasn’t trending on social media. But each of those standards reshaped the world by making it possible for different systems to talk to each other without custom wiring.

Anthropic released the Model Context Protocol, and I think it’s going to be one of those boring, important things.

What MCP actually is

Right now, if you want an AI model to use a tool (read a file, query a database, call an API), you have to build a custom integration. Every tool. Every model. Custom code. If you have 10 tools and 3 AI providers, that’s 30 integrations. Change one tool and you update 3 integrations. Change one model and you update 10.

MCP is a standard protocol that sits between the AI model and the tools. Build your tool to speak MCP once, and any MCP-compatible model can use it. Build your model to speak MCP once, and any MCP-compatible tool is available.

That’s it. That’s the whole thing. One protocol. Universal compatibility. Boring. Important.

Why I care about this

I’ve been building AI-powered tools for two years. The amount of time I’ve spent writing custom integrations is embarrassing. Every new model, every new API, every new data source requires glue code. The glue code has more bugs than the actual logic. The glue code takes longer to maintain than the product it connects.

MCP kills the glue code.

The GitHub repo already has reference implementations. Server-side tools are straightforward to build. The protocol handles authentication, capability negotiation, and data formatting. Someone building a tool doesn’t need to know which AI model will use it. Someone building a model doesn’t need to know which tools will be available.

Decoupling. That’s the word. MCP decouples AI models from the tools they use, the same way HTTP decoupled web browsers from web servers.

The bigger picture

AI models that can use tools are fundamentally more useful than AI models that can only generate text. A model that can read your files, search the web, run code, and call APIs can do real work. But until now, the tool world was fragmented. Every provider built their own approach. Switching models meant rebuilding integrations.

With a standard protocol, the tool world can grow independently of the model world. Tools compete on quality. Models compete on intelligence. Neither is locked to the other.

That’s how platforms emerge. That’s how ecosystems get built. Not with flashy launches, but with boring standards that make everything else possible.

I’m probably more excited about this than most people. I’ve seen what happens when standards take hold. The growth goes from linear to exponential, because every new tool multiplies the value of every existing model, and every new model multiplies the value of every existing tool.

Standards are boring. Standards change everything.

Related thinking: