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

Review · October 26, 2026

Revocation Closure for Agentic Authorization Systems Summary

draft-watts-oauth-agent-revocation-closure -01View on Datatracker →

The problem

Revoking a token doesn't mean the agent has stopped. By the time a user hits "revoke", an agent may have exchanged its token for downstream tokens, handed work to sub-agents, or queued jobs that run later. RFC 7009 can kill the root token. Nothing tells you when everything that came from it is also dead.

This draft asks a narrow question: when can a system honestly say revocation is complete? It separates three things that often get blurred together:

  • Revocation request: someone asked.
  • Authorization invalidation: some tokens or grants got marked invalid.
  • Revocation closure: no remaining path can produce a new effect on behalf of the revoked authority.

How it fits in

This is a vocabulary and requirements document, not a protocol. It defines no endpoints, no token format, no parameters and no IANA registrations. It calls itself "protocol-neutral" and says up front that it doesn't update any OAuth RFC.

Its normative references are only RFC 2119 and RFC 8174. Everything OAuth-related is informative: RFC 7009, Token Exchange (RFC 8693), RAR (RFC 9396), Transaction Tokens, WIMSE architecture, and RFC 9700.

So does it fit the OAUTH charter? Barely. The WG standardizes mechanisms that clients, ASes and RSes use to interoperate. This draft describes a property that a deployment's internal systems should have. Most of it is about queues, job runners and internal fan-out, which OAuth has never tried to specify.

It sits next to draft-chen-oauth-agent-revocation, which defines actual cascade revocation mechanisms. This draft positions itself as the "how do you know it worked" layer on top. Some notable gaps in what it cites:

  • Global Token Revocation, the existing WG-adjacent work on revoking everything tied to a user across systems.
  • OpenID Shared Signals and CAEP, which is where the industry already sends "this session is revoked" events across trust boundaries.

What it actually defines

The model is a graph. The root is the authority being revoked, like a user's grant to an agent. The leaves are "consequential sinks": anything that causes a real effect, such as an API call, a write to storage, a payment, or a queued job running. Edges are the ways authority flows, like token exchange, delegation to a sub-agent, or putting a job in a queue.

A "revocation cut set" is a set of enforcement points that together block every path from root to sink. You reach closure once every enforcement point in the cut set is active and no unresolved path remains.

The worked example is the useful part. A user revokes Agent A. Agent A had already queued a delayed job, and Service B had exchanged A's token for a credential at Resource Server R. Killing A's token does nothing about either one. Closure needs a block at R and the queued job cancelled before it commits.

The draft then defines:

  • Closure states: REQUESTED, PROPAGATING, CLOSED, PARTIAL, FAILED, UNKNOWN. The main rule is that anything other than CLOSED must not be treated as closed.
  • Authority epochs: a fresh authorization after revocation starts a new epoch. A receipt for the old epoch says nothing about the new one.
  • Closure budget: an optional target time from request to closure, with a warning not to compare timestamps across systems whose clocks you haven't established.
  • Closure receipts: a signed statement of what was revoked, what scope was checked, what status was reached and what's still unresolved. The encoding is explicitly left undefined. There's one non-normative JSON example.

Interoperability

There's nothing here to interoperate on. With no encoding for the receipt, no way to ask for closure status, and no way to deliver it, two implementations that both "follow" this draft can't exchange anything. Appendix B admits this: common encoding and cross-domain discovery are listed as open questions.

Most MUST statements describe internal behavior that nobody outside the system can check. "An implementation claiming closure MUST have a deterministic method for establishing that the declared closure condition has been satisfied" is a fine engineering principle. It isn't a testable protocol requirement.

The real interop question is the one the draft leaves out. How does a resource server at Salesforce learn that a grant issued by Okta has been revoked, and how does Okta learn that Salesforce has stopped honoring it? That's a cross-domain signaling problem. Shared Signals already partly covers it, and it's where a receipt format would actually matter.

What could be trimmed

  • The graph theory. The G=(V,E) formalism and cut-set definitions dress up a simple idea: block every path, and don't say you're done until you have. The worked example in Section 9 gets this across better than Section 4.
  • The closure budget. It's an optional SLA with no way to advertise or check it. That's a deployment policy, not something a spec needs.
  • The falsification cases. Section 12 is a good list of test scenarios. It reads more like a blog post or an appendix than spec text.

The core of this would fit in a Security Considerations section of a real revocation mechanism: "a successful revocation response does not mean derived tokens, delegated agents, or queued work have stopped." That one sentence is the most valuable thing in the draft.

Writing quality

The writing is clean, grammatical and uses IETF conventions correctly. The terminology is consistent, and the draft is careful about what it claims. It doesn't overreach. It's also very abstract. Phrases like "authority-bearing descendants", "consequential sinks" and "the revoked authority epoch can authorize a new consequential effect" make simple ideas harder to read than they need to be.

At about 14 pages it's not too long. The problem is that it's almost all definitions and principles, with nothing an implementer can build.

Author background

I couldn't reach Datatracker from this session, so this is based on the draft and the local draft corpus.

Deonte Watts is the sole author and lists themself as an Independent Researcher in San Francisco, with an ORCID ID and a personal domain email. Their name doesn't appear on any RFC or other draft in the local corpus, so this looks like their first IETF work. This is the -01 revision, which tightened the scope language and added the falsification cases.

Questions worth raising

  • Is this better as an informational input to existing work? The closure-vs-invalidation distinction would strengthen the Security Considerations of draft-chen-oauth-agent-revocation or Global Token Revocation.
  • If receipts matter, who consumes them? A user-facing "your agent has been fully stopped" screen, an auditor and a downstream RS all need different things.
  • How does this relate to Shared Signals and CAEP, which already carry revocation events between domains?
  • Does the WG want to take on queue and job-runner semantics at all? Or is that firmly deployment-internal?