Do Son 
The Model Context Protocol (MCP), spearheaded by Anthropic, recently launched its highly anticipated 2026-07-28 specification. The defining transformation of this update is the complete migration of MCP. It has transitioned from a bidirectional, stateful protocol into a streamlined, stateless, request-response architecture. Furthermore, this iteration introduces multi-round requests, HTTP header routing, list caching, a robust extension framework, and critical OAuth security enhancements.
It is imperative to note that this release introduces substantial breaking changes. Fortunately, SDKs for TypeScript, Python, Go, and C# already support the new specifications, while the Rust SDK currently offers beta support. However, developers must consult the official migration documentation to successfully adapt existing MCP clients and servers.
Eliminating Initialization Handshakes and Session IDs
Historically, the MCP protocol mandated a rigorous initialize and initialized handshake. Subsequently, it relied on an Mcp-Session-Id to maintain connection state. The revised specification abolishes this cumbersome mechanism entirely. Now, every single request is entirely self-contained. Each request inherently carries the protocol version, client identity, and capability declarations, allowing for independent processing.
If a client wishes to ascertain supported server features proactively, it can invoke the newly introduced server/discover interface. While not a strict prerequisite before dispatching other requests, developers are strongly encouraged to implement it. Consequently, clients can elegantly display available MCP server capabilities to end-users.
Crucially, this stateless design empowers standard load balancers to distribute requests indiscriminately across any available server instance. It eliminates the necessity for a client to maintain a persistent connection to a specific node. Furthermore, servers no longer require complex shared storage mechanisms to maintain protocol sessions. Ultimately, this drastically reduces the operational complexity of deploying MCP services in clustered, auto-scaling environments.
Applications can, of course, still manage internal state. For instance, if a tool must maintain task progress across multiple requests, it can generate an explicit handle. The underlying language model will then seamlessly pass this handle back as a parameter during subsequent invocations.
Multi-Round Requests Replace Server-Initiated Calls
Because the stateless architecture eradicates persistent bidirectional connections, a new mechanism was required for user interactions. Often, during tool execution, the system must prompt the user for confirmation or supplementary parameters. To resolve this, the new specification introduces the Multi-Round Turn Request (MRTR) mechanism.
When a tool requires additional input, the server simply returns an input_required status, accompanied by the necessary queries. After the client collects the user’s response, it re-transmits the original invocation request, now appended with the answers, to finalize the operation.
This elegant solution entirely replaces the previous server-initiated requests, such as elicitation/create, sampling/createMessage, and roots/list. For example, before executing a destructive data deletion tool, the system can pause, demand explicit user confirmation via MRTR, and then proceed—all without maintaining an active bidirectional data stream.
HTTP Header Routing and Intelligent Caching
Under the new specifications, Streamable HTTP requests must explicitly declare the invocation method and tool name via the Mcp-Method and Mcp-Name headers. Consequently, gateways, load balancers, rate-limiting systems, and Web Application Firewalls (WAFs) can execute routing, billing, and authorization checks by simply reading the headers. They no longer need to parse the entire JSON request body.
Furthermore, responses from endpoints like tools/list, prompts/list, resources/list, and resources/read can now include sophisticated caching directives. Clients can cache tool and resource lists to aggressively minimize redundant network requests. This also ensures that the sequence of tools remains perfectly consistent upon reconnection, thereby preventing frequent invalidations of the upstream AI model’s prompt cache.
Enhanced OAuth Security and the Deprecation Roadmap
Anthropic also prioritized security enhancements within this update. The new protocol mandates that clients rigorously verify the issuer information returned by the authorization server. This critical step mitigates the risk of authorization server mix-up attacks. Additionally, client credentials are now strictly bound to the specific authorization server that issued them, expressly forbidding their reuse across disparate MCP servers.
Dynamic Client Registration (DCR) has been officially deprecated. The MCP protocol will now pivot toward Client ID Metadata Documents (CIMD). While DCR remains temporarily functional, Anthropic emphatically stressed that it will be entirely excised in future releases. Therefore, developers must prioritize this adaptation.
Finally, the Tasks feature has graduated from an experimental core component into the formalized extension framework. Features like MCP Apps and enterprise managed authorization can similarly be provided via these extensions. Meanwhile, Roots, Sampling, Logging, and the legacy HTTP+SSE transport methodology have entered the deprecation phase. However, Anthropic guarantees a minimum 12-month compatibility window for these retiring features.
Support Our Threat Intelligence
If you find our CVE report and cybersecurity news helpful, consider supporting our work.
Buy Me a Coffee
PayPal
