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

Review · October 13, 2026

"AAuth -11: The Person Server Admits It's an Identity Provider"

draft-hardt-oauth-aauth-protocol -11View on Datatracker →

AAuth is now at -11 and 164 pages long. The Document History says the revision was "restructured for readability," and the sections do now follow the order an implementer meets them. The bigger story is a new token. -11 adds a person token, a PS-issued identity assertion bound to the agent's key, and rebuilds every mode that involves a Person Server around it. The draft's own description of the new mode is "federated login for agents."

The problem it's solving

AAuth's premise hasn't changed. Every agent instance gets its own cryptographic identity (aauth:local@domain, bound to a signing key, discoverable at a well-known URL). Every request is signed with HTTP Message Signatures. No credential is a bearer credential, and the first call to a resource is the registration. On top of that identity it builds consent, federation, missions, and audit for agents that discover resources at runtime and run long tasks across trust domains.

How it fits in

It's still a parallel protocol, not an OAuth extension. It defines its own roles (Agent Provider, Person Server, Access Server), its own JWT types, its own headers, its own metadata documents, and its own URI scheme. The normative dependencies are JOSE, RFC 9421, and Dick's own HTTP Signature Keys draft. RFC 8693 dropped out of the references entirely in -11, along with the act claim that was the last thing tying call chaining to Token Exchange.

The short version of how it works

An agent provider issues the agent an agent token. A resource can stop there and decide on the agent's identity alone, which is the "replace API keys" pitch. When the resource needs to know the person, the agent asks its Person Server (PS) for a person token scoped to that resource. When the resource needs consent for a scope, it hands the agent a signed resource token, the agent takes it to its PS, and the PS either issues an auth token itself or federates with the resource's own Access Server (AS). Missions, permission, audit, and clarification chat ride alongside as an optional governance layer.

What changed since -10

The person token. This is the headline. A person token (aa-person+jwt) is a JWT from the PS with aud set to one resource, a pairwise sub, cnf bound to the agent's key, an optional tenant and mission_s256, and a lifetime of at most an hour. It explicitly carries no authorization: no scope, no account. Every PS MUST publish a person_token_endpoint. A resource MUST verify a person token (or an auth token) before it will issue a resource token, and the resource token now copies ps, sub, and a new presented_jti from whichever token it verified. The agent then passes that token to the PS as presented_token so the PS can check the resource didn't quietly drop the mission.

Five modes instead of four. The new one is "person identity access": the agent presents a person token and the resource applies its own policy on the person's identity, with no resource token or auth token involved. "PS-asserted" was renamed "PS authorization," and the old "identity-based" mode is now "agent identity." There's a new IANA registry for access mode values.

No agent identifier reaches a resource. In the three PS-involved modes, none of the person token, resource token, or auth token names the agent. act is gone. The resource token binds the agent's key via agent_jkt but carries no agent ID. The rationale (Appendix C.1.6) is that a resource that can see the agent product can pin policy to it, which makes agent providers into gatekeepers. That's a real design position, and a notable one for anyone building agent-specific policy at a resource.

Missions slimmed down. The mission object in tokens is replaced by mission_s256. The AAuth-Mission header and approver claim are removed. The mission endpoint takes propose, update, and completion actions, and there's a new mission_terminated error.

Revocation got a real cascade. This was the largest set of issue closures. A revocation is just jti and exp, the caller's identity comes from the signature, and each token type has exactly one revoker and a defined set of recipients. Revoking a person token at the PS cascades to the resource and to every AS the PS presented it to, and the AS revokes the auth tokens it issued against it. Agent provider revocations cascade by agent identity across every token the PS issued to that agent. Person token revocations now reach call chains. A recipient only answers 200 once its whole downstream cascade has a terminal outcome, with a 202 deferred response when that takes too long, a downstream result array from the AS, and a new rate_limited error.

Call chaining reworked. An intermediary can present a person token as upstream_token, not only an auth token. Downstream tokens expire no later than the upstream token and carry its mission_s256. Routing follows the upstream token's PS. And an intermediary MUST be its own agent provider, publishing aauth-agent.json on its own origin and signing with a self-issued agent token, because that's the only way the recipient can tie the signer to the upstream token's aud.

Smaller items. A resource token MAY carry login_hint, which the agent passes through unaltered. The person token request accepts the same optional parameters as the auth token request. Third-Party Login and login_endpoint are removed. token_endpoint was renamed auth_token_endpoint, and the two-party credential is now called a session token. A "Supervisor" role was added with the actual protocol deferred to a TBD companion spec. Every party MUST support Ed25519, iat is REQUIRED, exp has no tolerance, and agents refresh with five minutes left. There's a new informative appendix describing a minimal single-person PS, which is a useful addition.

Does -11 address the earlier feedback?

My earlier feedback had two main threads. Describe the flows in OAuth terms and point out where the real gaps are. And fix the "Why Not Extend OAuth" analysis, which gets several things wrong about OAuth as it exists today.

The comparison section is unchanged. Appendix C.4.5 is word-for-word identical to -10. It still says OAuth clients have no independent identity, that OAuth requires pre-registration, that OAuth tokens are bearer, and that OAuth has no federation model. Client ID Metadata Documents give clients a portable URL-based identity with no pre-registration. DPoP, mTLS, and HTTP Message Signatures give you sender-constrained tokens. The Introduction repeats the same "client has no independent identity" claim in Section 1.1. Appendix C.3.1 still describes combining the user's identity server and the resource's policy server as "the conflation that makes OAuth insufficient," when OAuth deployments routinely federate an external IdP into the resource's AS. None of these claims were updated.

