The Model Context Protocol just got its most significant rewrite since Anthropic launched it. On May 21, 2026, MCP's lead maintainers published the 2026-07-28 release candidate and called it "the largest revision of the protocol since launch." That's not marketing language — the spec removes sessions, drops the initialization handshake, deprecates three core features, and rewrites how authorization works. If your business team runs MCP-based workflows, some of those workflows may already be breaking.
This post gives you a plain-English breakdown of the MCP update 2026, what it actually changes, what it breaks, and what you need to do before the final spec lands.
What the 2026-07-28 MCP Spec Actually Changes
The headline change is architectural: MCP is now stateless at the protocol level. Previously, every MCP connection required a session — a persistent, stateful handshake between client and server. The new spec removes that entirely. No sessions. No initialize handshake. Requests stand alone.
Here's a summary of the four major changes:
| Area | Before (pre-2026-07-28) | After (2026-07-28 RC) |
|---|---|---|
| Sessions | Required; server tracked state per client | Removed; protocol is stateless |
| Initialization handshake | Mandatory initialize call before any request | Gone; clients connect directly |
| Authorization | OAuth flows loosely specified | Hardened; agent-to-agent auth formalized |
| Extensions | Experimental, informal | First-class citizens (Tasks, MCP Apps) |
The official release candidate post frames this as making MCP "routable, cacheable, and traceable" — properties that matter a great deal for infrastructure teams scaling AI agents across cloud environments, but that also break assumptions baked into most existing server implementations.
Why Sessions and the Handshake Were Removed
The old session model was a scaling liability. Every time a client connected, the server had to store state — who connected, what capabilities were negotiated, where the conversation was. That meant sticky sessions, Redis dependencies, and load balancers that had to route each client to the same server instance.
GitHub's engineering team described this concretely: to support the new spec, they removed Redis sessions entirely. Previously, every initialize call wrote to a database, and every subsequent call read from it. With the new stateless spec, both are gone — which makes responses faster and infrastructure simpler.
Microsoft's App Service team noted the same pattern: teams were already working around the stateful spec by using stateless HTTP transport and disabling session affinity on load balancers. The new spec makes that the default, not a workaround.
For business teams, the practical implication is this: any MCP server your team built or deployed that relies on session state — tracking which user is connected, persisting context across calls, or using the initialize negotiation to decide what to expose — needs to be rearchitected.
What the Authorization Hardening Means in Practice
The authorization changes are the other major area that will affect business teams, especially those connecting MCP servers to internal data sources.
According to WorkOS's analysis of the release candidate, the spec formalizes agent-to-agent authentication — the mechanism by which one AI agent can call another's MCP server with proper credentials. Previously this was loosely specified, which meant teams were improvising their own auth flows, creating security gaps and interoperability problems.
The new spec tightens this with:
- Formalized OAuth flows for agent-to-server and agent-to-agent authentication
- Scoped permissions so agents only access what they're explicitly authorized to access
- Clearer token handling to prevent credential leakage between agent calls
If your current MCP setup uses a simple API key or an informal auth pattern, you'll need to migrate to the new authorization model before the final spec lands. The good news: this is the right direction. Agents operating on business data — CRM records, financial data, internal comms — need proper permissioned access, not a shared key.
What the Extension System Changes
The third major change is less likely to break existing workflows but worth understanding: extensions are now first-class citizens in the protocol.
Two extensions graduate to formal status:
- Tasks — long-running, async operations that an agent can hand off and check on later. This is critical for workflows that take more than a few seconds.
- MCP Apps — server-rendered user interfaces that an MCP server can push to the client. Think of it as a way for an MCP server to return structured UI, not just text.
For business teams, the Tasks extension is the more immediately relevant one. If you're running agents that do things like summarize a week of Slack messages, pull a report from Salesforce, or reconcile invoices in QuickBooks, those are multi-step operations that benefit from proper async task handling rather than a single synchronous call that times out.
What Actually Breaks — and for Whom
Not everything breaks. Neil Mansilla at Barndoor AI, who has been running MCP server implementations at scale, notes that the tier-1 SDKs (Python, TypeScript, Go) have all shipped beta support for the new spec with backwards compatibility preserved. If you're using a managed MCP server built on one of those SDKs, your vendor should handle the migration.
What does break:
Custom-built servers that manage session state. If your team wrote an MCP server that stores per-session context — user preferences, in-progress workflows, negotiated capabilities — that logic needs to move to the application layer. The protocol won't carry it anymore.
Auth implementations that relied on the handshake. Some teams used the initialize exchange to pass credentials or negotiate scopes. That flow is gone. You need proper OAuth.
Servers that inspect request payloads for routing. GitHub's team noted they previously had to do deep packet inspection to read values for logging and secret scanning. The new spec guarantees those values in HTTP headers, but servers that depended on payload inspection need to update their routing logic.
Clients that assumed sequential initialization. The new spec allows clients to complete the handshake in parallel. Clients that assumed a strict sequential flow may behave unexpectedly.
How to Adapt Before the Final Spec Lands
The release candidate was published May 21, 2026, with a final spec date of July 28, 2026. Here's a practical checklist:
- Audit your MCP servers for session state. List every place your server stores per-session data. Decide what moves to the application layer and what gets dropped.
- Check your auth implementation. If you're using anything other than a properly scoped OAuth flow, plan the migration now. The WorkOS analysis is a good reference for what the new auth model expects.
- Review your SDK version. If you're on a tier-1 SDK (Python, TypeScript, Go), check that you're on the beta release that supports
2026-07-28. The backwards compatibility window won't last indefinitely. - Test async workflows with the Tasks extension. If you have long-running agent operations, the Tasks extension is now the right primitive — start using it.
- Talk to your MCP server vendor. If you're using a managed MCP service rather than a custom build, ask them directly what their migration timeline is.
The broader context matters here: according to Stacklok's 2026 software report, cited by Digital Applied, 41% of surveyed software organizations are already in limited or broad production with MCP servers. With the ecosystem this large — over 9,600 servers in the official registry and 97M+ monthly SDK downloads according to Anthropic — a breaking spec change has real operational consequences for real teams.
Keeping Your Company Context Layer Stable Through Spec Changes
One of the harder problems the MCP update 2026 surfaces is this: if your AI agents depend on MCP servers to access your company's data — Slack history, CRM records, financial data — a breaking spec change means your agents lose context until the servers are updated.
This is exactly why the architecture of your company context layer matters. A well-designed business context layer for AI doesn't just expose data as MCP servers — it manages the permissioning, source citations, and update cycles so that when the protocol changes, the context layer absorbs the change rather than passing it to every downstream agent.
Gyld exposes your company's data from Slack, Gmail, Notion, HubSpot, Salesforce, QuickBooks, and other connected apps as MCP servers with proper permissioning built in. When the spec updates, Gyld's servers update — your agents keep working. That's a different proposition from building and maintaining your own RAG pipeline, where every protocol change is your team's problem to absorb.
Key takeaways:
- The
2026-07-28MCP spec removes sessions and the initialization handshake, making the protocol stateless. Custom servers built around session state need rearchitecting. - Authorization is hardened with formalized OAuth. Informal auth patterns need to migrate.
- Tier-1 SDKs have backwards compatibility in beta — check your SDK version and your vendor's migration timeline.
If you want your AI agents to have reliable, permissioned access to your company's context without absorbing every protocol update yourself, start building your company brain with Gyld.
Frequently asked questions
What is the MCP 2026-07-28 spec change in plain English?
The Model Context Protocol's July 2026 release candidate removes stateful sessions and the initialization handshake, making MCP stateless at the protocol level. It also formalizes agent authentication with proper OAuth flows and promotes async Tasks and MCP Apps to first-class extensions. It's the largest change to the protocol since its launch.
Will existing MCP servers break when the new spec ships?
Servers built on tier-1 SDKs (Python, TypeScript, Go) have backwards compatibility in the beta releases, so managed servers should continue working if vendors update promptly. Custom servers that store per-session state, use informal auth, or rely on payload inspection for routing will need code changes before the final spec lands on July 28, 2026.
What does the removal of MCP sessions mean for business workflows?
Any workflow that relied on the MCP server tracking per-session state — user identity, in-progress context, negotiated capabilities — needs that logic moved to the application layer. The protocol itself no longer carries it. Long-running operations should migrate to the new Tasks extension.
How does the new MCP authorization model work?
The 2026-07-28 spec formalizes OAuth-based authentication for agent-to-server and agent-to-agent calls, with scoped permissions and cleaner token handling. Teams using API keys or informal auth patterns need to migrate to proper OAuth flows before the final spec ships.
How does Gyld handle MCP spec updates for business teams?
Gyld manages the MCP server infrastructure for your connected apps — Slack, Gmail, Notion, HubSpot, Salesforce, QuickBooks, and more — so spec updates are absorbed at the platform level. Your agents keep accessing your company's context without your team needing to track protocol changes or rewrite server code.