Four RFCs for Agent Auth. The MCP Spec Names Three of Them.
I slotted this post in April on the strength of something I brought home from a conference: MCP mandates four RFCs. I read the spec before writing a word, and it doesn't. The four I'd written down were 9728, 8414, 7591
I slotted this post in April on the strength of something I brought home from a conference: MCP mandates four RFCs. I read the spec before writing a word, and it doesn't.
The four I'd written down were 9728, 8414, 7591 and 8693. In the MCP authorization spec (version 2026-07-28), 9728 is a MUST. 8414 is a MUST unless the authorization server offers OpenID Connect discovery instead. 7591, dynamic client registration, is a MAY and labeled deprecated. And 8693, token exchange, doesn't appear in the core authorization spec at all.
(Yes, RFC meant "request for change" in an earlier post of mine. Here it means the IETF kind, every time.)
The four I'd name now are 9728, 8414, 8707 and 8693. The spec requires the first three one way or another. The fourth is the one an agent chain needs, and you're on your own for it.
MCP's official enterprise extension does use 8693, at the front door: it turns a corporate SSO login into a grant the MCP server's authorization server accepts. That gets the user into the MCP server. It says nothing about the next hop.
The hop where identity gets lost
Say an agent answers "which invoices are overdue?" It calls an MCP server for the billing system, and that server calls the billing API. The chain runs user, identity provider, agent, MCP server, API. Standard OAuth handles the first legs fine. Then the MCP server has to call the billing API, and the API has to answer a question it was never built to ask: who is acting, and for whom?
The MCP server has three options.
It can forward the user's token. The spec forbids this: MCP servers "MUST NOT accept or transit any other tokens." A token minted for the MCP server shouldn't work on the billing API, and if it does, the API can't tell the server's calls from the user's own.
It can use its own credential, a client-credentials grant. That works. MCP even has an official client-credentials extension, though it covers machine clients calling an MCP server, one hop earlier. The billing API now sees the MCP server for every request, whoever asked. The audit log says "the MCP server did it" on every line, and the server typically holds standing access broad enough for every user it serves.
Or it can exchange the user's token for a new one scoped to the billing API. That's RFC 8693.
The four, in the order a request meets them
Agent MCP server Auth server Billing API
| call, no token | | |
|--------------------->| | |
| 401 + resource_metadata (RFC 9728) | |
|<---------------------| | |
| fetch server metadata (RFC 8414) | |
|------------------------------------------->| |
| authorize, resource=MCP server (RFC 8707) | |
|------------------------------------------->| |
| token, aud=MCP server | |
|<-------------------------------------------| |
| call with token | | |
|--------------------->| | |
| | exchange: subject=user token, |
| | actor=MCP server, resource=billing |
| | (RFC 8693) | |
| |-------------------->| |
| | token, aud=billing API, act=MCP server |
| |<--------------------| |
| | call with exchanged token |
| |------------------------------------------>|
RFC 9728 lets the MCP server say where its authorization server lives. Without it, someone configures that by hand for every server an agent might ever touch. RFC 8414 lets the authorization server publish its own endpoints, so the agent doesn't hardcode them either.
RFC 8707 is the one my list skipped. The client names the resource the token is for, on both the authorization request and the token request, and the server checks the audience when the token comes back. That check is what keeps a token minted for the MCP server from working on the billing API. The spec makes the client send the parameter whether or not the authorization server supports it.
Those three are discovery and audience. They tell the agent where to go and keep each token on the resource it was minted for. None of them carries identity across a hop. RFC 8693 does.
What 8693 gives you
The RFC separates two things that sound alike. Impersonation makes A indistinguishable from B. Delegation keeps A's identity and records that "any actions taken are being taken by A representing B." The exchanged token carries the user as the subject and the MCP server in an act claim. Log the subject and the actor on every exchange and the audit trail answers the invoice question: who acted, and for whom.
It also nests. A chain of three agents produces an act inside an act inside an act. If the agent in the invoice example had itself been acting for a planner agent, the billing API would get this:
{
"sub": "user-1234",
"aud": "https://billing.example.com",
"act": {
"sub": "mcp-billing",
"act": { "sub": "agent-planner" }
}
}
The billing API sees the user, the MCP server acting now and, nested inside, the agent that acted before it.
What it doesn't give you
The nesting has a catch. The RFC says a token's consumer "MUST only consider the token's top-level claims and the party identified as the current actor." Prior actors in the nested claims are informational only. So the billing API can enforce on the user and the last agent. It can't deny a request because agent one, three hops back, was never allowed near billing. That enforcement has to happen at the exchange, in the authorization server's policy, and the RFC leaves that policy out of scope. Every deployment writes its own.
Support is uneven too. As of November 2026, Tyk's documentation says Entra rejects the RFC 8693 grant outright with unsupported_grant_type and offers its own On-Behalf-Of flow, built on the RFC 7523 JWT bearer grant with a Microsoft parameter on top. If your identity provider is Entra, you have the capability without the standard interface, and anything written to 8693 needs an adapter.
What a platform team builds
This is the other 80% again. Nobody ships these RFCs. A platform team ships the thing that implements them, and for an agent chain that is a token exchange service: one place that decides which agents may trade whose tokens for which audiences, keeps lifetimes short and logs subject, actor, audience and scope on every trade.
AIEOS does the workload half of this. Its CI signs conformance attestations with GitHub's OIDC token, keyless, so no signing key sits anywhere an agent could read it. It doesn't do the delegation half. Nothing I've built in the framework carries a user's authority down a chain of agents, and I'd rather say so than imply a layer I haven't built. I'm writing this from the specs and a conference talk at AI Dev 26 in April, not from a deployment.
If you're about to put agents in front of corporate data, find out first whether your identity provider will do 8693. If it won't, the exchange becomes your problem, and it's cheaper to learn that before an agent is already three hops deep.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.