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

Review · November 10, 2026

AAuth Agentic Authorization OAuth 2.1 Extension Summary

draft-rosenberg-oauth-aauth -02View on Datatracker →

This is the other AAuth. It shares a name with Dick Hardt's AAuth Protocol and nothing else. Where Hardt's draft replaces OAuth, this one is a 45-page OAuth extension: one grant type, one well-known scope, and one JWT signed by the resource server.

The problem it's solving

An agent doesn't know in advance which APIs it will call. The usual answer is a broadly scoped token, and agents make mistakes with broadly scoped tokens.

The draft's answer is to start the agent with almost nothing and ask the user at the moment of each risky operation. The question the user sees is written by the resource server, not the agent: "ReserveBot wants to book a table for two at Joe's Italian on Friday at 9pm."

How it fits in

It is in charter. It is a grant type extension that builds on RFC 6749, RFC 6750, Authorization Server Metadata, Protected Resource Metadata, and the JOSE RFCs. The flow is modeled on the Device Authorization Grant, and the challenge is modeled on Step-Up Authentication.

It adds no new roles and no agent identity. The agent is a confidential OAuth client with a client_id.

It does add one new relationship. The RS signs a JWT that the AS consumes, and the AS fetches the RS's metadata and keys to verify it. In OAuth today the RS never signs anything for the AS. Hardt's draft makes the same move with its resource token, so both AAuth drafts land on the same idea from opposite directions.

What it doesn't cite matters more. CIBA already defines out-of-band user approval with poll, ping, and push delivery and a binding message. Rich Authorization Requests already defines operation-specific authorization. The WG has adopted Deferred Token Response for asynchronous token issuance. None of these are mentioned.

How it works

  1. The agent gets a normal access token through any existing grant, with the scope ai-agent-minimal. What that scope allows is up to each RS.
  2. The agent calls an API that needs more. The RS returns a 403 with insufficient_scope and a new scope_challenge parameter in WWW-Authenticate.
  3. The Scope Challenge is a JWT signed by the RS. It names the AS, the client, the user, the required scopes, and a plain-text reason describing the specific operation.
  4. The agent posts the challenge to a new agent authorization endpoint at the AS. It cannot add or change anything.
  5. The AS verifies the signature against the RS's jwks_uri, fetches human-readable scope descriptions from the RS, and returns a request_code.
  6. The AS gets approval however it likes: push notification, SMS, a web page the agent opens, or an automated policy agent.
  7. The agent retrieves a short-lived token by polling the token endpoint, or over SSE or WebSocket.

The trust model is stated plainly: the agent is not trusted. Everything the user sees comes from the RS or the AS.

Significant interoperability concerns

The user approves an operation and the agent gets a scope. The reason says "table for two at Joe's on Friday." The token says reservations.write. Nothing binds the two. Section 8.10 admits this and compensates with token lifetimes of "10 seconds to a minute," plus an open issue asking whether to put API details in the challenge. That open issue is RAR. The draft should use authorization_details instead of inventing a parallel.

Confidential clients only. Public clients MUST be rejected. Every example uses a client secret. That excludes most desktop and CLI agents, and it sits awkwardly with Client ID Metadata Documents, which is where MCP clients are heading.

Web approval does not require the right user. The AS "SHOULD authenticate the end user" at the approval page. It is never required to check that the approver is the sub in the challenge. The agent is the one holding the URL. This needs to be a MUST on both counts, since Section 8.7 already concedes this is the one place the agent is trusted.

The token endpoint behaves differently from every other grant. Pending is a 202 with a status member instead of an error. Denial is 403, expiry is 410, and slow_down is 429. RFC 8628 uses 400 for all of these. The draft says the departure is permitted, which is true, but OAuth client libraries treat non-200 token responses uniformly and will need special cases.

Push delivery loses tokens and loses DPoP. A token is delivered at most once. If the SSE or WebSocket connection drops mid-delivery, the agent restarts from the 403 and the user gets prompted again. The draft also notes that a pushed token cannot be bound to a DPoP proof. The fast path produces bearer tokens only.

The RS needs to know a lot about the AS. It must put the AS issuer in aud, and the client_id and the user's sub "as known to the AS" in the challenge. That works with JWT access tokens or introspection from a single AS. An RS behind multiple authorization servers has to track which AS issued each token.

ai-agent-minimal does two jobs. It is a permission level and a capability signal that the client supports this flow. Its permissions are "entirely a matter of local implementation," so the scope tells a client nothing portable. An agent can also skip it and request broad scopes the normal way, which the draft acknowledges.

The client credentials case is undefined. With no sub, the draft doesn't say whose approval the AS obtains.

Mechanisms that could be removed

SSE and WebSocket retrieval. Polling is mandatory, the other two are optional, and together they take up about a quarter of the protocol text plus a WebSocket subprotocol registration. They bring the DPoP gap and the lost-token case with them. One retrieval mechanism is enough for a first version.

The Scope Descriptions Document. The draft's own open issue asks whether this should be a separate spec. It should. Scope Metadata Document and the adopted RAR metadata work are already competing for this space. The risk field in particular is policy input, not interoperability.

The agent-supplied timeout. The agent can simply stop polling.

token_endpoint in the response. It is already in AS metadata. So is the grant_type parameter on the agent authorization request, which is sent to an endpoint that accepts only one grant.

Section 7. The comparison with Hardt's draft belongs on the mailing list. It is also dated: it says the approval text in Hardt's protocol is written by the agent, while that draft now has the resource sign a token describing the request.

Writing quality

There are two voices in this document, and Section 10 explains why. The authors disclose that the introduction and explanatory prose are human-written and that the protocol elements, tables, error handling, and much of the security and IANA text were AI-generated and then edited.

It shows. The protocol sections are precise and use BCP 14 language correctly. The human sections are conversational and have typos: "acess", "Ther user", "malicous", "infratructure", "obtains and token", "This is preventing by". Section 8.7 says "passcodes" where it means passkeys.

A few statements are wrong on their face. Section 8.3 says the signature "uses keys shared between the AS and RS" when the spec mandates asymmetric keys. Section 8.4 describes an agent "getting the AS to sign" scope challenges, but the RS signs them. JSON Schema is a normative reference to an expired individual draft.

The length is reasonable for what it defines. It would be about 30 pages without the push channels and the scope descriptions appendix.

Background of the authors

Datatracker was not reachable when this review was written, so the profile counts below are not verified against it.

Jonathan Rosenberg is one of the most prolific RFC authors in IETF history. He is the lead author of SIP (RFC 3261) and the principal author of STUN, TURN, and ICE, with dozens of RFCs in the real-time communications area. He is not a new IETF author, but he is new to the OAuth WG. He is actively writing on agents, with a use cases draft and a framework draft for agent protocols co-authored with Cullen Jennings.

Pat White (Bitwave) has no other documents in the OAuth, WIMSE, SCIM, or agent protocol working groups that we track, and appears to be a new author.

So what should the WG do with this? The core idea is small and good: the RS signs the description of what the agent tried to do, and the agent carries it to the AS untouched. That could be a scope_challenge extension to Step-Up plus a profile of CIBA or Deferred Token Response with RAR, at a fraction of the size. The first thing to fix is the name.