Post

MCP Can Name the User, the App or the Workload. Not Yet the Agent.

MCP's roadmap makes agent identity a priority because its authorization assumes a person with a browser. Here is what each shipped and proposed mechanism actually proves, read from the specs and the open SEPs, and what is still missing.

MCP Can Name the User, the App or the Workload. Not Yet the Agent.

On 22 August 2026 the MCP maintainers published a new roadmap with five priority areas. The third, “Agent Identity and Enterprise-Ready Security,” opens with the best one-paragraph description of the problem I’ve read:

MCP authorization assumes a person with a browser at consent time. Increasingly the caller is an agent: a cloud workload with its own identity, acting for a user who isn’t present, or spawning sub-agents that should get narrower authority than their parent.

The roadmap names the work: finalize DPoP, and build “an opinionated way for MCP servers to be reached by agents through their own identity or a user-delegated identity” out of Workload Identity Federation, the Identity Assertion JWT Authorization Grant (ID-JAG) behind Enterprise-Managed Authorization, and RFC 8693 token exchange. All of it goes to an Agent Identity Working Group that is “forming during this roadmap period.”

That’s a lot of acronyms for one sentence of intent. So I read each mechanism from its spec or SEP and asked the same question every time: when an MCP server receives this token, who does it actually identify?

Short version: the user, the app, or the workload. Pick one, sometimes two. Never the agent acting for an absent user.

What the core specification does today

The 2026-07-28 authorization specification is OAuth 2.1 with a selected set of extensions. An MCP server is a resource server. An MCP client is an OAuth client “making protected resource requests on behalf of a resource owner.” The token names two things.

The first is the user. A person logs in through a browser and approves access, and the token’s subject is that person.

The second is the client software. The preferred registration path is now a Client ID Metadata Document, where the client’s identifier is an HTTPS URL pointing to a JSON description of the client. Dynamic Client Registration is deprecated in this revision. Either way, the identifier names an application, so every running copy of the same client presents the same client_id.

Two rules stop the token from being reused elsewhere. Clients MUST send an RFC 8707 resource parameter naming the target server, and servers “MUST validate that access tokens were issued specifically for them as the intended audience.” Servers also “MUST NOT accept or transit any other tokens,” which rules out passing a user’s token straight through to an upstream API.

What the token doesn’t name is the running agent. Two agent instances working for the same user through the same client look identical to the server. And it’s a bearer token: whoever holds it can use it until it expires.

Enterprise-Managed Authorization: the employer decides

Enterprise-Managed Authorization (EMA) is the one agent-relevant piece that’s already stable. The extension specification was promoted to stable on 17 June 2026 and follows version 04 of the IETF ID-JAG draft. On 23 October it was published as a dated revision, 2026-07-28, matching the core specification.

The flow puts the company identity provider between client and server. The employee signs in to the MCP client through corporate SSO. The client exchanges the resulting ID Token at the identity provider for an ID-JAG, a short-lived signed assertion addressed to the MCP server’s authorization server (the spec’s example uses a 300-second lifetime). Before issuing it, the identity provider checks administrator policy: group membership, role, which clients may act for which users on which servers. The MCP server’s authorization server then trades the ID-JAG for an access token “audience-restricted to the MCP Server.”

For governance this is a real step forward. Access policy lives in one place, and disabling an employee at the identity provider cuts off every MCP server at once. But look at what the token identifies: the employee as sub and the client application as client_id. Same two things as before.

The ID-JAG draft (draft-ietf-oauth-identity-assertion-authz-grant-04, May 2026, Parecki, McGuinness and Campbell) does include an AI agent example in Appendix A.4. There, the agent is an OAuth client that both the identity provider and the tool’s authorization server recognize “as a trusted client,” and the user first establishes their identity with the enterprise IdP. After that, the agent “can first attempt to silently obtain an access token” with an ID-JAG. So the user doesn’t have to be present for each tool call. An interactive login still starts the chain.

The draft also lets a token exchange request carry an actor_token, which could put the agent into an act claim. Section 9.7 is careful here. The specification “allows Token Exchange requests for ID-JAG to carry actor_token, but it does not define normative processing requirements for it,” and it warns that “a client could attempt to combine a valid subject_token with an unrelated or less-trusted actor_token to obtain an ID-JAG that overstates the actor’s authority.” That is the delegation chain splicing problem reported on the OAuth working group list in February 2026, now sitting in the draft’s security considerations. The actor slot exists. How to fill it safely is left to future profiles.

