AI Security & Governance

MCP Swaps DCR for CIMD: Rebuild Your Agent Auth Path Now

Rushil ShahRushil Shah
14 min read
Share

MCP's 2026-07-28 spec formally deprecated Dynamic Client Registration in favour of Client ID Metadata Documents. That moves client identity from a registration endpoint you control to a document the client hosts — and most enterprise allowlists do not survive the change.

TL;DR

The 2026-07-28 MCP specification demotes Dynamic Client Registration to a backwards-compatibility fallback and makes Client ID Metadata Documents (CIMD) the default. Operationally this is not a drop-in swap: your client allowlist moves from a registration endpoint your authorization server controls to a JSON document the client hosts on its own domain. If you turned on DCR in a hurry during the 2025 rush, you are now holding a registration table full of per-machine duplicates and live refresh tokens with no owner. Pick one of three patterns — gateway-mediated, CIMD with pinned domains, or fully static pre-registration — before the next spec release lands on 30 March 2027.

Dynamic Client Registration is still functional. That is the single most important operational fact, and most of the coverage of the 2026 MCP updates buries it under a feature list. The maintainers were explicit in the release notes: DCR is formally deprecated in favour of CIMD, continues to work for backward compatibility, and will be removed in a future version. No removal date has been published. Unlike Roots, Sampling and Logging — which the same release deprecated with an explicit commitment that they keep working for at least twelve months — DCR's offramp is undated. Treat that as a planning window, not a reprieve.

What follows is the auth-path rebuild, not a protocol explainer: what the registration handshake looks like before and after, who is allowed to register a client against your server under each model, and which parts of your existing gateway break for reasons that have nothing to do with registration at all.

~500Mmonthly downloads across the Tier 1 MCP SDKs as of the July 2026 releaseSource: Model Context Protocol Blog, 2026
1Btotal downloads crossed by both the TypeScript and Python SDKsSource: Model Context Protocol Blog, 2026
12 monthsminimum support window the maintainers committed to for Roots, Sampling and Logging — DCR has no comparable dated commitmentSource: Model Context Protocol Blog, 2026
2027-03-30next MCP specification release, now on a fixed six-month cadenceSource: Model Context Protocol Blog, 2026

The registration handshake, before and after

Under DCR, an unknown client POSTed metadata to your authorization server's /register endpoint, your server wrote a row, and it handed back a client_id that your server had minted and could therefore govern, rate-limit and revoke. Under CIMD, there is no write. The client's client_id is an HTTPS URL with a path component, pointing at a JSON document the client hosts, and your authorization server fetches it at authorization time.

The spec now lists three mechanisms with a defined priority order for clients that support all of them: use pre-registered credentials if you have them; otherwise use CIMD if the authorization server advertises client_id_metadata_document_supported in its OAuth Authorization Server Metadata; otherwise fall back to DCR if a registration_endpoint is present; otherwise prompt the user to type client details in by hand. The minimum viable metadata document carries client_id, client_name and redirect_uris, and the client_id value inside the document must match the URL it was fetched from exactly.

CIMD authorization, step by step

1
Client discovers the authorization server

Protected resource metadata on the MCP server points to the AS; the client checks for client_id_metadata_document_supported.

↓
2
Authorization request carries a URL as client_id

No registration call happens. client_id=https://app.example.com/oauth/client-metadata.json.

↓
3
Authorization server fetches the document

An outbound HTTPS GET from inside your network perimeter to a URL the caller chose. This is the new attack surface.

↓
4
Validation

Document is valid JSON, client_id matches the URL exactly, the requested redirect_uri appears in the document, and — optionally — the domain passes your trust policy.

↓
5
Consent, code, token

Standard OAuth 2.1 with PKCE. The consent screen renders client_name from a document the client controls.

↓
6
Cache

The AS caches the metadata respecting HTTP cache headers. Your revocation latency is now a function of someone else's Cache-Control header.

Who is allowed to register a client against your MCP server

This is the question an integrator actually faces, and the honest answer is that CIMD does not answer it for you — it relocates it. The maintainers' own write-up of the registration problem is unusually candid about why DCR had to go: an unauthenticated /register endpoint writes to a database, registrations are not portable so the same desktop app on Windows and macOS creates two distinct client IDs, and an administrator ends up auditing hundreds of records for the same application with no way to correlate them. Anyone who ran DCR at scale recognises all three.

