Review · October 26, 2026
AAuth Protocol Summary
AAuth is a new authorization protocol for AI agents, not an OAuth extension. At -11 it is 164 pages, defines five access modes, five token types, three HTTP headers, four metadata documents, a URI scheme, and four IANA registries. It has four exploratory implementations and a family of companion drafts. This is the most ambitious document in front of the OAuth working group right now, and it deserves a careful read.
The problem it's solving
Agents discover resources at runtime, so there is no developer to pre-register a client with each server. Agents also run long tasks across trust domains and need authorization decisions mid-task. The draft's premise is that every agent instance should have its own cryptographic identity, verifiable by anyone, and that every request should be signed with it. No credential is a bearer credential. The first API call is the registration.
On top of that identity it adds a server that represents the person, brokers consent, and federates with the servers that protect resources.
How it fits in
It defines its own roles, token types, headers, metadata, and URI scheme. The agent provider issues agent identity. The person server (PS) represents the user. The access server (AS) represents the resource. OAuth 2.0 is cited normatively but only for vocabulary. The actual building blocks are JOSE, HTTP Message Signatures, and the author's own HTTP Signature Keys draft, which is an unadopted individual submission in HTTPbis.
The document mentions no adopted OAuth WG work on the same problems. Client ID Metadata Documents gives clients a portable URL-based identity. ID-JAG and Identity Chaining cover cross-domain federation. Deferred Token Response covers asynchronous token issuance. AAuth redefines each of these from scratch and does not say why the adopted versions don't fit.
Adopting this would mean the WG taking on a parallel protocol family, since the protocol document depends on companion drafts for bootstrap, events, and rich resource requests.
How it works
Every agent holds a signing key and an agent token from its agent provider. Every request is signed. The resource answers with an AAuth-Requirement header naming what it needs: the agent's identity, a user interaction at the resource's own page, a person token, or an auth token.
The five modes are answers to what the resource needs to know:
- Agent identity. The resource decides on the agent's identity alone. This is the "replace API keys" pitch.
- Resource-managed. The resource runs its own login or OAuth flow and hands back an opaque session token bound to the agent's signature.
- Person identity. The agent gets a person token from its PS, scoped to one resource, with a pairwise subject and no scope. The resource decides on the person's identity alone. The draft calls this "federated login for agents." In OAuth terms, the PS is an identity provider and the person token is a key-bound ID token.
- PS authorization. The resource signs a resource token describing the requested scope and hands it to the agent. The agent takes it to its PS, which runs consent and issues an auth token the resource accepts.
- Federated authorization. Same, except the resource token names the resource's own AS, and the PS federates with that AS to get the auth token. The PS is the only party that ever calls an AS.
The resource token is the genuinely novel piece. In OAuth the resource server never signs anything. Here the resource cryptographically states what was requested, by which key, for which person, under which mission. The PS then checks that the resource did not quietly drop the mission.
Governance rides alongside as an optional layer: missions described in Markdown and identified by hash, a permission endpoint for local tool use, an audit endpoint, interaction relay, and clarification chat between the user and the agent during consent. Call chaining, sub-agents, a revocation cascade, and 202-based deferred responses round it out.
Significant interoperability concerns
Person tokens and auth tokens differ only by typ. Section 13.11 admits they carry the same issuer, audience, subject, and key binding, and that the check "fails open." A resource that verifies the signature and reads sub without checking typ accepts an identity assertion as an authorization. The fix offered is a MUST and a suggestion to test it. The two token types should be structurally different.
Every agent needs the full state machine. A resource may mix modes per endpoint and escalate at any time, and the runtime header is authoritative over the advertised mode. Five modes plus 401 and 202 delivery variants is a lot of surface for the agent side.
The signing layer depends on an unadopted draft. HTTP Signature Keys defines how the agent token is conveyed, how keys are discovered, and the error vocabulary. Nothing in AAuth interoperates until that document stabilizes.
PS-to-AS trust is left to deployments. Trust can be pre-established, established by user interaction, established by payment via a 402 response, or granted on identity claims alone. These compose in any order. Two conformant implementations can easily fail to converge on a working path.
Too much that matters is SHOULD. Revocation endpoints are SHOULD. Resource token lifetime is SHOULD NOT exceed five minutes. Replay detection on resource tokens is explicitly not required. A resource that accepts agent tokens directly has no revocation path at all.
Mechanisms that could be removed
The governance layer. Missions, permission, audit, and clarification chat are optional and do not affect whether an agent and a resource interoperate. Moving them to a companion document, as Events and R3 already are, would cut the core protocol substantially and make it reviewable.
The Supervisor role. It is defined in terminology, its protocol is "TBD," and the draft says nothing any party sees changes with who supervises.
The payment path. The 402 handling and the x402 and Payment scheme references are informative and belong elsewhere.
Appendix C.4. The "Why Not Extend OAuth" section says OAuth clients have no independent identity, require pre-registration, use bearer tokens only, and have no federation model. None of these hold for OAuth as the WG has developed it. The same claims open the Introduction. Either update them or drop them, because they will derail WG discussion before anyone gets to the resource token.
Writing quality
The prose is clear and the tables are useful. The design rationale appendix explains the reasoning behind decisions in a way most specs never do, and it is the best part of the document.
The length is the problem. There are 300 MUSTs across 164 pages. Some artifacts suggest the restructure was rushed: the BCP 14 boilerplate directive is unrendered in Section 2, a kramdown figure attribute leaks into the text in Section 9.3.1, and there is a "Section Section 8" in Section 4.5.1. Inline section references appear without parentheses throughout. A document this size cannot be reviewed as one unit by a working group.
Background of the author
Dick Hardt is the editor of RFC 6749 and an author of RFC 6750 and RFC 8725. He is one of the most experienced authors in this space, not a newcomer. He is also very actively writing: the AAuth family alone has five drafts (protocol, bootstrap, events, R3, budgets), alongside OAuth 2.1, the RFC 8725 update, HTTP Signature Keys, and Protected Authorization. The implementation status section lists TypeScript, .NET, Python, and Keycloak implementations from three organizations, all marked exploratory.
The conversation the WG needs is a side-by-side of the person token against ID tokens and ID-JAG, the four-party flow against Identity Chaining, and agent identity against Client ID Metadata Documents. The draft has not drawn that comparison. Someone should.