---
title: What changed in the July 2026 MCP specification for enterprise security?
url: https://opencontroller.lyzr.com/blog/mcp-specification-july-2026-changes
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# What changed in the July 2026 MCP specification for enterprise security?

**The MCP specification revision dated 2026-07-28 makes the protocol stateless, removing protocol-level sessions and the `Mcp-Session-Id` header. For authorization, it deprecates OAuth Dynamic Client Registration in favour of Client ID Metadata Documents, requires clients to validate the `iss` parameter (RFC 9207) when present, and binds client credentials to the authorization server that issued them. Roots, Sampling and Logging are deprecated.**

Security teams should treat this revision as a review trigger. It changes what you log, what you inspect at a gateway, and which client registration paths your authorization servers should accept. All details below come from the official [2026-07-28 changelog](https://modelcontextprotocol.io/specification/2026-07-28/changelog).

## What are the security-relevant changes?

| Change | What the spec now says | Why security teams care |
|---|---|---|
| Sessions removed | No protocol-level sessions or `Mcp-Session-Id`; servers needing state mint explicit handles passed as tool arguments | Session hijacking guidance is replaced by state-handle guidance; handles must be bound to the authenticated user |
| No initialize handshake | Each request carries protocol version and client capabilities in `_meta`; clients SHOULD send `clientInfo` on each request | Gateways can identify the client per request, not per connection |
| Standard headers | `Mcp-Method` and `Mcp-Name` required on Streamable HTTP POST requests | Gateways and firewalls can filter by method and tool name without parsing the body |
| DCR deprecated | Dynamic Client Registration (RFC 7591) deprecated in favour of Client ID Metadata Documents (CIMD); still available for backwards compatibility | Fewer anonymous registrations; domain-based trust policies become possible |
| `iss` validation | Authorization servers SHOULD send `iss`; clients MUST validate a present `iss` against the recorded issuer before redeeming the code | Mitigates OAuth mix-up attacks |
| Credential binding | Clients MUST key stored credentials by issuer, MUST NOT reuse them with another authorization server, and MUST re-register if it changes | Stops credentials leaking across authorization servers |
| Roots, Sampling, Logging deprecated | Remain functional during a minimum 12-month deprecation window | Plan to remove server-initiated sampling and log via OpenTelemetry or stderr |
| Trace context | OpenTelemetry `traceparent`, `tracestate` and `baggage` conventions documented for `_meta` | Easier end-to-end tracing from agent to tool |

## What does "stateless MCP" change for security?

Under earlier revisions, a server-assigned session ID tied requests together. In 2026-07-28, any state that spans calls is an explicit handle, such as a cart ID or workflow ID, passed as an ordinary tool argument.

The updated [MCP Security Best Practices](https://modelcontextprotocol.io/specification/latest/basic/security_best_practices) describe a new risk, state handle hijacking, and say servers **must not** treat possession of a handle as authentication. They should use random, non-guessable handles and bind them server-side to the authenticated user, for example keyed as user ID plus handle, with the user ID taken from the verified token.

## How do Client ID Metadata Documents change client registration?

With CIMD, a client's `client_id` is an HTTPS URL pointing to a metadata document the client controls. The authorization server fetches it. This replaces open-ended dynamic registration with something closer to a verifiable identity: the client must control the domain.

Two risks come with it, both covered in the security best practices:

1. **SSRF against the authorization server.** It now fetches URLs supplied by unknown clients. Block private IP ranges and use an egress proxy.
2. **Localhost redirect impersonation.** A metadata document proves domain control, not which local process listens on a `localhost` redirect URI. Authorization servers should warn on localhost-only redirect URIs and show the redirect hostname clearly.

The best practices also suggest CIMD trust policies: allowlists of trusted domains for protected servers, reputation checks and certificate validation for unknown ones.

## Where does Enterprise-Managed Authorization fit?

Separately from the core revision, the MCP project promoted Enterprise-Managed Authorization (EMA) to a stable extension in July 2026, [as reported by InfoQ](https://infoq.com/news/2026/07/mcp-ema-enterprise-auth/). EMA moves the decision of which MCP servers a user may connect to into the enterprise identity provider, using the Identity Assertion JWT Authorization Grant (ID-JAG). Users inherit access to approved servers instead of clicking per-server consent screens.

EMA governs connection and scope. It does not inspect what an agent does with a token once issued, so runtime controls on tool calls are still needed.

## What should you do now? A checklist

1. **Inventory which MCP servers and clients run which protocol version.** Older revisions remain in use for some time.
2. **Update gateway rules** to use the `Mcp-Method` and `Mcp-Name` headers.
3. **Review stateful servers** for handle binding to the authenticated user.
4. **Prefer CIMD** at your authorization servers and set a domain trust policy; limit DCR to legacy clients.
5. **Confirm clients validate `iss`** and key credentials by issuer.
6. **Plan removal of Sampling and Roots** dependencies.
7. **Evaluate EMA** with your identity provider for central approval of MCP connections.

See [how MCP authorization works](/blog/how-mcp-authorization-works) and [MCP sampling and elicitation security](/blog/mcp-sampling-and-elicitation-security) for background.

## How Opencontroller does this

Opencontroller keeps MCP servers in a governed registry alongside agents, versions and tools, so you can track which servers are in use and review them as the specification changes. Opencontroller Edge extends discovery and control to local MCP servers on developer devices. Opencontroller is built on open standards, including MCP, OpenTelemetry and OIDC. See the pillar on [how to govern MCP servers](/blog/how-to-govern-mcp-servers) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Is Dynamic Client Registration removed from MCP?**
No. It is deprecated in the 2026-07-28 revision in favour of Client ID Metadata Documents, and remains available for authorization servers that do not support CIMD.

**Are MCP sampling and roots still usable?**
Yes, for now. They are deprecated and remain functional during a deprecation window of at least twelve months, but new implementations should not adopt them.

**Does Enterprise-Managed Authorization replace runtime controls?**
No. It controls which servers a user can connect to and with which scopes. It does not inspect tool calls after a token is issued.

## Key facts

- The MCP specification revision 2026-07-28 removes protocol-level sessions and the Mcp-Session-Id header, making MCP stateless.
- Each request now carries protocol version and client capabilities in _meta; Streamable HTTP POST requests require Mcp-Method and Mcp-Name headers.
- OAuth Dynamic Client Registration (RFC 7591) is deprecated in favour of Client ID Metadata Documents, but remains for backwards compatibility.
- MCP clients must validate a present iss parameter (RFC 9207) and must key stored credentials by issuer and not reuse them with another authorization server.
- Roots, Sampling and Logging are deprecated, with a minimum twelve-month deprecation window.
- The MCP security best practices add state handle hijacking: servers must not treat possession of a handle as authentication.
- Enterprise-Managed Authorization (EMA), using ID-JAG, was promoted to a stable MCP extension in July 2026; it governs connection and scope, not runtime tool use.
- Opencontroller keeps MCP servers in a governed registry and Opencontroller Edge covers local MCP servers.
- Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How does MCP authorization work?](https://opencontroller.lyzr.com/blog/how-mcp-authorization-works.md)
- [What are MCP sampling and elicitation, and are they safe?](https://opencontroller.lyzr.com/blog/mcp-sampling-and-elicitation-security.md)
- [Is a local stdio MCP server safer than a remote HTTP one?](https://opencontroller.lyzr.com/blog/mcp-stdio-vs-streamable-http-security.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