Client credentials: the agent as an application

The ext-auth repository also holds an OAuth Client Credentials extension for “machine-to-machine authentication without user interaction.” It moved from draft to stable on 23 October 2026. The client is pre-registered out of band and authenticates with a signed JWT (recommended) or a client secret.

That gets an agent a token with no user involved. But it identifies a registration, not a workload. Somebody creates that credential and then has to store and rotate it, and we know how that usually goes. The core spec also treats these clients differently on scope errors: clients acting on their own behalf “MAY attempt the step-up authorization flow or abort the request immediately.”

Workload Identity Federation: the platform vouches

SEP-1933, opened by Pieter Kasselman on 5 December 2025 and still in Draft status, gets rid of the stored credential. A workload already holds a short-lived JWT from its platform: a Kubernetes service account token, a SPIFFE JWT-SVID, a cloud workload token. The client presents that JWT to the authorization server as an RFC 7523 JWT bearer grant, with resource naming the MCP server. The authorization server finds the issuer’s keys through OpenID Connect Discovery, validates the JWT, and issues an access token.

The SEP is explicit that this rests on two separate trust decisions. Issuer trust decides whether JWTs from a platform are accepted at all, and “changes to issuer trust affect all workloads associated with that issuer simultaneously.” Workload trust decides whether the specific workload named in the JWT gets a token. The SEP says the two “SHOULD be managed independently.”

Its security section points at the place this goes wrong: “The translation of workload JWT claims to MCP server access tokens represents a critical trust boundary.” For multi-tenant platforms, it says authorization servers should rely on issuing keys bound to a single tenant and should “NOT solely rely on JWT claims that can be controlled by any tenant.” It’s the same trap as caller-asserted session tags in cloud IAM, which I covered in the agent identity gap analysis. An expressive claim the caller controls isn’t a control.

Workload Identity Federation does name the running workload. The SEP says the flow “eliminates the need for client secrets, client identifiers, or separate credential management,” so there’s no separate client software identity, and there’s no user. And the access token at step 10 of the SEP’s flow is still sent with the Bearer scheme.

DPoP: binding, not identity

SEP-1932, also by Kasselman and also in Draft, adopts RFC 9449 DPoP and deliberately defines no extensions to it. The client holds a key pair, the access token is bound to the public key’s thumbprint, and every request carries a fresh signed proof. A stolen token is useless without the private key.

The SEP is precise about what that doesn’t buy you. On client compromise: “If an attacker gains full access to the client system, they can access the private key and generate valid proofs.” On authorization: “DPoP binds tokens to clients but doesn’t address confused deputy or privilege escalation vulnerabilities.” DPoP answers “is this the party the token was issued to?” It doesn’t answer “who is that party?” or “should it be doing this?”

Stateless servers get specific guidance. A server that can’t track proof identifiers enforces an iat window of plus or minus five minutes, and can add a server-supplied nonce, such as an encrypted timestamp, to force fresh proofs. That matters more than it used to, because the 2026-07-28 revision removed protocol-level sessions and made MCP stateless, so plenty of servers now keep no per-client state at all.

