MCP: The Integration Standard the AI Era Was Missing

A protocol announcement worth actual attention, which is rare enough in our experience to be the lede. On November 25, Anthropic open-sourced the Model Context Protocol, or MCP. A standard plug for wiring AI assistants to data sources and tools. One protocol lets a model-backed client find and use what an outside system offers. Its content, its queries, its actions. No matter which vendor built either side.

The shape will be at once familiar to anyone who remembers what REST’s conventions did for web hookups or what SQL did for data access. Or, our own touchstone, what RSS did briefly and schema.org did durably for content exchange. The N-times-M connector explosion, collapsed to N-plus-M.

Without a standard, every AI assistant needs a custom hookup to every system. The per-vendor connector sprawl is already piling up in this year’s enterprise AI pilots. Each hookup a one-off. Each pilot’s plumbing throwaway. With one, a system opens itself up once, to any client that speaks it, and the hookup economics change in kind.

We have watched enough protocol announcements die in committee or in obscurity to hold the enthusiasm properly. The caveats section is essential. And enough integration eras have run the same course to show why this one matters anyway. The ending argues that integration standards will decide whether the AI-mediated future now assembling is composable or captive, and that question is squarely our beat. Architecture, caveats, and stakes. In order.

The architecture, translated for decision-makers

The mechanics, at the altitude this audience needs. An MCP server is a small piece of software that exposes a system’s capabilities in the protocol’s vocabulary. Resources: the content and data the system holds. The CMS’s pages and the analytics reports. The database queries, the ticket queue. Tools: the actions it permits (create, update, search, run). And prompts: packaged interactions it supports.

An MCP client (the AI assistant, whoever ships it) connects to any such server, finds what it offers, and uses it. The human’s permissions and the deployment’s policies govern what actually happens.

The consequence for the enterprise-pilot landscape this year’s copilot coverage surveyed. The hookup your team builds to open up the CMS’s content list is built once, to the standard, rather than once per assistant vendor. That turns hookup work from throwaway pilot plumbing into pipes that last. And for clients currently weighing AI platforms, it makes ‘does it speak the standard?’ a portable-investment question. Exactly the kind the composability coverage taught buyers to ask about everything else.

For the platform-watching genre, the early signals are the right ones. The open-source release. The reference servers for common systems. The fast third-party servers in the protocol’s first weeks. The signal that would actually settle the question, adoption by the other major model vendors, is the one the watchlist below names first.

The caveats, in the same paragraph as promised

• One-vendor origin, until others adopt: a standard one company publishes is a proposal until rivals ship it. The open-source license and governance approach are the right opening moves, and the test is stated now. MCP matters in proportion to who else ships it, and we will revisit this against that roster.

• Security and permission models are still growing up: wiring AI systems to institutional data and actions is exactly the surface our governance coverage spent two years fencing. The who-can-run-it, what-gets-logged, where-review-cannot-be-skipped settings from the copilot coverage. The protocol’s authorization story is young. Early rollouts should treat every MCP connection as the privileged hookup it is. Scoped, logged, and reviewed, with the tag-governance lesson (unwatched connectors are debt) applied from day one this time.

• The standards graveyard is full of elegant protocols: for every schema.org there are a dozen forgotten acronyms whose technical merits exceeded their adoption. Timing and sponsor incentives decide these races more than elegance does. So our enthusiasm comes with strings. The shape is right, the need is real, and the race is not run.

The stakes: composable or captive

Why a protocol announcement earns strategy coverage, stated as the thesis it is. Every platform roadmap this year asserts the same future. AI assistants as an interface to institutional systems. The copilots in the CMS, the assistants over the analytics, the agents the keynotes promise. If that future arrives in any form, the hookup layer beneath it becomes critical plumbing for how institutions’ knowledge and powers get reached.

We have learned to ask one question at exactly this moment in every era. The browser wars, the API decade, the composability fight of 2022. Does the connecting layer belong to everyone or to someone?

A world of proprietary per-vendor connectors is the captive outcome. Integration spending that locks to its assistant vendor. Switching costs that compound with every connection. The N-times-M economics quietly doing what they always do: gathering power with whoever owns the biggest N.

A world with a genuine open standard at that layer is the composable outcome. Systems opened up once. Assistants competing on merit above a common floor. And the exit rights we price into everything preserved at the layer where the next decade’s lock-in would otherwise live. MCP is the first credible bid for the composable outcome, which is precisely why it matters regardless of whether this particular protocol wins. The composability fight of 2022, arriving at the AI layer, with the same stakes and the same buyer’s advice. Favor the standard, price the lock-in, and keep the exits surveyed.

What to watch

The watchlist, with its checking criteria named now. Adoption by other vendors: the question. Everything else is commentary. The security model growing up: the permission and audit story reaching enterprise grade. The server ecosystem’s growth in the systems this readership actually runs: the CMS platforms, the analytics tiers, the institutional databases. And the governance patterns: whether MCP deployments arrive fenced or sprawling, the copilot-configuration lesson, applied at the protocol layer.

The advice meanwhile, calibrated. No urgent action for most of this audience, since the protocol is weeks old. A pilot’s attention for the teams already building AI hookups. Building to the standard costs little more than building custom, and it keeps options open either way. And the buying question, ‘do you support MCP, or what is your equivalent open interface?’, goes into every AI-platform talk now. Vendor answers to standards questions are always most honest before the market forces them.

This is a topic we expect to cover for years, on the usual terms. Watched by name, judged against its own criteria, and welcomed exactly as warmly as its adoption earns. The era was missing its integration standard. A credible one just introduced itself, politely, with the source attached. Attention paid.