| Internet-Draft | Delegation Revocation Events | November 2026 |
| Nandakumar & Jennings | Expires 23 May 2027 | [Page] |
When a person withdraws a task from an agent, or a delegating agent is compromised, every credential delegated below that point has to stop working, and the agents holding those credentials have to stop the work they were doing under them. Token status lists and token introspection tell a verifier that asks whether one token is still valid. They do not tell the agents further down a delegation chain, which may be in other organizations and which the revoking party may not know. This document defines a Security Event Token that revokes a delegation and everything delegated from it, a subject identifier format that names a delegation token, the parties entitled to issue the event, how agents propagate it down the chain, and how verifiers check the status of a whole chain so that revocation reaches them even when the event does not.¶
This note is to be removed before publishing as an RFC.¶
Status information for this document may be found at https://datatracker.ietf.org/doc/draft-nandakumar-oauth-delegation-revocation/.¶
Discussion of this document takes place on the Web Authorization Protocol Working Group mailing list (mailto:oauth@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/oauth/. Subscribe at https://www.ietf.org/mailman/listinfo/oauth/.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 23 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
Agents delegate to agents. A user's assistant delegates a task to a
planning agent, which delegates parts of it to agents run by other
organizations, which delegate again. Each hop is represented by a
credential: a token issued by an authorization server with an act
claim [RFC8693] [ACTOR-PROFILE], a Delegation Token
[DELEGATION-TOKENS], or a Delegate SD-JWT [DELEGATE-SD-JWT].¶
Revocation has to reach the whole subtree below the revoked hop:¶
The revoking party knows the hop it is revoking, but in peer delegation it does not know the agents further down, which were chosen by the agents it delegated to.¶
A verifier that caches a chain may hold a status answer for a token for its time to live, so that a revoked token remains usable for that window (Section 9.5 of [DELEGATION-TOKENS]).¶
An agent that holds a revoked delegation is in the middle of work. Learning about the revocation only when its next request is denied leaves work running, and children of its own still delegated.¶
Shared Signals [SSF] and CAEP [CAEP] push events about sessions, credentials, and accounts, and [AIMS] describes their use for agents. No event type identifies a delegation, and none states that its effect extends to every token delegated from it.¶
This document defines:¶
the delegation subject identifier format (Section 3), which names
a delegation token by its issuer and identifier;¶
the delegation revoked event (Section 4), a Security Event Token [RFC8417] whose effect is the revocation of the named token and of every token whose chain contains it;¶
how receivers act on it and pass it on to the holders of tokens they delegated (Section 6); and¶
how verifiers check the status of a whole chain, so that revocation reaches them even when a party in the middle of the chain does not relay the event (Section 7).¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
A credential that conveys authority from a delegator to a delegatee,
such as an access token with an act claim, a Delegation Token
[DELEGATION-TOKENS], or a Delegate SD-JWT [DELEGATE-SD-JWT].¶
The sequence of delegation tokens from the root grant to a given token. For tokens issued by token exchange, the chain is the sequence of tokens exchanged one for the next, possibly at different authorization servers.¶
A token whose chain contains a given token, other than that token.¶
The party whose key a delegation token's cnf claim [RFC7800]
confirms.¶
Revocation travels two ways, and a verifier needs only one of them to work:¶
Revoking party Status mechanism
(issuer, ancestor, designee, holder) of each token
| ^
| (1) delegation revoked event | (3) status of every
v | token in the chain
Holder --(2) relays, wrapped--> Holder --> ... Verifier
stops work stops work
A party entitled to revoke (Section 5) issues a delegation revoked event naming one token, and revokes the token in its status mechanism (Section 6.1).¶
Each holder stops acting under the revoked tokens and relays the event, with the original signature, to the holders of the tokens it delegated (Section 6.3, Section 6.4). This is fast, but depends on every holder.¶
Verifiers check the status of every token in the chain, within a staleness bound (Section 7). This is slower, but depends on no holder, and bounds how long a revocation can go unnoticed.¶
The delegation subject identifier format identifies one delegation
token. A subject identifier in this format is a JSON object with these
members:¶
REQUIRED. delegation.¶
REQUIRED. The iss claim of the token.¶
REQUIRED. The jti claim of the token.¶
Other claims of the token, such as a context claim [AGENT-DELEGATION], are not included: a holder of the token already has them, and they would reveal the token's purpose to a party that does not.¶
{
"format": "delegation",
"iss": "https://planner.example",
"jti": "dt-7f3a9c"
}
¶
A token is identified by the pair (iss, jti). Issuers of delegation
tokens that are to be revocable with this document MUST include jti
and MUST NOT reuse a jti.¶
The event type is:¶
urn:ietf:params:oauth:event-type:delegation-revoked¶
The SET [RFC8417] is signed with JWS [RFC7515], has typ
secevent+jwt, and carries iss, iat, jti, aud, events, and
sub_id [RFC9493], a subject identifier in the delegation format
(Section 3) that names the revoked token. Its iss is the party
revoking the token (Section 5), or, when relayed, the holder that
relays it (Section 6.4).¶
The event payload is a JSON object with these members:¶
REQUIRED. A NumericDate [RFC7519] from which the token and its descendants are revoked.¶
OPTIONAL. One of principal_request (the principal withdrew the
task), task_complete, compromise (a key or agent in the chain is
believed compromised), or policy. Receivers MUST ignore values they
do not recognize.¶
OPTIONAL. The original SET, in JWS Compact Serialization, when this SET relays it (Section 6.4).¶
{
"iss": "https://assistant.example",
"iat": 1794643200,
"jti": "set-0b51",
"aud": "https://planner.example",
"sub_id": {
"format": "delegation",
"iss": "https://assistant.example",
"jti": "dt-41c2"
},
"events": {
"urn:ietf:params:oauth:event-type:delegation-revoked": {
"revoked_at": 1794643200,
"reason": "principal_request"
}
}
}
¶
The effect of the event is the same as revoking, through the token's own status mechanism, the named token and each of its descendants. A revocation cannot be undone; a delegator that wants to restore authority issues a new token.¶
The event supplements the token's status mechanism (Section 7), such as a Token Status List [STATUS-LIST]; it does not replace it. A party that issues the event and is also the issuer of the named token, or operates its status mechanism, MUST also revoke the token there, so that verifiers that miss the event still learn of the revocation within their staleness bound. Any other issuer of the event (Section 5) SHOULD also send it to the issuer of the named token, which then MUST revoke the token in its status mechanism.¶
An issuer that issues an event for a token it issued, or receives one, SHOULD send it to the verifiers that subscribe to its events (Section 6.5).¶
A verifier, such as a resource server or an enforcement point, that receives a valid event:¶
MUST deny, from revoked_at, any request authorized by the named
token or by any chain that contains it; and¶
MUST NOT continue to rely on a cached status answer for those tokens.¶
A verifier that caches chains therefore indexes them by the (iss,
jti) of every token in each chain, not only by the presented token.¶
A holder of the named token or of a descendant that receives a valid event:¶
MUST stop acting under the revoked tokens from revoked_at;¶
MUST send the event on to the holder of each token it issued itself from a revoked token, as Section 6.4 describes, so that the event reaches the end of the chain even when no single party knows every holder. Tokens that an authorization server issued from a revoked token are handled by that server (Section 7);¶
MUST stop work that depends on the revoked tokens, for example by ending the dialogs it controls under them, as the application protocol defines; and¶
SHOULD tell the verifiers it used the revoked tokens with, where it has a channel to them.¶
A holder that cannot obtain the current status of its chain, within the staleness bound its policy sets, SHOULD suspend work under the chain until it can, so that a lost event does not leave it working under revoked authority.¶
Processing is idempotent. A holder that has already processed an event for the same token, or for an ancestor of it, processes it again only to retry delivery.¶
A holder passes the event on unchanged, with the original signature, inside a SET of its own:¶
{
"iss": "https://planner.example",
"iat": 1794643202,
"jti": "set-77e0",
"aud": "https://researcher.example",
"sub_id": {
"format": "delegation",
"iss": "https://assistant.example",
"jti": "dt-41c2"
},
"events": {
"urn:ietf:params:oauth:event-type:delegation-revoked": {
"revoked_at": 1794643200,
"reason": "principal_request",
"original": "eyJ0eXAiOiJzZWNldmVudCtqd3Qi..."
}
}
}
¶
The relaying SET has the same sub_id, revoked_at, and reason as
the original. The original member (Section 4) carries the SET that
revoked the token, never a relaying SET: a holder that relays an event
it received by relay copies its original unchanged. The receiver
validates the original SET under Section 5 and checks that the
relaying SET's sub_id equals the original's. The relaying SET tells
the receiver that the event reached it through its delegator, but the
authority to revoke comes from the original.¶
When the token below the boundary was issued by an authorization
server at the boundary, for example by identity chaining, the
parties below hold only that server's tokens and do not hold the
named token. The original event would tell them the issuer and
identifier of a token upstream, which the boundary is meant to keep
from them. The authorization server therefore does not relay it.
It revokes the tokens it issued from the revoked token
(Section 7) and sends, for each, a new event that it issues
itself, naming that token and without original, to the token's
holder. It is the issuer of those tokens, so the new events are
accepted under Section 5 item 1.¶
SETs can be delivered with push [RFC8935] or poll [RFC8936] delivery, through a Shared Signals stream [SSF], or in the messages of the application protocol that the agents already use, such as the dialogs that depend on the revoked delegation. The delivery mechanism does not affect the authority to revoke, which comes only from the signature.¶
A verifier that needs to learn of a revocation sooner than its staleness bound (Section 7) allows SHOULD subscribe to events from the issuers of the tokens in the chains it accepts, for example with a Shared Signals stream [SSF]. A verifier that does not subscribe still learns of the revocation through chain status, within its staleness bound; events only let it learn sooner.¶
A delegator SHOULD retry delivery to each holder of a token it delegated until the delivery mechanism reports success or the token expires.¶
Relaying (Section 6.4) depends on every holder in the chain being reachable and willing to pass the event on. A holder that is offline, compromised, or simply slow leaves the parties below it uninformed. Verifiers therefore do not depend on relaying for safety. Relaying makes revocation fast; checking the status of the whole chain bounds how long a revocation can go unnoticed.¶
In this section, a token's status mechanism is a Token Status List
[STATUS-LIST] referenced by its status claim, token introspection
[RFC7662] at its issuer, or another mechanism through which its
issuer reports that it is no longer valid. A token is revoked in its
status mechanism when its status is set to INVALID in a Token Status
List, or when introspection reports it inactive.¶
A verifier that relies on a chain of delegation tokens:¶
MUST check the status, through each token's status mechanism, of every token in the chain that carries a status reference, not only of the token presented to it. A revoked token anywhere in the chain revokes the chain.¶
MUST define a staleness bound for the status answers it relies on,
and MUST reject requests that rely on the chain while it has no
status answer for every such token that is fresher than that bound.
This is not a revocation: once the verifier obtains a current answer
showing the tokens valid, it accepts the chain again. For a Token
Status List, freshness is measured from the iat of the Status
List Token, not from when the verifier fetched it; the verifier
MUST NOT rely on a Status List Token past its exp, and SHOULD NOT
cache one for longer than its ttl. A verifier that cannot trust
its own clock cannot measure staleness, and MUST treat its status
answers as stale until it can; a secure time source such as
Roughtime [ROUGHTIME] can provide this.¶
A verifier that also receives events applies them as Section 6.2 describes.¶
Issuers of delegation tokens that are to be revocable with this document SHOULD give each token a status mechanism. When the root token has one, its status entry is the single point at which the whole tree can be revoked: its issuer revokes it there, and every verifier that checks the chain sees the revocation no later than the issuer's publication delay plus the verifier's staleness bound, whether or not any holder in the chain relayed the event. A token without a status mechanism can be revoked, for verifiers that miss the event, only by its expiry.¶
These rules need the verifier to see the chain. A verifier receives
every link of a Delegation Token chain [DELEGATION-TOKENS]
[AGENT-DELEGATION]. A verifier of a token issued by token exchange
[RFC8693] sees only that token: nested act claims identify prior
actors but carry no reference to their tokens or to their status, and
Section 4.1 of [RFC8693] makes them informational only. This
document does not add such references. Verifiers of these tokens rely
on the authorization server, which takes the verifier's place:¶
An authorization server that issues a token by token exchange MUST
record the (iss, jti) of the subject_token and of any
actor_token it was issued from. When it revokes a token, or learns
by an event or by its status that one has been revoked, it MUST also
revoke, in their status mechanism, every token it issued from that
token, directly or indirectly, and SHOULD send an event of its own
for each to its holder (Section 6.4).¶
An authorization server SHOULD limit the lifetime of a token it issues by token exchange to the remaining lifetime of the tokens it was issued from.¶
An authorization server that issues a token by exchanging a token from another issuer cannot learn of that token's revocation from its own records. It SHOULD check the status of the tokens it was issued from at least as often as its own staleness bound, and revoke their descendants when one is revoked. It MAY also receive delegation revoked events from that issuer, for example through a Shared Signals stream [SSF].¶
Remains the authoritative status of each token. This document adds push, subtree effect, and propagation to holders.¶
Its Section 8 provides revocation per token through status lists. Its Section 9.5 describes the window between revocation and a verifier's next status refresh; this document narrows it for verifiers that receive events.¶
Ends the authority of a unit of work at the authorization server. The event in this document can carry that ending to agents that delegated further without the server.¶
Its requirements for timely revocation across organizations are met by propagation along the chain, with chain status as the backstop.¶
Distinguishes invalidating tokens from closing the authority they conveyed, and defines authority epochs, delegation lineage, admission fencing, and closure states such as CLOSED, PARTIAL, and UNKNOWN. The event and chain status in this document are invalidation mechanisms: they can supply evidence toward closure, and the lineage that Section 7 requires of authorization servers parallels its lineage requirement, but they do not by themselves establish that work admitted under the revoked authority has stopped.¶
A forged event can stop legitimate work. Receivers accept events only under Section 5, and MUST verify the signature before acting.¶
A delegator that does not relay an event, because it is unreachable, compromised, or uncooperative, leaves its delegatees acting under revoked tokens until they next check status or contact a verifier. Verifiers do not depend on relaying (Section 7), so for a chain whose tokens have status mechanisms and that the verifier sees, the exposure is bounded by the issuer's publication delay plus the staleness bound, not by the reachability of the delegators.¶
When a verifier sees only the last token of a chain, revocation of an earlier token reaches it only through the authorization server that issued the last token. Across issuers, the exposure is bounded by how often that server checks the status of the tokens it exchanged, and by token lifetimes (Section 7).¶
Replaying a valid event has no effect beyond the first, since
revocation is permanent. Receivers MAY discard SETs whose jti they
have seen.¶
Receivers SHOULD rate-limit events from each issuer, and ignore an event for a token whose chain they do not hold before doing any further work (Section 5).¶
Revoking the root token revokes the whole tree. Parties named under Section 5 item 3 hold that power for every chain of the root; root issuers SHOULD designate them narrowly.¶
The subject identifier reveals the token issuer and identifier, which
are linkable across verifiers that see the same token, and nothing
else about the token (Section 3). Events SHOULD be sent only to
parties that hold the chain. Across a trust boundary, the boundary's
authorization server sends events of its own instead of relaying the
original (Section 6.4), so parties below the boundary learn nothing
about tokens above it. A token whose sub is a pseudonym
[AGENT-DELEGATION] keeps the principal hidden in the event as in the
token.¶
This document builds on the revocation sections of [DELEGATION-TOKENS] and on the Shared Signals work of the OpenID Foundation.¶