The Model Context Protocol (MCP) has become the common way to connect AI applications and agents to tools and data. On 28 July 2026 its maintainers released the 2026-07-28 specification, the largest revision since the protocol launched. Most coverage focuses on what developers must change in their code. This article looks at it from the architect’s side: what changes in your deployment topology, your gateways, your identity design and your migration plan.
MCP in thirty seconds
An MCP server exposes capabilities, such as tools an AI can call, resources it can read and reusable prompts. An MCP client inside an AI application (an assistant, an IDE, an agent runtime) discovers and uses them. Build one MCP server in front of a system, and any MCP-capable client can use it. For enterprises, that makes MCP servers a new integration layer, sitting alongside your APIs and event streams.
What changed in 2026-07-28
1. The protocol is now stateless
Earlier versions began each connection with an initialization handshake and tracked a session ID. The new version drops both. Every request now carries its own protocol version, client details and capabilities, and clients can optionally ask a server to describe its capabilities up front. The practical result: any server instance behind an ordinary round-robin load balancer can handle any request, with no shared session store and no sticky routing. The maintainers recommend that application state live in explicit handles that tools return and the model passes back, rather than in a transport session.
2. Routing information moves into HTTP headers
Requests over the Streamable HTTP transport must now state the MCP method and the target name (for example, which tool is being called) in headers. Gateways, rate limiters and web application firewalls can therefore route, meter and authorize MCP traffic per tool without parsing the JSON body.
3. Caching hints for discovery
Responses that list tools, prompts and resources, and responses that read resources, can now carry a time-to-live and a cache scope, and list results come back in a stable order. Fewer repeated discovery calls, and more predictable prompts for model-side caching.
4. Server questions without held-open connections
When a server needs something from the client mid-task (more user input, for example), it now returns a result saying input is required, and the client simply retries the call with the answers. This replaces several server-initiated request types that previously needed a long-lived stream.
5. Authorization hardening
- Clients must validate the issuer of an authorization response before redeeming the code, closing an authorization-server mix-up gap.
- Client credentials are bound to the authorization server that issued them and cannot be reused across servers.
- Desktop and command-line clients can register localhost redirects properly.
- Dynamic Client Registration is formally deprecated in favor of Client ID Metadata Documents. It still works but is scheduled for removal in a future version.
6. An extensions framework
Features that evolve quickly now live as formal extensions outside the core protocol. Long-running Tasks moved into an extension (with polling and updates), and MCP Apps and Enterprise Managed Authorization are named as extensions too. The core stays small and stable while these evolve on their own timelines.
7. Deprecations, with a predictable policy
Roots, Sampling and Logging are deprecated, and so is the legacy HTTP+SSE transport. New implementations should not adopt them. The specification now includes a formal lifecycle and deprecation policy with a minimum twelve-month window, which gives enterprises the roadmap predictability they need for planning.
What it means for your architecture
- Run MCP servers like any stateless service. Horizontal scaling, blue-green deployments and multi-region setups become ordinary platform work. Remove sticky sessions and session stores that existed only for MCP.
- Put an MCP-aware gateway in front. With method and tool names in headers, your API gateway can enforce per-tool policies: which teams may call which tools, rate limits on expensive or risky tools, and full audit logging, without deep packet inspection.
- Design state explicitly. If a tool needs continuity (a draft order, a multi-step workflow), return an explicit handle and persist state in your own store. That is easier to secure, test and recover than hidden session state.
- Revisit identity. Align MCP authorization with your existing OAuth / OpenID Connect platform, validate issuers, and plan the move from Dynamic Client Registration to Client ID Metadata Documents. Enterprises should also watch the Enterprise Managed Authorization extension.
- Govern deprecations. Inventory every MCP server and client you run or buy, record which protocol version and features each uses, and track the deprecation windows like any other platform dependency.
Migration checklist
- Inventory MCP servers and clients, including those embedded in vendor products.
- Identify anything that depends on session IDs, server-initiated requests, Sampling, Roots, Logging or the HTTP+SSE transport.
- Upgrade to SDK versions that support 2026-07-28. The maintainers list TypeScript, Python, Go and C# support, with Rust in beta.
- Move workflow continuity into explicit handles and your own state store.
- Configure gateway policies, rate limits and logging using the new routing headers.
- Update authorization: issuer validation and a plan for Client ID Metadata Documents.
- Re-run your agent evaluations and security tests after migration.
Want the bigger picture on safety? Read Guardrails for AI agents: least agency and human-in-the-loop patterns. New to MCP and agents? Start with A beginner’s map of generative AI.
Sources
- The 2026-07-28 Specification, Model Context Protocol blog
- MCP specification, version 2026-07-28, modelcontextprotocol.io