In late November, Anthropic released something called the Model Context Protocol, or MCP. It did not get the attention that a new model launch gets. No benchmark charts, no demo videos going viral. But I have been reading the spec and playing with it over the holidays, and I think it might be one of the most important AI releases of the past year. Not because it is clever. Because it is boring, in the best possible way.
The problem nobody puts on slides
Here is a dirty secret of AI projects inside companies. The model is rarely the hard part. The hard part is connecting the model to the things it needs. Your database, your ticket system, your document store, your internal APIs. Every one of those connections is custom work. Custom authentication, custom data formats, custom error handling, custom maintenance forever.
If you have one AI application and five internal systems, you build five integrations. Add another AI application, five more. The math is ugly. With M applications and N systems, you are looking at M times N integrations. Each one is code someone has to write, test, secure, and keep alive when the API on the other side changes. I have watched promising AI projects die exactly here. Not in the model evaluation, not in the prompt design. In the integration backlog, where the budget quietly runs out.
One connector instead of many
MCP attacks this with an old and proven idea, a standard interface. The analogy everyone uses, and I will use it too because it is good, is USB.
Before USB, every device had its own port. Printers had one connector, keyboards another, mice another, and your computer needed a specific port for each one. Then USB arrived and said, everyone speaks this one protocol now. Device makers build to the standard once. Computer makers build to the standard once. And suddenly any device works with any computer.
MCP wants to do this for AI. A system exposes its data and actions through an MCP server, once. An AI application speaks MCP as a client, once. After that, any compliant application can talk to any compliant system. The M times N problem becomes M plus N. If you build software for a living, you know that turning multiplication into addition is the kind of thing that changes budgets.
We already learned this lesson once
What makes me optimistic is that we have seen this movie. Fifteen years ago, companies kept building point to point integrations between internal systems. Every connection was a special snowflake. Then the API first idea spread, the thinking that Martin Fowler and others pushed for years, where you treat your system boundaries as products with stable contracts. Companies that took that seriously got faster. Not because any single API was brilliant, but because every new connection got cheaper than the last one.
That lesson cost the industry a lot of money to learn. MCP is basically that same lesson, applied to AI before the mess gets too big. Standard interfaces are how an ecosystem grows. Nobody remembers the USB spec authors, but everyone benefits from them every day.
The business angle, because there always is one
Let me put this in money terms, because that is how I think about architecture now after years in this work.
Integration cost is where AI projects die. I said it above and I will say it again because it is the whole point. When a leadership team approves an AI pilot, they imagine paying for the model and some development. What actually eats the budget is the long tail, connecting to legacy systems, handling permissions, keeping integrations alive. If a standard removes even half of that cost, the math of many borderline projects flips from no to yes.
There is also a risk side. Custom integrations create lock in. If your AI tooling is hand wired to one vendor, switching later means rewriting everything. A standard protocol means the connectors survive even if you change the model or the application on top. For anyone making a multi year bet on AI inside a company, that optionality is worth real money.
My honest caveats
I am not declaring victory. MCP is weeks old. Standards only matter if people adopt them, and the graveyard of well designed protocols that nobody used is large. The security story needs to mature, because giving an AI a standard way to reach your systems means you need a very good answer about what it is allowed to do there. And there will probably be competing standards, because there always are, and we may get a format war before we get a winner.
But the direction feels right to me. The AI world has been all about capability for two years, what can the model do. The next phase is about connection, what can the model reach, safely and cheaply. That is plumbing work. Plumbing is never exciting. It is also where most of the value in real companies gets unlocked.
If you are a developer, my suggestion is simple. Spend one afternoon building a small MCP server for something you own, even a toy. The concepts are simple and the spec is readable. Worst case, you lose an afternoon. Best case, you understand early the thing that quietly becomes the USB port of this whole era. I have made worse bets with my afternoons .
Pax et bonum.