Skip to content
The Model Context Protocol, the Open Standard for Plugging Tools Into AI Assistants, Removed Its Handshake and Sessions in the 2026-07-28 Revision So Any Request Can Reach Any Server Behind a Plain Load Balancer
AI & Technology

The Model Context Protocol, the Open Standard for Plugging Tools Into AI Assistants, Removed Its Handshake and Sessions in the 2026-07-28 Revision So Any Request Can Reach Any Server Behind a Plain Load Balancer

Illustration by tuput

English

The Model Context Protocol, or MCP, lets an AI application call outside tools and read outside data through one open standard. Its 2026-07-28 revision, published on 28 July 2026, has every request carry its own version and capabilities instead of opening with a handshake.

· · 10 min read

The Model Context Protocol (MCP) is an open standard that lets an AI application call outside tools and read outside data without a custom connector for each one. Its 2026-07-28 revision, published on 28 July 2026, removed the opening handshake and the connection session from the protocol. Every request now carries its own protocol version and capabilities, and the maintainers’ release post says: “Any request can now land on any server instance behind a plain round-robin load balancer without needing shared storage.”

This article describes what the specification text and the maintainers’ posts say, as read on 19 November 2026. The adoption figures quoted are the makers’ own statements. None was counted independently.

What the protocol is, in the specification’s words

The specification describes MCP as an open protocol connecting applications built on large language models with outside data sources and tools. Messages use JSON-RPC 2.0, a plain format in which a program sends a named request, such as tools/call, and gets back a reply that carries the same ID. Three roles take part. A host is the AI application that starts the connection, a client is a connector inside that host, and a server is the service that supplies the context and capabilities.

The specification says MCP takes inspiration from the Language Server Protocol, the standard that lets one code editor support many programming languages. Servers can offer three things: tools, which are functions the model can run, resources, which are data, and prompts, which are templated messages for users. Clients can offer one in return, called elicitation, which lets a server ask the user for more information.

The model behind a chatbot produces text one token at a time, as tuput’s piece on how a chatbot guesses the next word explains. A tool is how a host turns some of that text into an action, such as a database query. How well assistants that use tools perform in independent tests is covered in tuput’s piece on AI agents in production.

From one company’s project to a foundation

Anthropic open-sourced MCP on 25 November 2024. Its announcement says the protocol was created at Anthropic by David Soria Parra and Justin Spahr-Summers, and that it shipped with a specification, software development kits (SDKs), local server support in the Claude Desktop apps and an open-source set of servers for Google Drive, Slack, GitHub, Git, Postgres and Puppeteer. Anthropic named Block and Apollo as early adopters, and the coding-tool makers Zed, Replit, Codeium and Sourcegraph as working with it.

On 9 December 2025 the Linux Foundation announced the Agentic AI Foundation, with MCP, Block’s goose agent framework and OpenAI’s AGENTS.md as its founding projects. Its platinum members are Amazon Web Services, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft and OpenAI. The same release says more than 10,000 MCP servers had been published and that the protocol had been adopted by Claude, Cursor, Microsoft Copilot, Gemini, VS Code and ChatGPT.

