Home / Articles

MCP Under the Hood: JSON-RPC, Session Quirks and the Missing Auth Layer

A skeptical engineer's look at MCP: it is JSON-RPC 2.0 with stateful sessions, no built-in authorization, and real value in agreement and careful versioning.

Publisher: REACTAPP.TOP6 min read1337 words

This article is published in English.

Sources: MCP Is Just RPC With Better Marketing: A Backend Engineer Reads the Spec

Backend engineering periodically receives a shiny new buzzword with a promise to transform everything. Microservices had their turn, then serverless. The current one is MCP, short for Model Context Protocol, sold with the slogan "USB-C for AI": one universal socket where any model connects to any tool. Veterans of distributed systems can be forgiven some fatigue here, since they've sat through plenty of explanations of RPC from people who never ran one in production.

Reading past the slogan

Open the actual specification and the substance is JSON-RPC 2.0, a protocol old enough to have powered Bitcoin nodes and countless internal tools. A reflexive eye-roll at the marketing is understandable, but it only tells half the story. The truth sits in the space between dismissing MCP and swallowing the pitch whole.

Stripped of agent vocabulary, it's a client-server design. A host application opens one or several client sessions, and each session connects to its own server across a JSON-RPC 2.0 channel. Servers advertise three categories: tools that a model may invoke, resources that it may read and prompts that can be reused. Clients find out what exists, settle on a protocol version and then issue requests just as RPC clients always have: a method, some parameters, a correlation id, and eventually an answer.

Developers who've built JSON-RPC services won't be startled by any of this. Messages use the JSON-RPC format, and they travel either through a local subprocess on stdio or through Streamable HTTP when the server is remote. Calling that revolutionary only works in the sense that a shipping container was revolutionary. The box itself wasn't new. What changed is that a whole industry stopped debating box designs and settled on one.

Settling is the real achievement, and it's the portion of the hype that earns respect without any irony. Previously every AI application hand-built a connector for each tool, and every tool vendor hand-built one for each application. ODBC cured that same tax for databases, and POSIX did so for operating systems, so curing it again has value. But fixing a coordination problem is a different kind of win from fixing a technical one, and promotional copy blurs the two on purpose, because "everyone agreed on a format" sells far worse than "the future has arrived".

Sessions that talk both ways

One point breaks a pure RPC picture, and it's a substantial one. Traditional RPC ends each exchange once the server replies. MCP doesn't. While a session is running, the server itself may send requests toward the client, for example to have the client perform a sampling call on the model, or to get a person to approve an action before things go on. The connection stays open and keeps state across the session's lifetime, so clients have to be written to accept requests they didn't start, not merely wait for answers.

This resembles a persistent socket on which either side may speak first, which differs from the fire-and-forget request-response habit of most web developers. Anyone who handles MCP like a REST client will read this behavior as a defect, though it's really the single deliberate design decision in the spec that deserves to be called interesting.

Authorization left to others

This is the part the industry would rather not hear. The core MCP protocol specifies no authentication and no authorization. Zero. Both are pushed to the transport and the application, and for HTTP servers OAuth 2.1 is becoming the habit, mostly because someone needed to pick a default.

As a division of responsibilities that's arguable. As a practical matter it repeats the familiar flaw of extensible protocols: whatever isn't decided gets decided differently by every implementer, and the average result is weaker than what a firm requirement would have produced. A local stdio server borrows the trust boundary of its host process, which works until that same design gets lifted into a remote deployment without anyone asking what trust means after the process boundary is gone.

It's striking that so many teams hurry to hook autonomous agents up to production databases and internal systems over a protocol whose authors treated authorization as someone else's problem. The spec deserves credit for being honest about that. The criticism lands on everyone further down the chain who acts as if the hole doesn't exist.

A slogan, not a description

"USB-C for AI" is branding, and it speaks to two audiences quite different from what one might guess. First are engineers who recall integration hell and will tolerate nearly anything that promises relief. Second are executives needing a metaphor short enough to say in a board meeting. Neither group is lied to outright, yet neither hears everything.

How good a universal connector standard is depends on who steers it. At present that's the repository of a single company, run under that company's own process, and competitors adopted it largely because refusing would have looked worse. No plot is involved. It's standard platform behavior expressed in the language of open standards, and acting as though it were otherwise is the most grating feature of the debate.

Careful change management

Fairness matters here, and this isn't a hit piece. The most impressive feature is how the spec manages change. MCP revisions carry a date string, and the two sides negotiate it when a session starts, so both know exactly which version of the contract applies before anything else happens. Plenty of internal APIs lack even that, and the answer to "what version is this?" ends up buried in commit history.

Newer revisions formalize a lifecycle for features, which move from active to deprecated to removed, with at least a year between deprecation and the first possible removal. An extensions framework lets new capabilities be released, proven and stabilized outside the core before they can join it. One release candidate replaced a custom error code with the standard JSON-RPC invalid-params code and flagged it openly as a breaking change instead of tucking it into a changelog no one reads.

Such behavior comes from a team that expects outsiders to maintain the protocol for years and has felt the pain of a breaking change itself. It's the strongest technical reason to take MCP seriously, and it has no connection to agents or intelligence. It's plain, careful API stewardship, a far less thrilling phrase than the protocol's boosters would pick.

The verdict

On the wire, it's RPC. Remove the branding and what's left is JSON-RPC 2.0 with two-way sessions, a discovery layer and authorization deliberately unspecified. None of those parts merits a new acronym on its own, and the people giving the keynotes likely agree, though they have something to sell.

The acronym earns its place because competing vendors really did converge on one approach. Convergence is rare, valuable and underappreciated. Most framework wars in backend work are coordination problems in disguise, and they end through consensus rather than smarter engineering. REST didn't defeat SOAP through technical brilliance. It won because enough developers grew weary of wire-format fights and returned to building products.

Should MCP last, JSON-RPC won't have been quietly brilliant all along. More likely, enough engineers got tired of writing the same connector three times and picked this version to defend, flaws included. A good question to end on: which protocol did you last watch everyone quietly accept, with nobody marking the moment?