CIMD fixes those cleanly. One URL per application, no write path, no expiry black hole, natural per-app identity for audit. What it does not fix is trust. The maintainers classify client impersonation as a separate, orthogonal challenge: a malicious client can register a callback and claim to be a well-known desktop app, and the mitigation — restricting trusted domains and warning on unknown ones — works with both DCR and CIMD. CIMD gives you a stable, DNS-anchored handle to apply that policy to. It does not write the policy.

Two sharp edges the spec calls out explicitly and most summaries skip. First, CIMD cannot prevent localhost URL impersonation on its own; authorization servers should warn on localhost-only redirect URIs and must clearly display the redirect URI hostname during authorization. Every CLI and desktop MCP client in your estate redirects to 127.0.0.1, so this is not an edge case. Second, the authorization server now makes outbound fetches to attacker-supplied URLs, and the spec routes you to the SSRF considerations in the IETF draft. If your AS sits inside a VPC with a metadata service on a link-local address, you have just handed an unauthenticated caller a fetch primitive.

!

Treating "CIMD supported" as "CIMD governed"

Teams flip client_id_metadata_document_supported to true in their AS metadata because the spec says SHOULD, ship it, and consider the migration done. They have now replaced an open write endpoint with an open read-and-trust path: any domain on the public internet can mint a client identity against their MCP server, and the consent screen will faithfully render whatever client_name that domain publishes.

Fix: ship CIMD support and a domain trust policy in the same change. The spec permits domain-based trust policies for accepting metadata documents — use an explicit allowlist for internal servers, a warn-and-log posture for public ones, and make the unknown-domain path visibly different in the consent UI.

Three enterprise patterns, and how to choose

There is no single correct migration. The right pattern depends on whether the set of clients that may call your MCP server is bounded, and on whether you already operate an egress-controlled gateway in front of it.

PatternWho decides which clients connectWhat you hostBreaks whenBest for
Gateway-mediatedYour gateway. It terminates MCP, holds the only registered OAuth client, and brokers downstream identity.The gateway, its client registry, and per-tool policy.You need end-user consent semantics per upstream API, or a client needs capabilities the gateway does not proxy.Internal MCP servers where every caller is a managed app.
CIMD with pinned domainsYour trust policy. Any client whose metadata URL is on an approved domain gets in; everything else is denied or flagged.An SSRF-hardened fetcher, a cache with a bounded TTL, and the domain allowlist as reviewed config.A trusted domain is taken over, or a vendor silently changes redirect_uris in a document you cache for 24 hours.Partner-facing or semi-open servers with a known vendor set.
Fully static pre-registrationYou, manually, one client at a time.Nothing new. Client IDs issued out of band.The client list grows past a handful, or users bring their own MCP hosts.Three to ten known clients. Genuinely the correct answer more often than the spec's framing suggests.
Enterprise-Managed Authorization (on top of any of the above)Your IdP, by group and role, before OAuth is reached.IdP configuration and server-side ID-JAG support.A client or server in the chain has not implemented the extension.Workforce deployments where per-user consent fatigue is the real problem.

That last row is the one to look at hardest if you are an enterprise buyer. The Enterprise-Managed Authorization extension went stable in June 2026; the client obtains an Identity Assertion JWT Authorization Grant from the IdP during SSO and exchanges it for an access token at the MCP server's authorization server, with no per-server consent screen. Okta is the first supported IdP, Anthropic and Visual Studio Code shipped client support, and Asana, Atlassian, Canva, Figma, Granola, Linear and Supabase support it on the server side.

"we turn identity into a centralized governance plane"

— Aaron Parecki, Director of Identity Standards, Okta, Model Context Protocol Blog

EMA and CIMD solve different halves. CIMD answers "which application is this?" EMA answers "is this user, in this org, allowed to use that application against this server?" Deploying CIMD without something in the EMA position leaves you with clean client identity and no authorisation policy behind it. When we scope MCP work in integration engagements, this is the split we draw first, because it decides whether the gateway is a routing component or a policy component.

What breaks in your existing gateway that has nothing to do with CIMD