The maintainers’ 28 July 2026 post adds that the four Tier 1 SDKs (TypeScript, Python, Go and C#) see close to half a billion downloads a month, and that the TypeScript and Python SDKs have each passed 1 billion in total. These are the project’s own numbers.

What a tool looks like on the wire

A tool has a name, a description and an input schema, which is a JSON Schema, a standard way of spelling out which fields an input may contain and of what type. The specification advises names of 1 to 128 characters, made of letters, digits, hyphens, dots and the _ character. It notes that two servers can each offer a tool called search, and tells programs that combine several servers to prefix names so the two stay apart.

The flow is short. A client sends tools/list and receives the catalogue. To use one, it sends tools/call with the tool’s name and arguments, and the server returns content plus an isError flag. The specification says failures such as a date in the wrong format should come back as ordinary results with that flag set, so the model can read the message and try again.

The specification calls tools model-controlled, meaning the model can find and invoke them on its own judgment. It then adds a safeguard: “there SHOULD always be a human in the loop with the ability to deny tool invocations.” It tells clients to treat tool annotations, the hints a server gives about what a tool does, as untrusted unless the server is trusted. It also says MCP cannot enforce its consent rules at the protocol level, so the duty falls on whoever builds the host.

The handshake that went away

Under the 2025-11-25 revision a connection began with an initialize request carrying the client’s protocol version, capabilities and identity. The server answered with its own, and the client then sent an initialized notification. Over HTTP the server could also hand out an Mcp-Session-Id header, which tied later requests to one connection.

The Transport Working Group explained the cost on 19 December 2025. Stateful connections forced sticky routing, which pins a client’s traffic to one particular server and prevents effective auto-scaling. Load balancers and gateways had to open the full JSON-RPC message to route it, and simple tools needed backing storage just to hold a multi-step exchange. The group said the next revision was tentatively slated for June 2026. It was published on 28 July 2026.

The key changes page lists nine major changes. The first two remove sessions and the handshake. In their place, every request carries io.modelcontextprotocol/protocolVersion and io.modelcontextprotocol/clientCapabilities in a field called _meta. Over HTTP the version also travels in an MCP-Protocol-Version header, which must match the body or the server answers with a 400 error. A server that does not support the requested version returns UnsupportedProtocolVersionError, listing the versions it does support. The client picks one and retries. The versioning page’s example lists 2026-07-28 and 2025-11-25.

Clients that want to know a server’s versions and capabilities in advance can call a new server/discover method, which every server must implement. Calling it is optional.

Two new headers go further. Streamable HTTP requests must now carry Mcp-Method, and requests such as tools/call also carry Mcp-Name, so that a gateway or firewall can route and meter on headers without reading the body. A server must reject a request whose headers disagree with its body.

Keeping state without a session

Dropping the session does not stop an application from remembering things. The specification’s non-normative guidance for stateful tools says a server should return an explicit handle from a creation tool and accept it as an argument afterwards. Its example is a shopping cart: a create_basket tool returns an ID, and the model passes that ID to add_item. The maintainers say they found this works better than state hidden in the transport, because the model can see the handle. The guidance adds that a handle is a name and not a permission, so an authenticated server should check the caller’s authorization on every call.

Asking a question without a held-open connection

Before this revision a server in the middle of a call could send the client its own request, for example to ask the user to confirm something. That needed a connection held open in both directions. The new pattern, called Multi Round-Trip Requests, works in four steps. The server answers a request with a result marked input_required, listing what it needs. The client collects the answers and sends the original request again with them attached, under a new request ID. The server then finishes the work.

If the server needs to carry context between the two rounds, it puts it in an opaque requestState string that the client must send back unread. The specification says this avoids shared storage across server instances and stateful load balancing, and allows the pattern only on tools/call, prompts/get and resources/read. The release post quotes Inian Parameshwaran, head of product, saying that because Supabase MCP runs statelessly, elicitation had not been easy to support and the pattern changes that.

The rest of the nine changes

Major change in 2026-07-28What the key changes page says
Sessions removedNo Mcp-Session-Id, and list endpoints no longer vary per connection
Handshake removedVersion and capabilities travel in each request
server/discoverServers must implement it, clients may call it first
subscriptions/listenOne opt-in stream for change notices replaces the HTTP GET endpoint
Methods removedping, logging/setLevel and a roots change notice go, and log level is set per request
Tasks moved outLong-running tasks become an official extension, polled with tasks/get
Multi round-trip requestsReplace server-initiated requests
resultType fieldEvery result says “complete” or “input_required”
Stream resumability removedA broken stream loses the request, so the client re-issues it

Smaller changes include cache hints. List results now carry ttlMs, how many milliseconds a client may treat the answer as fresh, and cacheScope, which says whether shared intermediaries may keep a copy. Servers should also return tools in a steady order, which the specification says helps client caching and prompt-cache hit rates.

Two transports and an optional sign-in

The specification defines two standard transports. With stdio the client launches the server as a subprocess and they exchange one JSON-RPC message per line through standard input and output, with logs going to standard error. With Streamable HTTP every message is an HTTP POST to a single endpoint, and the reply is either one JSON object or a stream scoped to that request using Server-Sent Events, a way for a server to send several messages down one reply. Servers must check the Origin header to block DNS rebinding attacks, and local servers should bind only to localhost.

Authorization is optional. For HTTP the specification says implementations should follow it, and for stdio they should not, taking credentials from the environment instead. It builds on OAuth 2.1, which the specification cites as an IETF draft. A protected MCP server acts as an OAuth resource server, and must publish protected-resource metadata under RFC 9728 so a client can find the right authorization server. The revision adds RFC 9207 issuer checks, deprecates Dynamic Client Registration in favour of Client ID Metadata Documents, and ties stored client credentials to the issuer that granted them. The maintainers write that authorization is where implementers spend most of their integration time.

Compatibility, deprecations and the next date

On 29 June 2026 the maintainers wrote that nothing breaks for existing clients and servers on 28 July, which is when the normative text was published and not a switch-off. The versioning page sets out the combinations. A client that speaks only the new revision cannot use an older server, and an older client cannot use a server that supports only the new one. A client or server that supports both eras works with either, and a dual-era server can serve both on one endpoint. The maintainers say all four Tier 1 SDKs support 2026-07-28 and the Rust SDK has it in beta. They add that Python and TypeScript moved to new major versions, with a migration cost for code that relied on session identifiers.

Roots, Sampling, Logging and Dynamic Client Registration are deprecated in this revision, and the HTTP+SSE transport is also listed as deprecated. A new policy sets a minimum twelve-month window, and the registry gives those four an earliest removal at the first revision released on or after 28 July 2027. The release post also carries statements from vendors including Amazon Web Services, Cloudflare, Google Cloud and Microsoft. They are the vendors’ own words on the maintainers’ page, and no vendor’s own documentation was opened for this piece.

On 11 November 2026 the maintainers said specification releases will move to a six-month schedule, generally on the last Tuesday of March and September. The next release is targeted for 30 March 2027, as version 2027-03-30.

Share
Copied!

Sources & further reading

  1. Model Context Protocol specification, overview (version 2026-07-28, latest)
  2. Model Context Protocol specification: Key Changes since 2025-11-25
  3. Model Context Protocol specification: Transports
  4. Model Context Protocol specification: Streamable HTTP
  5. Model Context Protocol specification: Versioning and Compatibility
  6. Model Context Protocol specification: Tools
  7. Model Context Protocol specification: Multi Round-Trip Requests
  8. Model Context Protocol specification: Discovery
  9. Model Context Protocol specification: Authorization
  10. Model Context Protocol specification: Deprecated Features
  11. Model Context Protocol specification 2025-11-25: Lifecycle
  12. MCP maintainers: The 2026-07-28 Specification (28 July 2026)
  13. MCP Transport Working Group: Exploring the Future of MCP Transports (19 December 2025)
  14. MCP maintainers: Beta SDKs for the 2026-07-28 MCP Spec Release Candidate (29 June 2026)
  15. MCP maintainers: A More Predictable Release Cycle for MCP (11 November 2026)
  16. Anthropic: Introducing the Model Context Protocol (25 November 2024)
  17. Linux Foundation: Formation of the Agentic AI Foundation (9 December 2025)

Researched and written with the help of AI tools and edited for accuracy. Provided for general information and discussion only, not professional advice. See our editorial standards and disclaimer. Spotted an error? Tell us.

#model context protocol#mcp#ai agents#agentic ai foundation#json-rpc#oauth#ai standards#stateless protocol

Enjoyed this? Get the next one.

One good read at a time, straight to your inbox. No spam, unsubscribe anytime.

More in AI & Technology
DeepSeek's V4.1-Flash, an Open-Weight 552-Billion-Parameter Model Released on 10 September 2026, Cuts Its Per-Token Memory Cache to 890 Bytes, About a Quarter of Its Predecessor's
A model's short-term memory of a long conversation is expensive to keep. DeepSeek's September release compresses it by design, and its own report says where the model still trails. Here is the mechanism, the timeline from 2024, and what outsiders have checked.
METR's Time Horizon Rated GPT-4 at 4 Minutes and Claude Mythos Preview at 17.4 Hours of Human Work, and the Nonprofit Itself Says Readings Above 16 Hours Are Unreliable
The stopwatch in this yardstick runs on the humans, not on the AI. Here is how it is built, what it has read since 2023, how the same model's number has moved, and where its makers say it stops working.
Scale's SWE-Bench Pro Board Puts the Best Coding Agent at 61.5%, Maintainers Reject Many Fixes That Pass the Tests, and METR Says Its Latest Trial Cannot Show How Much Time Agents Save
Benchmarks say agents are strong. Maintainers, a randomised trial and a pile of incident reports say the picture is narrower. Here is what each number actually measures.
← all articles