Protocol explainer
What is MCP? The Model Context Protocol explained
A plain explanation of what MCP is, who stewards it, how it works and what it does not do, checked against the specification on 2026-10-07.
The Model Context Protocol (MCP) is an open standard for connecting AI applications to external tools and data. It sends JSON-RPC 2.0 messages between a host application and servers that expose tools, resources and prompts. Anthropic introduced it, and in December 2025 announced a donation of the project to the Linux Foundation's Agentic AI Foundation. This page follows the current specification revision, 2026-07-28.
Last verified 2026-10-07. Sources are listed at the end of the page.
What is MCP, who created it and who looks after it now?
The MCP site describes MCP as an open-source standard for connecting AI applications to external systems. It compares MCP to a USB-C port: one standard connector instead of a custom cable for every device. An AI application, such as an assistant or an editor plug-in, speaks MCP to a server. The server gives it access to a data source, a tool or a prepared prompt.
The specification says the protocol uses JSON-RPC 2.0 messages. It takes some inspiration from the Language Server Protocol, which did a similar job for programming-language support in editors. MCP defines what the messages look like. It does not decide which tools are safe, which model to call or what an agent should do next.
The specification's versioning page names 2026-07-28 as the current revision. MCP versions are date strings that record the last backwards-incompatible change. This revision changed the shape of the protocol: every request is self-contained and carries its own protocol version and capabilities, and there are no protocol-level sessions. The older handshake-based revisions (2025-11-25 and earlier) are covered by a compatibility section, so many tutorials you find still describe the older shape.
Anthropic introduced MCP. The Linux Foundation's announcement of the Agentic AI Foundation quotes the open-source release as November 2024. On 9 December 2025 Anthropic announced that it was donating MCP to the Linux Foundation's new Agentic AI Foundation, where it sits beside Block's goose and OpenAI's AGENTS.md as founding projects. Anthropic's post says the maintainers will keep prioritising community input and transparent decision-making.
The MCP site describes the day-to-day governance. The project is established as a series of LF Projects, LLC. Contributors, maintainers, core maintainers and lead maintainers form a hierarchy, and membership belongs to individuals, not companies. Changes to the specification go through public Specification Enhancement Proposals. Contributions to code and specification use the Apache License 2.0, and documentation uses CC BY 4.0.
How does MCP work: hosts, clients and servers?
The specification names three parts. A host can run several clients, and each client talks to exactly one server.
| Part | What the specification says it does | Why it matters |
|---|---|---|
| Host | The LLM application that initiates connections. It creates and manages client instances, enforces security policies and consent requirements, and coordinates the AI model. | Consent and policy live in the host. The protocol does not enforce them for you. |
| Client | A connector inside the host. It communicates with exactly one server and attaches the protocol version and its capabilities to every request. | One client per server keeps servers apart. |
| Server | A service that provides context and capabilities: resources, tools and prompts. It can be a local process or a remote service. | A stated design principle is that a server should not be able to read the whole conversation or see into other servers. |
Servers advertise their capabilities in response to server/discover, which a client may call before any other request. Calling it is optional.
What can an MCP server offer, and what can a client offer?
| Feature | Offered by | What it is, per the specification |
|---|---|---|
| Tools | Server | Functions for the AI model to execute. They are model-controlled: the model can discover and call them. Each has a name, a description and a JSON Schema for its input. |
| Resources | Server | Context and data, for the user or the AI model to use. |
| Prompts | Server | Templated messages and workflows for users. |
| Elicitation | Client | Server-initiated requests for additional information from users. |
| Sampling | Client | A way for a server to request a model completion through the client. Deprecated in 2026-07-28; the stated migration path is to integrate directly with LLM provider APIs. |
| Roots | Client | Informational guidance about directories the client considers relevant. The spec says it is not an access-control mechanism. Deprecated in 2026-07-28. |
| Extensions | Both | Optional, opt-in features negotiated between client and server. The overview names Tasks, Skills over MCP and MCP Apps. |
A deprecated feature stays in the specification for at least twelve months. The earliest removal is the first revision released on or after 2027-07-28.
Which transports does MCP use?
| Transport | How it works | What the specification adds |
|---|---|---|
| stdio | The client launches the server as a subprocess. Newline-delimited JSON-RPC messages travel over the standard input and output streams. | The server may log to stderr. For authorisation, stdio implementations should not follow the HTTP authorisation section and should take credentials from the environment instead. |
| Streamable HTTP | The server exposes one HTTP endpoint that accepts POST. Each message is its own POST, and the reply is a JSON object or a server-sent events stream for that request. | Servers must validate the Origin header to stop DNS rebinding and should bind to localhost when running locally. They should authenticate all connections. Revision 2026-07-28 removed the GET stream and sessions. |
| Custom transports | Allowed, if they keep the JSON-RPC message format, the message patterns and the per-request metadata. | The older HTTP+SSE transport is deprecated in favour of Streamable HTTP. |
What do MCP messages look like? A worked example
These shapes are copied from the specification's tools page for revision 2026-07-28 and trimmed. That page omits the _meta block for brevity but says every request must include it. The _meta block in step 3 is copied from the transport page.
1. The client asks which tools exist
{"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {"cursor": "optional-cursor-value"}}
2. The server lists its tools
{"jsonrpc": "2.0", "id": 1, "result": {"resultType": "complete", "tools": [{"name": "get_weather", "title": "Weather Information Provider", "description": "Get current weather information for a location", "inputSchema": {"type": "object", "properties": {"location": {"type": "string", "description": "City name or zip code"}}, "required": ["location"]}}]}}
3. The client calls one tool
{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "get_weather", "arguments": {"location": "New York"}, "_meta": {"io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientInfo": {"name": "ExampleClient", "version": "1.0.0"}, "io.modelcontextprotocol/clientCapabilities": {}}}}
4. The server returns the result
{"jsonrpc": "2.0", "id": 2, "result": {"resultType": "complete", "content": [{"type": "text", "text": "Current weather in New York:\nTemperature: 72°F\nConditions: Partly cloudy"}], "isError": false}}
5. A tool can fail without breaking the protocol
A tool execution error comes back as a normal result with isError set to true and text the model can use to correct itself. A protocol error, such as an unknown tool, uses a JSON-RPC error with code -32602. The specification suggests clients pass tool execution errors to the model.
What MCP is not
- Not a security boundary. The specification says MCP cannot enforce its security principles at the protocol level, and it tells implementors to build consent flows and access controls themselves. A tool server is code that runs with real privileges.
- Not an agent framework. The specification defines messages between hosts, clients and servers. It has no section on planning, memory or orchestrating several agents. The host application and its framework do that.
- Not a replacement for APIs. Many servers call an API underneath. See MCP vs API for the layering.
- Not agent-to-agent communication. MCP connects an agent to its tools. The A2A project describes itself as the layer for agents talking to each other: see What is the A2A protocol.
- Not a vetting scheme. The official registry says consumers should assume minimal-to-no moderation. See MCP servers for how to check a server yourself.
Security basics before you connect a server
- Treat tool descriptions and annotations as untrusted unless the server is trusted. The specification says so, and descriptions reach the model, which makes them a route for prompt injection. The checklist is in MCP security best practices.
- Keep a human able to deny tool calls. The specification says there should always be a human in the loop with the ability to deny tool invocations, and that hosts must obtain explicit consent before invoking any tool.
- Run local servers with least privilege. A local server runs with the same privileges as the client. The specification recommends showing the exact command before a one-click install and using a sandbox.
- Never let a server accept tokens issued for another service. The specification forbids token passthrough.
- Log tool use. The specification says clients should log tool usage for audit, and that servers must validate inputs, apply access controls, rate limit calls and sanitise outputs.
- Go deeper in MCP and tool security for the control model, and How to secure MCP servers for the hardening steps.
Where Swfte fits, and when you do not need it
Swfte Cortex, the desktop app, runs MCP servers and tools in-process and can use external MCP servers. In-app tool approvals are bound to the exact call, and approvals are recorded in a hash-chained log (Built). Swfte Connect, the model gateway, resolves a workspace's MCP tools in the gateway when a request uses tool calling (Built).
You do not need Swfte to use MCP. The protocol is open, the SDKs are free, and any MCP client works with any MCP server. If you run one or two servers you have reviewed in your own editor, the client's approval prompts and the steps in How to secure MCP servers may be all you need. A gateway or policy layer starts to pay for itself when many people and many servers are involved.
Sources and last verified
Every dated or technical fact on this page was read from the pages below on 2026-10-07. Anything that could not be confirmed is left out or marked as not verified.
- MCP specification overview (latest). Base protocol, features, key security principles.
- MCP specification versioning. Current revision 2026-07-28 and the version negotiation rules.
- MCP architecture. Host, client and server roles; design principles; capability negotiation.
- MCP tools. tools/list and tools/call message shapes, error handling, security considerations.
- MCP transports. Standard and custom transports.
- MCP Streamable HTTP transport. Endpoint, Origin validation, localhost binding, request headers, _meta example.
- MCP stdio transport. Subprocess launch and framing.
- MCP authorization. OAuth-based flow, resource indicators, token rules, client registration.
- MCP deprecated features. Roots, sampling, logging, Dynamic Client Registration and HTTP+SSE status.
- MCP governance and stewardship. LF Projects, LLC, maintainer roles, licences.
- What is MCP (official introduction). The project's own definition and USB-C comparison.
- MCP security best practices. Local server compromise, token passthrough, scope minimisation.
- Anthropic: donating MCP to the Agentic AI Foundation. Creator, donation date and governance statement.
- Linux Foundation: formation of the Agentic AI Foundation. Founding projects and the November 2024 open-source date.
Frequently asked questions
What does MCP stand for?
MCP stands for Model Context Protocol. It is an open standard for connecting AI applications to external systems such as data sources, tools and prepared prompts. The specification defines the messages between a host application, its clients and the servers, using JSON-RPC 2.0, so one server can work with many AI applications.
Who owns the Model Context Protocol?
Anthropic created MCP, and in December 2025 it announced a donation of the project to the Linux Foundation's Agentic AI Foundation. The MCP site describes governance by maintainers who join as individuals, not companies, with specification changes made through public proposals. Contributions to code and specification use the Apache License 2.0.
What is the current MCP specification version?
The specification site names 2026-07-28 as the current revision as of 2026-10-07. MCP versions are date strings that record the last backwards-incompatible change. This revision removed protocol-level sessions, so tutorials that describe an initialize handshake describe earlier revisions, which the specification covers in a backward compatibility section.
Does MCP include authentication?
Authorisation is optional in MCP. For HTTP transports the specification says to follow its OAuth-based flow, where the server acts as a resource server and publishes protected resource metadata. For stdio servers it says to take credentials from the environment. The protocol does not decide who may call which tool, so the host or a gateway has to add that policy.
Is MCP secure by default?
No. The specification says MCP cannot enforce its security principles at the protocol level and that tools represent arbitrary code execution. Safety comes from the host asking for consent, servers validating input and applying access control, least-privilege deployment, and your own review of every server. The official registry also says to assume minimal moderation.
Which transports does MCP support?
The specification defines two standard transports. With stdio the client launches the server as a subprocess and exchanges newline-delimited messages. With Streamable HTTP each message is an HTTP POST to a single endpoint. Custom transports are allowed if they keep the JSON-RPC format. The older HTTP+SSE transport is deprecated.