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

Review · November 20, 2026

OAuth 2.0 Subject-Proof Callers for Token Introspection and Revocation

draft-radusch-oauth-subject-proof -03View on Datatracker →

The Problem

A user signs in to a web app and also connects a few AI agents to the same API. The user expects the web app to show "your connected agents" with a disconnect button next to each one.

OAuth has no way for one client to see or revoke a grant issued to a different client. Token Revocation only lets the client that holds the token revoke it. Token Introspection lets the AS vary its response by caller, but has no concept of "this caller acts for the same user."

This draft lets a client prove it acts for the user, then read or revoke that user's grants to other clients.

How It Fits In

This extends two existing RFCs, RFC 7662 and RFC 7009, with one new request parameter. That fits the OAuth working group's charter.

It has normative dependencies on six RFCs: 6749, 7009, 7662, 8414, 8693 and 9068. It also depends in practice on an individual draft, the OAuth Actor Profile, for the dlg_id grant identifier.

It creates a new relationship between roles. Today a client only has authority over its own tokens. Here, one client gets authority over other clients' grants for the same user.

The draft positions itself against Global Token Revocation, which revokes everything for a user and treats the caller as an administrator. This draft revokes one grant and treats the caller as acting for the user.

How It Works

The proof is an access token the AS already issued to the calling client for that user. The client sends it in a new subject_proof_token parameter, alongside its normal client authentication.

The AS checks that the token is valid, not revoked, issued to the authenticated caller, and not itself a delegated token. That last check stops one agent from disconnecting another agent.

Introspection: the caller sends the target token plus the proof. If both name the same user, the AS returns the full response, including the act claim, the dlg_id, and any user-authored label.

Revocation: the caller sends the proof plus a selector, either dlg_id or act_sub. No token parameter is sent. The AS revokes every token in the matching grant and leaves the user's other grants alone.

Two AS metadata flags advertise support, one per endpoint.

The AS always returns the same response whether the proof was valid or not, so the endpoints don't reveal which grants exist.

Interoperability Concerns

The client has no way to find the grants. Introspection requires the target token. The web app does not have the agent's access token, and the draft never says how it would get one. There is no list operation. The "show connected agents" half of the use case is not actually delivered, and revocation needs a dlg_id that the client can only learn from an introspection it can't perform.

dlg_id is not defined anywhere. The draft says it "is being defined" in the Actor Profile. The cited revision, -01, does not contain it. The preferred selector for revocation has no specification behind it.

The fallback selector is coarse. act_sub revokes every grant for that actor. If the user connected the same agent twice, both go.

Only delegated grants can be selected. The introduction says the mechanism covers connected apps, devices and integrations. Both selectors are tied to the act claim. An ordinary grant to another client with no actor cannot be named.

Which clients can do this is left to policy. Any confidential client holding a user token qualifies by default. The draft only says the AS SHOULD limit this through registration policy. The proof token needs no particular scope. A client the user connected for some unrelated purpose could disconnect a competitor's agent with a guessed act_sub. A required scope on the proof token would give the user and the AS something concrete to grant.

The client can't tell if revocation worked. The AS returns 200 for an invalid proof, an unknown selector, and a success. The user clicks disconnect, sees a confirmation, and the agent keeps running. The draft lists a distinct error as an open issue. It needs one.

It changes RFC 7009 without saying so. RFC 7009 requires the token parameter. This draft removes it for a new request shape on the same endpoint. That is closer to a new operation than an extension, and it deserves an "Updates" header or its own endpoint.

What Could Be Removed

  • The CAEP session-revoked guidance and the paragraphs on delivery guarantees. Signaling revocation to resource servers is a separate problem that applies to all revocation.
  • The discussion of queued operations and the pointer to the revocation closure draft. It is out of scope by the draft's own words.
  • The public client opt-in. The rule is "MUST NOT, unless a deployment opts in," which is a rule with a hole in it.

Writing Quality

The writing is good. Sentences are short and use standard IETF language correctly. At 14 pages it is the right length for what it defines.

Each verification step comes with a reason. The security considerations are specific, and the section on why delegated tokens can't be proofs is the strongest part of the document.

The open issues section is honest about the unresolved parts, including whether to reuse subject_token from RFC 8693.

The gap is in the end-to-end flow. The draft describes each endpoint carefully and never walks through how the web app gets from "user opens the page" to "list of agents on screen."

Author Background

Ilja Radusch (Fraunhofer FOKUS) is a new IETF author. He has no RFCs and no expired drafts. This is his only Internet-Draft.

The draft went through four revisions in two days, with -00 through -02 all posted on November 16 and -03 on November 17.

The draft reports a production implementation in a Fraunhofer FOKUS authorization server, used for a document signing application with AI agent access over MCP.

Bottom Line

The problem is real. Users do expect a "connected agents" screen, and Google, GitHub and Slack all solve it today by hosting that screen at the AS. This draft is for the case where a first-party client wants to embed it.

So is this ready for working group attention? Not yet. The mechanism for proving the caller acts for the user is sound. The missing parts are how the client discovers grants, a defined grant identifier, and a required limit on which clients may use it. Those three decide whether two implementations can interoperate.