What Is the Model Context Protocol?

📘 What the specification fixes, and what it leaves open

The Model Context Protocol is an open specification for connecting an agent application to capabilities that live outside it. It is a message protocol rather than a library or a service: messages are JSON-RPC 2.0 requests, responses and notifications, and anything that emits and answers them correctly is a participant, whatever it happens to be written in.

What the specification fixes is short. Three roles — a host application, a client holding one connection, a server exposing capabilities. An initialization exchange in which both sides agree a protocol version and declare which features they support. The kinds of thing a server may publish — operations to invoke, content to read, message templates to fill in — and the requests for listing and using each. And notifications, so a side whose list has changed can say so instead of being polled.

What it leaves open is larger than what it fixes. It does not say what a server should expose, how coarse or fine an operation should be, which language or runtime to use, how a host should decide what to offer during an exchange, or what an operator’s authorization policy should be. It standardises the connection precisely so that those stop being connection decisions.

The reason to standardise that much and no more is arithmetic. Every agent application that wants to reach a system, and every system that wants to be reachable, would otherwise negotiate a bespoke integration each; one shared connection shape turns that product into a sum. Nothing about an individual integration becomes easier — the same decisions about scope, description and access still have to be made — but they are made once per system instead of once per pairing.

🧩 Two properties a diagram of it usually leaves out

Messages travel in both directions, and that is the property most often lost when the arrangement is drawn. A server does not only answer; it may ask. It can request something from the client side that only that side has: a completion produced by whatever the host is talking to, the boundaries within which it should confine itself, or an answer from the person sitting in front of the application. Which of those are available is settled in the same opening exchange, which is why a client declares capabilities of its own rather than only consuming a server’s.

Version agreement is the mechanism that lets the document be revised without breaking what is already deployed. Both sides state which revision they intend to speak, one is agreed, and everything afterwards is bounded by that agreement together with the feature declarations accompanying it. A request for something the other side never declared is not expected to work, and the expectation is that a participant refuses cleanly rather than guessing at it.

📐 The name invites one particular misreading

The name is worth being exact about, because it invites a misreading. The specification governs an exchange between applications, and no language model participates in that exchange. A model sits on the far side of the host, reading whatever the host chose to place in front of it. Nothing in the document describes model behaviour, and conforming to it settles nothing about how well anything works.

⚙️ How the Registry classifies reading the specification

Reading a specification and extracting what a new integration must implement is retrieval and compression over an existing document, which the information retrieval class covers. On the order form's task class field, select Information retrieval, which covers search, information gathering, research, summarisation. That class has its own page at /tasks/retrieval.

The Registry files this topic under one canonical task, fixed in advance and published here rather than generated per visit:

Read the Model Context Protocol specification and summarise the message types a new integration must implement.

That string, hashed once, is 15144e9e76b7410f… — the first sixteen of sixty-four hex characters. An assessment ordered against a task of this kind is computed from the class, the wording submitted, and the permanent chart the Registry derives for the model configuration named on the order: its ascendant, its ruling planet, and the composite harmony that constrains the range of verdicts available to it. The whole derivation is published at /method.

The risk in specification work is the silent omission: a message type or a handshake field skipped in the reading, surfacing weeks later as a connection that fails for a reason nobody wrote down. 4 risk factors are tracked for information retrieval tasks generally; an assessment reports 3 of them, selected by the submitted task's own seed rather than chosen. Their names, severities and descriptions are certificate content and are not published on a free page.

Get Assessment

📏 What this page does not claim

The Registry makes no representation that an assessment predicts the outcome of any task, and no assessment is validated against real-world results.

This page defines a term and states a classification. It publishes no verdict: the Registry does not test implementations, does not measure how often anything works, and has never run the canonical task above against any model. Which revision of the specification an integration targets, and which optional features it chooses to declare, are decisions the canonical brief does not make.

What is sold is a permanent, numbered assessment for one submitted task at one model configuration — a verdict on a seven-point scale, a recommended execution window, and, above the first tier, the risk factors the class tracks. EUR 1.90 Standard, EUR 4.90 Extended, and EUR 14.90 Full Chart, which adds the permanent chart for the configuration itself. Assessments from EUR 1.90; machine-readable at /pricing.json.

🔗 Related surfaces

← All MCP topics · The AFR-1 method · Information retrieval task class

Related topics: Transports · Tools · MCP compared with an API

❓ Questions about the Model Context Protocol

What is the Model Context Protocol?

An open specification for connecting an agent application to capabilities outside itself. It defines three roles — host, client and server — an initialization exchange in which each side declares what it supports, and a small set of things a server may publish: operations to invoke, content to read, and message templates to fill in.

Is MCP a library or a specification?

A specification. Implementations exist in several languages and are convenient, but the protocol itself is the message contract: JSON-RPC 2.0 requests, responses and notifications, an initialization exchange, and a defined set of requests for listing and using what a server publishes.

How is the protocol version decided?

In the opening exchange. Each side states the revision it intends to speak, one is agreed, and the feature declarations that accompany it bound everything afterwards. A request for a feature the other side never declared is not expected to work.

Can a server send requests to a client?

Yes. The conversation runs in both directions. A server may ask the client side for something only it has — a completion from whatever the host is talking to, the boundaries it should stay inside, or an answer from the person using the application — and what is available was settled when the connection opened.

Does the specification decide which operation gets called?

No. It defines how an operation is described, listed and invoked. The decision to invoke one belongs to the host application and to whatever it consults in order to make that decision.