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

Review · November 10, 2026

Agent Authorization Center Summary

draft-du-oauth-agent-authorization-center -00View on Datatracker →

The problem

A personal agent running on your phone wants to book a ticket on a site it has never used. Who approves that, and does the user have to be interrupted every time?

The draft proposes an Agent Authorization Center (AAC). It's a service that knows the user, knows which agents belong to them, and holds a per-user list of sites each agent may access without asking. If the site is on the list, the AAC approves silently. If it's on a forbidden list, the AAC refuses. Otherwise it asks the user.

The scope is "user-side agents", meaning agents on a personal device bound to one user. Cloud-hosted agents serving many users are explicitly out of scope.

How it fits in

Agent authorization is on topic for the OAuth working group. This draft is an architecture sketch, with no protocol in it yet.

It cites one OAuth document, RFC 6749, as an informative reference. The only normative reference is RFC 2119, and the draft contains no normative statements.

The roles are the interesting part, because they don't map the way the names suggest.

  • The "resource party" receives an authorization code and redeems it at the AAC's token endpoint. That makes it the OAuth client, not the resource server.
  • The AAC is the authorization server. It also holds the user's identity, so it's acting as an identity provider.
  • The agent carries the redirect and delivers the code. That's the job the browser does in the authorization code flow.
  • The resulting "access token" contains the user identifier and the agent identifier, and the resource party validates it to decide what service to provide. That's an ID token.

So what is this in existing terms? It's federated login, with the agent as the user agent and the user's chosen identity provider deciding whether to prompt. OpenID Connect already covers that shape, including prompt=none for the silent case.

The new relationship is that the agent names the AAC in its first request, and the site is expected to accept it. Any site must trust any AAC a user brings. The draft calls the AAC a "trust anchor" and never says how that trust gets established.

It doesn't mention the closest competing work. AAuth defines a person server that represents the user and makes this same approve-or-ask decision, with a full protocol behind it. CIBA already specifies how an AS notifies a user out of band for approval.

What it actually defines

A nine-step flow in prose, plus one diagram.

  1. The agent calls the site with a user identifier and an AAC identifier.
  2. The site sends back an "authorization guidance message" pointing the agent at that AAC.
  3. The agent asks the AAC for an authorization code, sending the user ID, agent ID and site information.
  4. The AAC checks the user's policy and picks a mode: Autonomous Approval, rejection, or Human Authorization.
  5. The AAC returns a code to the agent.
  6. The agent hands the code to the site.
  7. The site redeems the code at the AAC's token endpoint.
  8. The AAC returns a token naming the user, the agent and the AAC. It may also say which mode approved the request.
  9. The site validates the token and serves the user.

That's the whole mechanism. There are no HTTP messages, parameters, claims or examples.

Significant interoperability concerns

There's nothing to implement yet. Every step in the flow is a description of a message that isn't defined.

  • No AAC discovery or trust. The agent supplies the AAC identifier. The draft doesn't say what format it takes, how the site finds the AAC's endpoints, or why the site should believe tokens from it. A malicious agent can point at an AAC it controls and assert any user identifier it likes.
  • No client registration. The site redeems a code at an AAC it may have never seen. There's no mention of how the site is identified or authenticated at the token endpoint. Client ID Metadata Documents would be the obvious fit and aren't referenced.
  • No agent authentication. The agent sends an "Agent ID" to the AAC. Nothing says how the AAC knows the request came from that agent, or from the user's device at all. In autonomous mode, that request is the only thing standing between an attacker and an approved code.
  • The "authorization guidance message" is undefined. It's described as a redirect, but the agent isn't a browser. No status code, header or body format is given.
  • Policy is per site, with no scope. The allow list decides whether an agent may access a site, with no way to say what it may do there. Reading a calendar and buying a plane ticket get the same answer.
  • No token format. Step 8 lists what "should be included" in the token. No claim names, no signing rules, no audience. The site can't validate a token it has no format for.
  • The authorization mode signal is optional and undefined. A site that wants to require human approval for a purchase has no way to ask for it, and can't rely on the token saying so.
  • Human Authorization has no channel. The AAC "notifies user for confirmation." How, and what the agent does while it waits, aren't covered.
  • No PKCE, state or redirect URI rules. The agent relays a code between two parties over an undefined channel. None of the protections from the OAuth Security BCP are mentioned.

Security Considerations is "TBD". For a design where an unattended agent gets silent approvals, that's the section that matters most.

Mechanisms that could be removed

Most of what the draft describes doesn't need a standard.

How the AAC stores user-to-agent associations, how agents are grouped, and how the allow and forbidden lists are configured are all internal to the AAC. No other party sees them. Any authorization server can already skip the consent screen based on its own policy. That's a product feature, the same way "remember this app" works at Google or Okta today.

What would need a spec is a short list:

  • How a site learns which AAC to use and decides to trust it.
  • How the agent is identified and authenticated to the AAC.
  • A claim telling the site whether a human approved this specific request.

The first two have active work elsewhere in the working group. The third is a small claim registration, and could be a short standalone draft.

Writing quality

This is a placeholder. Six pages, about three of content.

The text is readable and the intent is clear. It doesn't use IETF protocol language. The RFC 2119 boilerplate is present and no requirement keywords appear in the body. The flow uses lowercase "should" and "may" for token contents.

Terminology is non-standard. "Resource party" is used for what OAuth calls the client, and the diagram labels it "Resource Server". "Token Swap" appears in the diagram and nowhere in the text. The diagram shows the agent querying the user for policy, while the text has the AAC notifying the user.

A few grammar slips: "user-side agents, which deployed on personal user devices", "In the Step 4".

IANA Considerations, Security Considerations and Acknowledgements are all "TBD".

The length isn't the problem. The motivation takes a page and a half, which is reasonable. The missing piece is everything after it.

Background of the author

I couldn't reach Datatracker from this session, so I have no verified RFC or draft counts. The profile to check is https://datatracker.ietf.org/person/[email protected].

Zongpeng Du (China Mobile) is the sole author. This is Du's only document in the local OAuth, WIMSE, SCIM and DAWN corpus, so Du is new to this working group. From memory, and unverified, Du's earlier IETF work is in the routing area, around computing-aware traffic steering. The role naming in this draft is consistent with an author coming from outside the OAuth community.

China Mobile is already a heavy contributor of agent drafts to OAuth through Meiling Chen's cluster. This draft doesn't reference any of them.

Questions worth raising

  • The "resource party" redeems a code and receives a token about the user. Isn't that an OAuth client doing OpenID Connect login?
  • Why should a site trust an AAC named by the agent making the request?
  • How does the AAC authenticate the agent before approving a request with no human involved?
  • What does the AAC add beyond an authorization server that skips consent based on user policy?
  • How does this relate to the person server in AAuth, which fills the same role?