The Scope Creep Automated reviews of new AI-related working group submissions

Review · November 10, 2026

User-Mediated Credential Delivery for AI Agents Summary

draft-emerson-oauth-user-mediated-delivery -01View on Datatracker →

The problem

Most MCP servers today are configured with a static API key pasted into an environment variable. The key is long-lived, broadly scoped and hard to revoke.

This draft argues that the OAuth alternatives have their own flaw: the agent starts the flow, and the credential comes back through a redirect or backchannel the agent's platform controls. A prompt-injected agent can start a new authorization request and frame it however it wants.

The proposal is to turn that around. The user goes to the resource application on their own, picks scopes and a duration, and receives a one-time code. The user hands that code to the agent, usually by pasting it into the chat. The agent redeems it for an access token.

How it fits in

This is a response paper to draft-klrc-aiagent-auth, not a protocol spec. Most sections are organized around KLRC section numbers. A second layer maps the proposal to the gaps in draft-chen-oauth-agent-authz-use-cases.

Both of those are individual drafts. The -01 revision already had to renumber every citation because KLRC changed its section numbering.

The draft has "oauth" in its name, but it doesn't reference RFC 6749. The only OAuth RFC it actually uses is Token Introspection. DPoP, mTLS, RAR and RFC 7009 are cited as things it "composes with".

It defines no grant type, no token endpoint parameters and no authorization server metadata. The IANA section is empty.

The roles are different from OAuth. There is no client registration and no client identity. The "resource application" is the authorization server, resource server and consent UI in one. Whoever holds the pasted code is the client.

Is the idea new? Not really. A user-generated, scoped, expiring credential is a GitHub fine-grained personal access token. A one-time code issued first and redeemed at a token endpoint is the pre-authorized code flow in OpenID for Verifiable Credential Issuance. The Device Authorization Grant is the same shape with the code traveling in the other direction.

The methods are patent pending. The draft says so in the abstract and points to IPR disclosure 7378.

What it actually describes

