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

Review · November 20, 2026

Security Events for Revocation of Agent Delegations

draft-nandakumar-oauth-delegation-revocation -00View on Datatracker →

The Problem

Agents delegate to other agents, and each hop gets its own token. Revoking one token in the middle does nothing to the tokens issued below it.

Token Status List and introspection only answer "is this one token valid?" for a verifier that asks. They don't tell the agents further down the chain to stop working. The revoking party often doesn't know who those agents are.

This draft defines a "delegation revoked" Security Event Token that revokes a token and everything delegated from it. It also defines how the event is passed down the chain, and a pull-based fallback so revocation still lands when the event gets lost.

How It Fits In

This is two specs in one document.

The first is a new SET event type and a new subject identifier format. That builds on RFC 8417 and RFC 9493. Security event types are mostly defined in the OpenID Shared Signals working group today, as CAEP and RISC events. The draft registers its event under the OAuth URN namespace instead.

The second is a set of new requirements on verifiers and on authorization servers doing Token Exchange (RFC 8693). An AS must record which tokens each exchanged token came from and cascade revocation to them. That part fits the OAuth charter and changes AS behavior for an existing RFC.

It depends normatively on Token Exchange, SET, Subject Identifiers, RFC 7800 (cnf), and the Token Status List draft. It also has a normative reference to draft-asor-wimse-agent-delegation-chain, an individual WIMSE draft. The key resolution rules lean on a second individual draft from the same authors, draft-nandakumar-wimse-delegator-bound-chains.

It adds no new endpoints. It adds new relationships: token holders become SET transmitters and receivers, and every delegator is responsible for notifying the agents it delegated to.

It doesn't cite Global Token Revocation or draft-chen-oauth-agent-revocation, which also defines cascading revocation for agents. It does position itself against Revocation Closure: this draft invalidates tokens and makes no claim that the work has stopped.

Summary of the Mechanism

Revocation travels two ways. A verifier only needs one of them to work.

Push, down the chain.

  1. A party entitled to revoke signs a SET naming one token by its iss and jti. It also revokes the token in its status mechanism.
  2. Four kinds of party can revoke: the token's issuer, the issuer of any ancestor token, a party designated by the root issuer, and the holder giving up its own delegation.
  3. Each holder that receives the event stops acting under the token. It wraps the original signed SET inside a SET of its own and sends it to every agent it delegated to.
  4. At a trust boundary, the AS does not relay the original. It issues fresh events naming only its own tokens, so downstream parties learn nothing about tokens upstream.

Pull, at the verifier.

A verifier must check the status of every token in the chain, not only the one presented. It must set a staleness bound and reject requests when its status answers are older than that.

So what about plain Token Exchange, where the resource server only sees the last token? The AS takes the verifier's place. It records the (iss, jti) of the subject and actor tokens for everything it issues. When one of those is revoked, it revokes everything issued from it. For tokens from another issuer, it polls their status.

The push path is fast and depends on every holder cooperating. The pull path is slower and depends on nobody in the middle.

Interoperability

The event format is clear. Two implementers would produce the same SET. The problems are in getting it delivered and getting it verified.

Significant interoperability concerns

There's no way to find where to send the event. A holder is identified by the key in cnf. Nothing in the draft maps that to a SET receiver endpoint. Delivery can be push, poll, a Shared Signals stream, or "the messages of the application protocol". Two agents from different vendors have no common way to relay an event, and the relay is the main new feature.

Key resolution is underspecified. A receiver accepts the event if it "verifies under a key of" an authorized party. For an AS, the draft doesn't say how to get from the SET's iss to a key. For an agent delegator, the key comes from the parent token's cnf, which only works for the delegator-bound chain format. It doesn't say which key signs the relaying wrapper either.

Ancestor revocation doesn't work for Token Exchange tokens. A receiver resolves the ancestor's key "from the chain it holds". A holder of an exchanged access token holds no chain. The draft says such a receiver ignores the event. The push path then depends entirely on every AS re-issuing its own events, which is only a SHOULD.

Designated revokers are out of scope. The party most likely to revoke in an enterprise deployment is a central security service acting for the root issuer. How receivers learn who that is, "is outside this document".

The original SET's aud is never addressed. The original names the first holder as its audience. Every downstream receiver validates a SET addressed to someone else. The draft needs to say that this is expected.

Relay checks are incomplete. The receiver must check that the wrapper's sub_id equals the original's. Nothing says to check revoked_at, or which value wins if they differ. Nothing says what a revoked_at in the future means.

The AS cascade requirement is large. "MUST revoke every token it issued from that token, directly or indirectly" requires a lineage store for every exchanged token. It also assumes those tokens have a jti and a status mechanism. Many deployments issue short-lived exchanged tokens with neither, and status mechanisms are only a SHOULD here.

Holder self-revocation overlaps RFC 7009. When the issuer is an AS, a holder giving up its token already has the revocation endpoint. The draft doesn't say when to use which.

Mechanisms that could be removed

The chain status rules for verifiers. Checking every token in a chain and bounding staleness are rules for validating delegation chains. They belong in the delegation token draft and work without the event. Moving them out would leave this as a short event definition.

The Roughtime paragraph. Clock trust is a general deployment concern.

"MUST stop work". A holder's obligation to end work and dialogs can't be tested on the wire. It reads better as guidance.

The reason values. They are a fixed list with no registry and no processing difference between them. Either drop them or point at the CAEP conventions.

The relay wrapper. The wrapper "tells the receiver that the event reached it through its delegator", but no processing rule uses that fact. Forwarding the original SET unchanged would be simpler, if the aud question is answered.

Writing Quality

The writing is good. Sentences are short and plain, normative keywords are used carefully, and the examples are valid.

It is concise at about twelve pages of content. The Overview diagram and the three-step summary make the design easy to follow.

The security considerations are honest. They state plainly that a holder who doesn't relay leaves its delegatees working, and they bound the exposure in concrete terms: publication delay plus staleness bound.

The brevity hides gaps. The sections on who may revoke and on delivery each defer the hard part to configuration or to other documents. The term "delegation token" covers three very different credential formats, and the rules only fully work for one of them.

Authors

Suhas Nandakumar (Cisco) has 9 published RFCs from 2013 to 2025, all in real-time media: STUN and TURN URI schemes, RTP taxonomy, SDP and ICE. He has 36 active Internet-Drafts. Most are Media over QUIC. About ten are recent OAuth, WIMSE, and AGENTPROTO drafts. He is an experienced IETF author who is new to OAuth and writing at high volume right now.

Cullen Fluffy Jennings (Cisco) has 29 published RFCs from 2002 to 2026, including SIP identity (RFC 3325, RFC 4474), NAT behavior (RFC 4787), and JSEP for WebRTC (RFC 8829). He has 30 active Internet-Drafts, with the same split: mostly Media over QUIC plus the same set of agent, OAuth, and WIMSE drafts co-authored with Nandakumar. He is a long-time IETF contributor, also new to the OAuth working group.

This draft is one piece of a larger set from the same two authors. It relies on their delegator-bound chains draft in WIMSE for the key resolution rules.

Bottom Line

The design instinct is right: push for speed, pull for safety, and never make the verifier depend on the push. The lineage requirement on token exchange is the most deployable idea here, and it would be useful without the event.

So what's missing? The push path has no receiver discovery, no defined key resolution for AS-issued tokens, and no defined way to name a designated revoker. Until those exist, the event is a format without a protocol.

The draft would be easier to progress as two pieces. One is the token exchange cascade rule for the OAuth working group. The other is the event type, written with the Shared Signals community and aligned with Global Token Revocation.