But the architecture moved toward the OAuth mapping anyway. The person token is, functionally, an OpenID Connect ID token issued for a resource and bound to a key. The draft says so itself: person identity access "is federated login for agents," and Appendix C.1.7 compares it to signing in to a site with an identity provider. That's the clearest statement yet that the Person Server is an IdP, not an authorization server.

The four-party flow now lines up even more closely with ID-JAG. The PS issues an identity assertion scoped to a target, the PS presents it to the resource's AS, and the AS applies its own policy and issues the token the resource accepts. In -10 the PS federated a resource token. In -11 it federates a resource token plus a PS-issued identity assertion about the user. That's the ID-JAG shape, with the main difference being that the PS calls the AS rather than the client. There's still no reference to ID-JAG, Identity Chaining, or CIMD anywhere in the document.

Mission-level cascade revocation is partly addressed. I'd flagged that revoking a mission should cascade to everything issued under it. The new cascade machinery is thorough for person tokens and agent tokens. Mission revocation itself is still one bullet: the PS denies new requests for that mission_s256 and SHOULD revoke outstanding auth tokens. Person tokens issued under the mission aren't mentioned, even though the mission now rides on person tokens.

The resource token is still the genuinely novel piece, and -11 gives it a better justification. Binding the resource token to the exact presented token via presented_jti is what makes mission stripping detectable (Appendix C.1.9). That's a concrete security argument for the resource signing something, which is more convincing than the earlier confused-deputy framing alone.

Significant interoperability concerns

Person tokens and auth tokens differ only by typ. Section 13.11 says it outright: they carry the same iss, dwk, aud, sub, and cnf, and "it fails open." A resource that checks the signature and reads sub without checking typ will accept a person token wherever it expects an auth token. The draft responds with a MUST and a suggestion to test it. A better answer is to make the two structurally distinguishable, for example by requiring scope on an auth token or using distinct dwk values that must match. A design whose most likely implementation bug grants access is going to produce that bug in the wild.

Five modes is a lot of surface. -11 adds a mode rather than collapsing them. Agent identity and resource-managed are really one architecture with no AS. PS authorization and federated authorization differ only in who issues the token the resource validates. Person identity is OIDC login. Every resource has to decide which of these it's in per endpoint, and every agent has to be able to handle all of them. The access_mode metadata helps the agent anticipate, but the runtime AAuth-Requirement is authoritative, so an agent still needs the full state machine.

Revocation now expects push endpoints at resources. A resource that accepts person tokens SHOULD run a revocation endpoint, and a PS revocation response waits until every downstream recipient answers. That's a synchronous fan-out across trust domains with deferred polling on top. Meanwhile a resource that accepts agent tokens directly has no revocation path at all and is bounded only by a 24-hour token lifetime. The draft is honest about this ("deployments requiring immediate termination should issue shorter-lived tokens"), which raises the question of whether the cascade machinery is worth its 7 pages.

The intermediary-must-be-its-own-AP rule. It's well reasoned, but it means any resource that wants to call a downstream API on the person's behalf has to stand up agent provider metadata and self-issue agent tokens. That's a real deployment cost for the common "my API calls Stripe" case.

Mechanisms that could be removed

Clarification chat, missions, permission, and audit are still in the core document. They're optional, and they're the parts people get most excited about, but none of them affect whether an agent and a resource interoperate. Moving the governance layer to a companion document, the way AAuth Events, Bootstrap, and R3 already are, would cut the core spec substantially and make the access protocol reviewable on its own.

The Supervisor role is defined in terminology and referenced in several places, but its protocol is "TBD" and "nothing an agent, resource, or AS sees changes with who supervises." It doesn't belong in the core spec until there's something to specify.

Appendix C.4. If the comparison sections aren't going to be updated to reflect current OAuth, they should be removed. They're the parts of the document most likely to derail WG discussion.

Writing quality

The restructure helps. Sections follow the order an implementer meets them, the endpoint and requirement tables are useful, and the design rationale appendix is the best part of the document. It explains the reasoning behind decisions in a way most specs never do.

But the claim that "each normative statement is made once" sits alongside 1,176 more lines than -10, about 21 more pages. Some of that is the person token and the revocation cascade, which earned their space. Much of it is prose that explains a rule and then explains why the rule exists in the same paragraph, when the rationale appendix already exists for that. There are also leftover artifacts like "Section Section 8" and section references dropped inline without parentheses throughout.

At 164 pages, the bigger problem is reviewability. A WG can't meaningfully review this as one unit, which is another argument for splitting the governance layer out.

Background of the author

Dick Hardt is the editor of RFC 6749 and author of RFC 6750 and RFC 8725. His Datatracker profile shows 10 active Internet-Drafts, five of them in the AAuth family (protocol, bootstrap, events, R3, budgets), plus OAuth 2.1, the 8725bis update, HTTP Signature Keys, and Protected Authorization. He is very actively writing, and the revision history (issue numbers throughout the changelog and four listed implementations) reflects a project with real momentum and contributors behind it.

The most productive next step for the WG is the conversation that hasn't happened yet: a side-by-side of the person token against ID tokens and ID-JAG, and of the four-party flow against Identity Chaining. -11 has made that comparison much easier to draw. The draft just needs to draw it itself.