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

Review · November 10, 2026

OAuth 2.0 Agent Authorization Explicit Revocation Summary

draft-chen-oauth-agent-revocation -01View on Datatracker →

The problem

RFC 7009 revokes one token at a time. The caller has to hold the token to revoke it.

That doesn't work when an agent has spawned sub-agents and each one holds its own tokens. An admin responding to a misbehaving agent wants one call that says "shut down this agent and everything it delegated to."

This draft proposes that call: a new endpoint that revokes by agent identifier and cascades down the delegation tree.

How it fits in

Revocation is squarely OAuth territory, and agent delegation is in the working group's charter. The topic fits.

The draft says it extends RFC 7009, but it reuses nothing from it. It defines a separate endpoint with a JSON request body, a custom response format and its own error structure. The only references are RFC 6749, RFC 7009 and the RFC 2119/8174 boilerplate.

It introduces a new relationship that OAuth doesn't have today. The authorization server is expected to know which agents exist, which tokens belong to each agent, and which agents are children of which. None of that is defined here or referenced from elsewhere.

It also skips the closest related work:

  • Global Token Revocation already defines "revoke everything for this subject" using a Security Event Identifier. An agent could be another subject type there.
  • OpenID Shared Signals and CAEP already carry revocation events to resource servers. The draft lists "no event notification" as a gap in RFC 7009, then doesn't define any.
  • Token Exchange (RFC 8693) and the various actor chain drafts are where a delegation tree would actually come from.

What it actually defines

One endpoint: POST /agent/revoke, with a JSON body.

Required parameters:

  • agent_id: the agent to revoke.
  • reason: an object with a code and description.
  • cascade_depth: how many levels of sub-agents to include. 0 is this agent only, -1 is unlimited.

Optional parameters:

  • context: operator, source IP and request ID, for audit logs.
  • revoke_all_tokens: defaults to true.
  • revoke_for_duration: suspend for a number of seconds instead of revoking permanently.
  • revoke_scopes and retain_scopes: remove some scopes and keep others.

The response is a JSON report: a status, a transaction ID, counts of agents and tokens revoked, a list of affected agents and an audit log reference.

So who are the players? A privileged caller, likely an admin console or security tool, tells the authorization server to shut down an agent. The authorization server walks its own record of the agent hierarchy and revokes what it finds. Resource servers and the agents themselves aren't involved.

What changed in -01? Only the Security Considerations section, which was "TBD" in -00. The rest is identical apart from list formatting.

Significant interoperability concerns

Two implementations of this draft would not interoperate. The request and response shapes are sketched, but the semantics underneath are missing.

  • agent_id is undefined. OAuth has no agent identifier. The draft doesn't say whether it's a client_id, a sub, a claim in the token, or something new. Without that, the authorization server can't map an agent to its tokens.
  • The hierarchy is undefined. Cascade only works if the authorization server knows parent and child relationships. The draft never says how those get established.
  • No discovery. The endpoint is a hardcoded path. There's no authorization server metadata parameter, which also conflicts with the BCP 190 guidance against specs claiming fixed URI paths.
  • No enumerated values. reason.code, the response status and the error codes appear only in examples. SECURITY_INCIDENT and INVALID_AGENT_ID are never defined anywhere.
  • The response is defined by example only. There's no table of response fields. The 400 example returns INVALID_AGENT_ID for an agent that doesn't exist, and the status code table says that case is a 404.
  • Suspension and partial revocation have no semantics. What happens to an already-issued JWT access token when two of its scopes are revoked? What happens when a suspension ends? Do old tokens come back to life? What if revoke_scopes and retain_scopes are both sent?
  • Caller authorization is hand-waved. The security section says to require "a specific OAuth 2.0 scope (e.g., agent.revoke)" and to enforce ownership. Neither is specified.
  • Async is recommended but not defined. The draft suggests processing large cascades asynchronously. There's no pending status and no way to poll the transaction.
  • Cross-domain is motivation only. The introduction talks about agents crossing trust domains. The mechanism is a single call to a single authorization server.

There's also a behavior change from RFC 7009 that needs discussion. RFC 7009 returns 200 for an invalid or already-revoked token, so clients can retry safely and can't probe for valid tokens. This draft returns an error for an agent that "does not exist or has already been revoked." Retries now fail, and the endpoint tells callers which agent IDs exist.

The problem with the detailed response is that the authorization server can only report on what it knows. Self-contained access tokens stay valid at resource servers until they expire. A response of "tokens_revoked": 15 reads as confirmation that the agent has stopped. It isn't. draft-watts-oauth-agent-revocation-closure covers exactly this gap.

Mechanisms that could be removed

  • revoke_for_duration, revoke_scopes and retain_scopes. Suspension and scope downgrade are different operations from revocation. They change what a grant means instead of ending it. Each one needs its own design.
  • The context object. The operator should come from the caller's authentication, not a self-asserted field. A client-supplied source_ip is worthless as audit evidence.
  • The summary counters and audit_reference. Counts of tokens revoked and events emitted describe internal bookkeeping. No client behavior depends on them.
  • reason.description. Free text for a log file doesn't need standardizing.

What's left is small: a subject identifier and a cascade flag. That's close to a new subject type in Global Token Revocation.

Writing quality

This is an outline of a spec. Ten pages, and roughly two of them are spec text. The rest is boilerplate, examples and whitespace.

The abstract promises more than the document delivers. It lists "coordination protocols", "event notification" and "verifiable audit trails". None of them appear in the body. The response even counts events_emitted for events the draft never defines.

It hasn't had a careful editing pass:

  • "Example Requst" in section 3.2.
  • The request parameter table is headed "Metadata Field".
  • A paragraph of the introduction is fused into the third bullet: "trust domains In these scenarios".
  • The acknowledgements section reads "This document based on RFC7009".
  • RFC 2119 and RFC 8174 are listed as informative references, and all four references are informative.
  • IANA Considerations is "TBD", in a draft that would need at least a metadata registration.

The new Security Considerations text is the best-written part. It names the right risks: privileged access, cascade as a DoS amplifier, hierarchy disclosure. It then pushes every one of them to the implementer with a MUST and no mechanism.

Background of the authors

I couldn't reach Datatracker from this session. The numbers for Chen come from an August 2026 lookup, and the rest is from the local draft corpus.

Meiling Chen (China Mobile) has 2 RFCs, both DOTS telemetry (RFC 9244, RFC 9387). As of August she had 17 active and 42 expired Internet-Drafts across more than a dozen working groups. That's a high-volume author of early-stage proposals. This draft is one of a cluster she is running in OAuth, alongside the agent use cases document, RAR and scope extensions for agents, an intent token and a roadmap.

Li Su (China Mobile) co-authors most of that same cluster: the RAR extensions, scope extensions, intent token, roadmap and a decoupled authorization model draft. I couldn't confirm an RFC count. Su doesn't appear as a first author on any draft in the local corpus.

Six months passed between -00 and -01, and the only change was filling in one TBD section. The draft is being kept alive more than it's being developed.

Questions worth raising

  • Why a new endpoint instead of a new subject identifier format in Global Token Revocation?
  • What is an agent_id, and which of the actor and delegation chain drafts supplies the hierarchy that cascade depends on?
  • Should suspension and scope downgrade be split out, so the core revocation call can be specified completely?
  • Should the endpoint keep RFC 7009's behavior of returning success for unknown or already-revoked targets?
  • How do resource servers find out? If the answer is Shared Signals, the draft should say so and drop the claim of defining event notification.