If agents are the new users, MCP is HTTP.

If you squint at the history of computing, every meaningful shift in who the user is has come paired with a meaningful shift in what the wire protocol looks like. Terminals had ANSI. The web had HTTP. Mobile had REST-shaped JSON. The agentic era has MCP.

What is MCP, and why does it matter more than the UI?

MCP — the Model Context Protocol — is an open standard for exposing tools, data, and prompts to a language model over JSON-RPC. It matters more than the interface because the caller changed. When the thing operating your software is a model rather than a person, the tool catalogue becomes the surface everything else is built on, and the screen becomes one client among several.

That isn't a marketing claim. It's a structural observation. When the caller changes — from a person at a keyboard to a model running in a loop — the surface they interact with changes with them. People scan; agents enumerate. People click; agents call. People tolerate ambiguity; agents need contracts.

Why did MCP win rather than a better protocol?

Because it is adequate and everybody converged on it. MCP is the boring, correct version of agents need an API — not innovative, just sufficient, and adopted widely enough that the industry never had to live through seven incompatible variants. Protocols do not win on elegance. They win when the cost of not speaking one exceeds the cost of the thing itself.

It doesn't try to be glamorous, and the restraint is the point. Every hour the ecosystem did not spend arguing about framing, transport, or capability negotiation is an hour it spent on the layer above.

Who owns MCP?

Nobody, by design. Anthropic published MCP in November 2024 and OpenAI adopted it across its products the following March. In December 2025 Anthropic gave the protocol away, donating it to the Agentic AI Foundation — a directed fund under the Linux Foundation, co-founded with Block and OpenAI. The specification now changes through a public proposal process rather than by its original authors.

The first real test of that arrived on 28 July 2026, when the 2026-07-28 revision shipped under the new governance: the initialize handshake and the Mcp-Session-Id header removed, the protocol made stateless so any request can land on any instance, extensions made first-class, tool schemas lifted to full JSON Schema 2020-12, and — the part that matters most — a formal feature lifecycle guaranteeing at least twelve months between deprecating something and removing it. Breaking changes announced ten weeks ahead, with a conformance suite gating what reaches Final.

That is what durable looks like from the outside. Not a protocol that never changes, but one that tells you how it will.

What's the difference between building MCP-first and adding MCP later?

MCP-first means the tools are the canonical surface and every interface — including your own dashboard — is a client of them. MCP-later means you have a UI with a translation layer bolted alongside it. The second arrangement produces two systems that drift apart, and reconciling them becomes permanent work that nobody scheduled and nobody can stop doing.

The interesting part was never the protocol itself. It's the order of operations it implies, and the order is very hard to change after the fact. The same discipline shows up at the database: decide what the contract is before there are five things depending on you not having decided.

Why is Munin open source if the protocol is already open?

Because an open protocol sitting on a proprietary schema still locks you in. The last decade of SaaS taught us that lock-in lives at the data layer, not the UI layer. If your data is in a proprietary schema in a proprietary cloud, your protocol is irrelevant — they own you. If your data is in an open schema and an open protocol, you can leave.

We think MCP wins when MCP-the-product becomes MCP-the-protocol — when nobody owns it, when implementations interoperate, when the bar for a new agentic application is speak MCP rather than integrate with vendor X. The way to get there is for everyone to ship MCP, not for anyone to own it.

That's why Munin is MIT-licensed. Open code, open protocol. We don't want to be the proprietary winner of the agentic era. We want to be the boringly correct implementation that helped move the industry somewhere a proprietary winner is impossible.

Frequently asked questions

Is MCP an open standard? Yes. MCP has been governed by the Agentic AI Foundation, a directed fund under the Linux Foundation, since December 2025. Anthropic wrote it and no longer controls it. Changes go through a public Specification Enhancement Proposal process, and since the 2026-07-28 revision a proposal cannot reach Final status without a matching scenario in the conformance suite.

What changed in the 2026-07-28 MCP specification? The protocol became stateless: the initialize handshake and the Mcp-Session-Id header were removed, so any request can land on any server instance. Extensions became first-class, with MCP Apps and Tasks shipping as official ones. Tool inputSchema and outputSchema were lifted to full JSON Schema 2020-12. A formal deprecation policy now guarantees at least twelve months before removal.

Do I still need a REST API if I support MCP? Usually yes, and we ship both. Munin exposes 204 MCP tools at one endpoint and 218 REST endpoints over the same data. Agents want a catalogue they can enumerate; web front ends, webhooks, and existing integrations want ordinary HTTP. They are different callers with different needs, not competing standards.

Is MCP only for Claude? No. MCP is client-agnostic, which is the entire point of standardising it. The same Munin endpoint is used from Claude, Claude Code, ChatGPT, Cursor, Codex, Gemini, the OpenAI Agents SDK, and custom runners people wrote themselves. If a client speaks the protocol, it gets the tools.

How do I connect to an MCP server? For a remote server it is a URL and a credential, registered with whatever client you use — one claude mcp add for Claude Code, one entry in mcp.json for Cursor. The server publishes its tools through tools/list; the client decides which of them the model may call and when to ask you first.

Munin's own implementation is 204 tools at a single endpoint, and the quickest way to see what that feels like is running the whole platform from a terminal or reading the tool reference.

Nobody owns HTTP. That is the entire reason it worked.