The Model Context Protocol: USB-C for AI Tooling

Every integration you hand-wire between a model and a tool is a bespoke adapter — and bespoke adapters rot. Three models times four tools is twelve custom integrations to build, version, and maintain. The Model Context Protocol is the USB-C of AI tooling: one standard so any model can discover and call any tool, resource, or prompt without the N×M glue.

It standardises how capability is exposed

MCP defines a small, consistent contract for three things a model needs from the outside world: tools it can call, resources it can read, and prompts it can reuse. A tool provider implements the protocol once as a server; any MCP-aware client can then discover and use it. The integration stops being "wire this model to this API" and becomes "speak the protocol."

It separates capability from reasoning

The deeper win is the boundary. An MCP server owns a capability — querying a database, hitting an internal API — and knows nothing about which model will use it or how it reasons. The client owns the reasoning and knows nothing about how the capability is implemented. That clean separation is what lets the two sides evolve independently: swap the model without touching the tools, add a tool without retraining anything.

// expose a capability once; any MCP client can discover it
server.tool("search_docs", {
  description: "Semantic search over the product docs",
  inputSchema: { query: z.string(), topK: z.number().default(6) },
}, async ({ query, topK }) => {
  const hits = await store.search({ vector: await embed(query), topK });
  return { content: hits.map(h => ({ type: "text", text: h.chunk })) };
});

N×M becomes N+M

The combinatorial math is the whole point. Without a protocol, every new model has to be wired to every existing tool, and every new tool to every existing model — the integration surface grows as the product. With MCP, a new model is one client and a new tool is one server: the surface grows as the sum. That's the difference between an integration layer that compounds in cost and one that scales linearly.

MCP doesn't make your model smarter. It makes your integrations composable — turning a rotting mesh of bespoke adapters into a protocol any side can plug into.

MCP servers are how the control loop gets its hands without bespoke wiring — and a disciplined protocol pairs naturally with disciplined payload design. Continue on the roadmap.