The registration change gets the headlines; the stateless core is what will actually page you. The 2026-07-28 release retired the initialize/initialized exchange and the Mcp-Session-Id header — every request now carries its protocol version, client identity and capabilities in _meta, and any request can land on any instance behind a plain round-robin load balancer. If your authorization layer caches a token-to-session mapping, applies per-session rate limits, or relies on sticky routing to keep an SSE stream alive, all three assumptions are gone.

Three more changes land directly on the auth path. Authorization servers should return the iss parameter per RFC 9207 and clients must validate it before redeeming a code, closing an AS mix-up hole; clients must set application_type during DCR so desktop and CLI localhost redirects stop being rejected; and client credentials are now bound to the issuer that minted them, with no reuse across authorization servers. That third one has a quiet operational consequence: clients must key persisted credentials to the AS issuer identifier, so multi-tenant hosts that stored one client record per MCP server URL need a schema change, not a config change.

On the upside, routing gets easier. Streamable HTTP requests must now include Mcp-Method and Mcp-Name headers, so a gateway, rate limiter or WAF can route and meter on headers instead of parsing JSON bodies. That is the single most useful thing in the release for anyone running a policy enforcement point: per-tool rate limits and per-tool deny rules become L7 rules rather than body-inspection hacks. The legacy HTTP+SSE transport is also officially deprecated with a year-long offramp.

!

Passing the client's token through to upstream APIs

The MCP server sits between an agent and three SaaS APIs, and the fastest implementation forwards the inbound bearer token upstream. It works in staging, and it quietly makes every upstream a confused deputy.

MCP Apps widens the review surface

The thing that changes your security review is not registration, it is that a server can now render UI inside the host. MCP Apps shipped as the first official MCP extension in January 2026: tools declare a _meta.ui.resourceUri pointing at a ui:// resource containing bundled HTML and JavaScript, which the host renders in a sandboxed iframe with bidirectional JSON-RPC over postMessage.

Read that as an auth question. Code inside that iframe can call app.callServerTool() and app.updateModelContext() — meaning a UI surface can originate tool calls and write into the model's context, under the same grant the user approved for a single tool invocation. The extension's answer is layered: iframe sandboxing with restricted permissions, pre-declared templates hosts can review before rendering, auditable JSON-RPC messages, and optional explicit user approval for UI-initiated tool calls. Those controls are real, but three of the four are host-side options rather than guarantees, and the post's own closing advice is that users should still vet servers before connecting them.

Practically, if you allow MCP Apps against internal servers, your review needs two additions: an inventory of which tools ship UI resources and what those bundles load at runtime, and a host-level decision on whether UI-initiated tool calls require per-call consent. Claude, Goose, Visual Studio Code and ChatGPT all shipped support, so "we don't allow that" is not a stance you can assume by default — check what your approved hosts actually enable. Our notes on how different hosts differ here sit alongside the rest of our model and host coverage.

The checklist for teams who turned on DCR in a hurry

Order matters. Inventory before you migrate, because the migration will otherwise carry your unknowns forward into a new identity model.

Seven steps, in sequence

1
Dump the registration table

Every row created by /register, with creation date, last token issuance, and the redirect URIs. Expect duplicates per user per machine.

↓
2
Join to live tokens

Any client ID with no token activity in 90 days is a candidate for revocation. Any client ID with live refresh tokens and no identifiable owner is an incident, not a backlog item.

↓
3
Collapse to applications

Map the surviving rows to actual applications. The count is usually one or two orders of magnitude smaller, which tells you whether static pre-registration is viable.

↓
4
Choose the pattern per server, not per estate

Internal servers rarely need CIMD at all. Partner-facing ones usually do.

↓
5
Harden the fetcher before advertising support

Egress allowlist, no redirects to private ranges, response size cap, timeout, bounded cache TTL independent of the origin's headers for revocation purposes.

↓
6
Rewrite audit logs around the URL identity

Log the full metadata URL, the document hash, and the fetch outcome on every authorization. A silent change to a trusted vendor's document should be detectable after the fact.

↓
7
Keep DCR enabled, logged, and visibly on the clock

It still works. Alert on new registrations rather than blocking them, so you learn which clients have not migrated before you turn it off.

When the honest answer is "don't migrate yet"