Implementation is running ahead of the spec. The official TypeScript SDK added client-side DPoP in @modelcontextprotocol/client 2.1.0 on 23 September 2026 (PR #2629), with the changelog line “Add DPoP (RFC 9449 / SEP-1932) sender-constrained access token support to the client.” It’s opt-in, and “Tokens the AS issued as Bearer are still presented as Bearer.” So if a vendor post tells you DPoP “shipped in MCP,” this is what shipped: SDK support for a draft extension.

The extension text is catching up. In October the normative wording started moving into the ext-auth repository, driven by conformance-suite feedback: one open pull request (#33) adds server requirements, including protection against downgrading a DPoP-bound token to the Bearer scheme, and another (#36) profiles the token endpoint and client-side nonce retries. Neither had merged when I checked again on 4 November. Two more have joined them: #35 (12 October) recommends binding the authorization code to the DPoP key with dpop_jkt, and #38 (23 October) would mark DPoP as an experimental extension, the same day Client Credentials went stable.

The matrix

Five MCP authorization mechanisms against four properties: naming the user, the client software, the running workload, and binding the token to a key. No mechanism covers the user and the workload together.

Each mechanism names part of the caller. None names an agent acting for a user who is not present.

Read the rows together and the gap is obvious. The mechanisms that name the user assume that user logged in. The mechanisms that name the workload drop the user. Key binding sits beside both and names nobody.

If you compose the pieces the roadmap lists, you get something like this.

Four steps: platform issues a workload JWT, the authorization server checks issuer and workload trust, issues an audience-bound and key-bound token, and the server checks audience and DPoP proof. Not proven: the user, the task, sub-agent narrowing.

Workload Identity Federation plus DPoP proves which workload is calling and that it holds the key. It says nothing about the user or the task.

The missing link is token exchange. RFC 8693 lets the agent present a user’s token as subject_token and its own workload credential as actor_token, and get back a token whose sub is the user and whose act is the agent. That’s exactly the step ID-JAG section 9.7 declines to specify, and exactly where splicing lives. The roadmap lists RFC 8693 as part of the work, coordinated with the IETF OAuth and WIMSE working groups.

What the roadmap leaves open

Three things show up in the roadmap as goals or as “under discussion,” with no mechanism yet.

Sub-agent narrowing

The roadmap says sub-agents “should get narrower authority than their parent.” None of the four mechanisms can express that. A sub-agent handed its parent’s token holds its parent’s authority.

Human-presence attestation

The roadmap lists “human-presence attestation for distinguishing interactive clients from headless agents” among topics that “may come into scope as the Working Group forms.” Today an MCP server can’t tell whether a request came from a person at a keyboard or an agent loop running unattended under that person’s token. For a tool that sends money, deletes data or changes access, that’s the distinction the server needs most, and it doesn’t have it.

Who holds the key

DPoP keys and workload credentials are only as strong as the process holding them. The IETF agent identity framework, draft-ietf-wimse-aims-00, is direct: “The Large Language Model MUST NOT have access to an agent’s credentials.” MCP doesn’t say this anywhere yet. A harness that leaves a DPoP key or workload token in a file the model can read through a filesystem tool has turned sender-constraining back into a bearer token with extra steps.

What to do while the working group forms

  1. Turn on audience validation, then test it. Send a token issued for one of your MCP servers to another one and confirm it’s rejected. This is core-spec behaviour and the cheapest test in this article. (The TypeScript SDK’s server side gained an optional expectedResource check in 2.3.0 for exactly this.)
  2. Prefer platform identity to stored credentials. If your agents run on Kubernetes or a major cloud, the workload JWT already exists. Even before SEP-1933 is final, an authorization server that accepts RFC 7523 grants from your cluster’s issuer removes a whole class of long-lived secrets.
  3. Keep issuer trust and workload trust separate. Trusting your cluster’s issuer shouldn’t mean every pod in the cluster can reach every MCP server. Write the per-workload allowlist SEP-1933 asks for.
  4. Pilot DPoP where tokens live long. The TypeScript client support is opt-in and falls back to Bearer, so a pilot costs little. Pair it with a check that the key is out of the model’s reach.
  5. Log which agent instance acted. Until tokens can name the agent, your harness can. Record the workload identity, the user and the task next to every tool call. It’s the first thing an incident review will ask for.

The Agent Identity Working Group is forming now, and the two SEPs it inherits are moving at different speeds. SEP-1932 was revised on 16 October, after implementers ran it against the conformance suite. SEP-1933 hasn’t changed since 12 January, and the SEP bot has asked its sponsor for an update every few weeks since April, most recently on 2 November. Implementer reports and concrete attack cases are what move SEPs from draft to final, and the contributor channels are open to anyone.

Primary sources

MCP specification and proposals

IETF

Earlier in this series

The Security Lab Newsletter

This post is the article. The newsletter is the lab.

Subscribers get what doesn't fit in a post: the full attack code with annotated results, the measurement methodology behind the numbers, and the week's thread — where I work through a technique or incident across several days of testing rather than a single draft. The RAG poisoning work, the MCP CVE analysis, the red-teaming patterns — all of it started as a newsletter thread before it became a post. One email per week. No sponsored content. Unsubscribe any time.

Join the lab — it's free

Already subscribed? Browse the back-issues →

This post is licensed under CC BY 4.0 by the author.