Four "methods", all in prose:

  • User-mediated delivery. The user signs in to the resource application, chooses scopes, duration and optional call-count ceilings, and optionally signs the grant with a passkey. The application shows a one-time credential that lives for minutes. The user gives it to the agent. The agent exchanges it for an access token with no refresh path.
  • Self-describing credentials. The credential embeds the base64url-encoded URL of the exchange endpoint, so the agent needs no prior knowledge of the application.
  • Caller-identity consent differentiation. The application sorts callers into classes (human session, the platform's own AI, external agents) and keeps a separate consent setting for each.
  • Discovery-by-introspection. The exchange and introspection responses include the list of endpoints and request body schemas the token is allowed to use.

Two additions in -01 are the more interesting parts.

Per-action confirmation: a scope can be marked confirm-each-time. The call is held, the user approves that exact request by digest with a passkey in their own context, and the agent retries.

Intent recording: the application's declared purpose and the user's own description of what they want are stored with the grant as audit evidence. Neither is used for policy. This is positioned as an alternative to draft-chen-oauth-agent-intent-token, where an authorization server interprets the intent.

Every API call is validated by introspection, which is how revocation takes effect immediately.

Significant interoperability concerns

Nothing here can be implemented from the text. Two implementations would share a concept and no wire format.

  • The exchange is undefined. No request format, no response format, no error codes. It isn't defined as an OAuth grant type, so no existing client library can call it.
  • The credential format is an example. It's introduced with "in one implementation", and the prefix is unspecified. An agent can't parse a credential from a vendor it hasn't seen, which is the one thing the format is for.
  • Endpoint validation has no mechanism. The draft says agents MUST validate that the decoded URL is "a legitimate exchange endpoint". It also says the agent needs no prior knowledge of the application. Those two statements conflict. This is a real attack vector: an attacker hands the user a credential that points at the attacker's server, and the agent follows it.
  • Introspection is redefined. RFC 7662 is a read-only call made by a resource server. Here the agent calls it, it returns API schemas, it enforces rate ceilings and it stages pending confirmations. None of the new response members are defined.
  • Step-up and confirmation are narrative. The missing-scope error, the "attestation identifier" the agent retries with, the digest computation and the way the user gets notified are all unspecified. RFC 9470 already defines a step-up challenge and isn't mentioned.
  • The metadata has no schema. "Filtered endpoint map" and "field-level request body schemas" overlap with OpenAPI and MCP tool listings. No format is given.

The security argument also needs work.

The draft treats the redirect URI as an agent-controlled channel. A registered redirect URI with PKCE and client authentication is the binding between the user's approval and a specific client. This flow removes that binding. The connection credential is a bearer secret with no client attached, and the default delivery method is pasting it into a chat window, where it lands in model context and conversation logs. KLRC section 8 says the model must not see credentials. The draft's answer is that the credential is short-lived, plus an alternate path of putting it in a config file, which is the practice the introduction set out to replace.

The prompt injection claim is narrower than it sounds. An injected agent can't start a grant. It can still tell the user "I need write access, please go create a connection and paste the code here." Teaching users to paste secrets into chat is the habit phishing depends on.

Mechanisms that could be removed

  • Caller-identity consent differentiation. This is internal policy at the resource application. Nothing crosses a boundary between two parties. Classifying callers by "token format prefix" or "signing algorithm" is an implementation detail, and an odd one.
  • Discovery-by-introspection. API description is a separate problem with existing solutions.
  • Mandatory per-call introspection. How a resource server validates tokens is a deployment choice. It only looks like protocol here because the AS and RS are the same application.
  • Hash-chained audit exports, presence ceremony evidence tiers, call ceilings. Product features. None affect what the agent sends or receives.
  • Section 10. Fourteen paragraphs restating the proposal against each KLRC section. Several overreach, such as claiming to replace cross-domain token chaining with a manual copy-paste per application.

What's left that could be standardized? A grant type for redeeming a user-delivered one-time code, a metadata parameter to discover it, and possibly a per-request confirmation challenge. That would be a short OAuth extension draft and a much easier conversation.

Writing quality

The prose is clean and grammatical. The numbered flow in section 4 is easy to follow.

It doesn't read like an IETF spec. There are no HTTP examples, no parameter tables and no ABNF. All normative keywords sit in Security Considerations, attached to behaviors the body never defines.

It reads like product positioning. "The authorization layer becomes infrastructure, not a feature. User-mediated delivery provides that infrastructure." The Implementation Status section is a single sentence of about 150 words listing the features of the author's hosted service, which the draft notes is proprietary. The statistics in the introduction come from the author's own company blog.

The draft doubled from 11 pages to 21 between -00 and -01. The growth is mapping tables and feature descriptions, and no wire-level detail was added. The same points about CIBA being "reactive" and the redirect being "automated" are made four or five times.

The security section is the most honest part. It admits "the human hop has its own risks" and that tying an approval to what the user actually saw "remains an open problem".

Background of the author

I couldn't reach Datatracker from this session, so this comes from the local draft corpus.

Christopher Emerson (AgentAdmit) is the sole author. This is the only draft under his name in the corpus, with -00 in July 2026 and -01 in October. I found no RFCs and no other drafts, which points to a new IETF author. That needs confirming on Datatracker.

He is active on the list. Both the Chen use cases draft and the intent token draft thank him for feedback, and -01 is clearly written in response to those discussions.

He runs AgentAdmit, the commercial service the draft describes, and holds the pending patent application. I haven't seen the licensing terms declared in IPR disclosure 7378. Anyone considering this work should read it first.

Questions worth raising

  • What are the licensing terms in the IPR disclosure, and do they cover a one-time code exchange that looks a lot like the OID4VCI pre-authorized code flow?
  • Why not define this as an OAuth grant type with RFC 8414 metadata, so existing clients and authorization servers can implement it?
  • How does an agent validate the exchange endpoint in a credential from an application it has never seen?
  • With no client identity, how does the resource application know which agent redeemed the code, and how does the user know what they are revoking?
  • Is pasting a bearer credential into a chat safer than a redirect bound to a registered client with PKCE and DPoP?
  • Could per-action confirmation be split out and specified against RFC 9470 and RAR? It's the part of this draft that addresses a gap KLRC actually names.