If your MCP servers are internal, reached through a gateway, and called by a client list you could write on a napkin, CIMD buys you nothing this quarter. Pre-registration already satisfies the spec's top-priority option, it is the cheapest thing to audit, and it does not add an outbound fetch from your authorization server to a URL supplied by the caller. Migrate when the client list stops being enumerable, not when a release note tells you a mechanism is deprecated.

The genuinely urgent work is the inventory, and it is urgent regardless of which pattern you land on. Unaudited DCR registrations holding live refresh tokens are a problem today; CIMD does not clean them up, and the deprecation does not revoke them. The second priority is the stateless-core migration, because that one has real breaking behaviour against existing deployments rather than a compatibility path.

Timing is now at least predictable. The project moved to a fixed six-month cadence on the last Tuesday of March and September, with a soft freeze two and a half months out, Tier 1 SDK betas six weeks out, and a hard freeze one month before release. That gives you a concrete planning anchor: whatever lands in 2027-03-30 will be visible in frozen form by mid-January and in SDK betas by mid-February. Plan the DCR shutdown against that calendar rather than against a rumour. If you want a second pair of eyes on the auth path before you flip anything, start here.

Frequently Asked Questions

Is Dynamic Client Registration still usable in MCP?

Yes. The 2026-07-28 release formally deprecated DCR in favour of Client ID Metadata Documents, but stated it continues to work for backward compatibility and will be removed in a future version. No removal date has been published, and DCR remains in the spec's client priority order as the third option after pre-registration and CIMD. Keep it enabled while you migrate, but log and alert on new registrations.

What exactly do we have to host to support CIMD as a client?

A JSON document at a stable HTTPS URL with a path component, containing at minimum client_id, client_name and redirect_uris, where the client_id value matches the document URL exactly. Typical documents also declare grant_types, response_types and token_endpoint_auth_method. Desktop and CLI clients still need backend infrastructure to host it, which is the main cost of the model for non-web clients.

Does CIMD stop untrusted clients from connecting to our MCP server?

No. CIMD gives each application one stable, domain-anchored identifier, which makes allow and deny policy possible — it does not apply that policy for you. The MCP security considerations explicitly permit domain-based trust policies, which means they are optional. Without one, any domain on the internet can present a metadata document and your consent screen will show the client name it publishes.

What is the SSRF risk people keep mentioning with CIMD?

Under CIMD your authorization server makes an outbound HTTPS GET to a URL chosen by the caller, at authorization time. The MCP specification tells implementers to consider server-side request forgery risk and points to the IETF draft's security considerations. Mitigate with an egress allowlist, refusal to follow redirects into private address ranges, response size and timeout caps, and no credential forwarding on the fetch.

How does Enterprise-Managed Authorization relate to CIMD?

They sit at different layers. CIMD establishes which application is calling. Enterprise-Managed Authorization, stable since June 2026, makes the organisation's identity provider the decision point for whether a user may reach a given MCP server, using an Identity Assertion JWT Authorization Grant exchanged during SSO instead of per-server consent. Most enterprise deployments need both: identity for the client, policy for the user.

What breaks in our gateway when we move to the 2026-07-28 spec?

Anything keyed on Mcp-Session-Id, because the session header and the initialize handshake were retired — session-scoped auth caches, per-session rate limits and sticky routing all need rework. In exchange, the mandatory Mcp-Method and Mcp-Name headers let you apply per-tool routing, metering and WAF rules without parsing request bodies. The legacy HTTP+SSE transport is deprecated with a year-long offramp.

Do MCP Apps change our security review?

Yes, because a server can now ship HTML and JavaScript that renders in the host and can initiate tool calls and update model context from inside the sandboxed iframe. The extension provides iframe sandboxing, pre-declared reviewable templates, auditable JSON-RPC messaging and optional consent for UI-initiated calls — but several of those are host configuration choices. Inventory which tools ship ui:// resources and decide your consent posture explicitly.

MCPOAuthCIMDagent securityenterprise AIidentity

Published

AI-assisted writing · Reviewed by the Twarx research team

Share:
Share

Research digest

AI Research Briefing

Honest insights on AI agents, Small Language Models, and local RAG. No hype. Only when we have something worth sending.

  • No hype, just measurable outcomes
  • Read by 2,400+ engineers
  • Unsubscribe anytime

Continue reading

More from Articles