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

Review · November 20, 2026

draft-sweeney-oauth-brokered-authorization-00 Review

draft-sweeney-oauth-brokered-authorization -00View on Datatracker →

Problem Statement

Agent platforms run one registered OAuth client as many short-lived instances. Current work such as attestation-based client authentication and client instance identifiers binds refresh tokens to the instance. When the instance dies, the user's authorization dies with it.

This draft answers one question: where does the grant live when the instance that obtained it is gone?

Its answer is a broker. The broker holds the upstream credential and makes every upstream call itself. The user's authorization is recorded against the client at the broker's authorization server, and no instance ever holds a refresh token.

How the Spec Fits In

This fits the OAuth working group charter. It is a profile of existing mechanisms with a small amount of new protocol surface.

The new pieces are:

  • a brokered_access authorization details type for Rich Authorization Requests
  • a rule that the client credentials grant can redeem a user's prior consent
  • one error code, upstream_authorization_required
  • a long list of requirements on how the broker behaves

It has normative dependencies on eight OAuth documents: OAuth 2.1, RFC 6749, PAR, RAR, DPoP, mTLS, Resource Indicators and Protected Resource Metadata. It leans informatively on attestation-based client authentication, which is the expected way an instance proves its key.

The broker is a new role. It is a resource server to the client instance and an OAuth client to the upstream API. The draft compares it to the Backend for Frontend pattern from the browser-based apps guidance, which is a fair comparison.

The new relationship is the notable part. A user consents through an authorization code flow, but no refresh token is issued. Afterwards, any instance uses the client credentials grant plus an upstream_grant identifier to get an access token that acts on that user's data.

This is the author's second draft. It is a much narrower rework of the ideas in draft-sweeney-wimse-credential-delegation. The DIDs, custom delegation token, /exercise endpoint, receipts and delegation chains are all gone.

High-Level Summary

There are four players: the user, the client instance, the broker with its authorization server, and the upstream API.

Setup happens once. The user authorizes the broker at the upstream API, for example Google or Salesforce. The user then authorizes the agent's client at the broker's authorization server, using an authorization code flow with PAR. The request lists the HTTP methods and path prefixes the client may use. The authorization server records this and returns an opaque upstream_grant identifier.

Each new instance then does the following:

  1. It authenticates as the client with a key only that instance holds.
  2. It makes a client credentials request naming the broker resource, the upstream_grant identifier and the operations it needs.
  3. It receives an access token that is sender-constrained to the same key and lives for five minutes or less.
  4. It sends ordinary HTTP requests to the broker.

The broker matches each request against a configured list of operations, checks the token permits it, attaches the upstream credential and forwards the request. The upstream API sees only the broker and needs no changes.

When an instance ends, nothing needs to be cleaned up. Its tokens expire.

Interoperability and Necessity of the Spec

Is there an interoperability surface here?

A small one. The draft requires the broker and its authorization server to be one party. The upstream API implements nothing. The only place two independent implementations meet is between the client instance and the broker.

That surface is the authorization details type, the token request and the error code. Those three pieces are specified well enough to implement.

Significant interoperability concerns

The identifier is a refresh token under another name. The draft says so itself: among instances of one client, the upstream_grant value "is all that separates one resource owner's authorization from another's." It needs 128 bits of randomness and never rotates. A client still has to store it and hand it to the right instance. The draft claims the grant now lives at the authorization server, but the client keeps a long-lived secret-like value either way.

The security model excludes the motivating use case. The draft assumes every instance is as trusted as a confidential client's backend. It then says an instance that reads untrusted content is not. That describes most AI agents. One prompt-injected instance that learns another user's identifier can get tokens for that user. Restricting an authorization to certain instances is listed as an open issue, and it is the issue that decides whether this design works for agents.

Clients cannot discover what a broker offers. Operation names are broker-specific and there is no way to learn them. Paths are relative to a broker resource that each broker lays out however it likes. A client written for one broker's GitHub resource will not work against another's.

The forwarding rules are out of scope. Section 6.9 lists nine things a broker's forwarding rules "have to cover" and specifies none of them. The draft admits these rules "decide whether the arrangement is safe in practice." Two brokers can both comply and offer very different security.

Reauthorization is a dead end. upstream_authorization_required tells the instance the user must reauthorize the broker upstream. The draft gives no way to start that.

Mechanisms that could be removed

Most of Section 6 governs the broker's internal behavior, which is not visible to any other party. That includes the operation configuration rules, the path normalization algorithm, the credential custody rules and the withdrawal limit "that the deployment states."

These are good security advice. They read as a best practices document for API gateways, and they could move into the companion document the author already proposes for the forwarding rules.

The consent screen requirements in Section 4.2 ("MUST make plain that...") are not testable and do not affect interoperability.

The Implementation Status section lists one implementation and states that it "does not implement this document." It can go.

Writing Quality

The writing is very good. Sentences are short and declarative, and the terminology is defined precisely and used consistently.

The draft is unusually candid. Section headings include "The Broker Holds Everything" and "Any Instance of the Client Can Act." The security considerations state the limits of the design plainly instead of burying them.

The positioning against existing work is careful. It explains why it defines a new authorization details type instead of reusing the one in draft-mcguinness-oauth-mission-resource-access, with section-level citations.

At 29 pages it is longer than its protocol surface needs. The length comes from the broker behavior rules. The nine open issues show the author knows where the gaps are.

One nit: the type name brokered_access is not collision-resistant, which RAR recommends. The draft acknowledges this and offers a URN as the alternative.

Background of the Authors

Kieran Sweeney

  • RFCs published: 0
  • Active Internet-Drafts: 2, this document and draft-sweeney-wimse-credential-delegation
  • Expired drafts: none
  • No working group roles or affiliation listed on Datatracker

This is a new IETF author, first seen in August 2026. This draft is a clear step up from the first one. It is smaller in scope, built on OAuth mechanisms the working group already knows, and it addresses the proxy-mapping gap in the earlier draft by having the instance send ordinary HTTP requests to the broker.