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.

PartWhat the specification says it doesWhy it matters
HostThe 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.
ClientA 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.
ServerA 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?

FeatureOffered byWhat it is, per the specification
ToolsServerFunctions 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.
ResourcesServerContext and data, for the user or the AI model to use.
PromptsServerTemplated messages and workflows for users.
ElicitationClientServer-initiated requests for additional information from users.
SamplingClientA 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.
RootsClientInformational guidance about directories the client considers relevant. The spec says it is not an access-control mechanism. Deprecated in 2026-07-28.
ExtensionsBothOptional, 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?

TransportHow it worksWhat the specification adds
stdioThe 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 HTTPThe 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 transportsAllowed, 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.

How does authorisation work in MCP?

Authorisation is optional. When a server uses an HTTP transport, the specification says implementations should follow its authorisation section, which builds on OAuth 2.1 (an IETF draft) and related RFCs. The MCP server acts as an OAuth resource server, the client acts as an OAuth client, and a separate authorisation server issues the tokens.

Three rules matter in practice. Servers must publish OAuth 2.0 Protected Resource Metadata so that clients can find the authorisation server. Clients must send a resource parameter naming the server the token is for, and servers must accept only tokens issued for them. Servers must not accept or pass on any other tokens. The specification also says servers should name the scopes an operation needs, and clients should ask for more only when needed.

For client registration the specification says authorisation servers and clients should support Client ID Metadata Documents. Dynamic Client Registration is deprecated in this revision and kept for older authorisation servers.

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. 1. The client asks which tools exist

    {"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {"cursor": "optional-cursor-value"}}

  2. 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. 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. 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. 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.

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.

Use MCP with approvals, limits and a record of what ran

Build this in Studio

Describe what you need in plain language. Studio builds the agents and workflows, and you keep every version.