The short version
AAuth is the most coherent attempt yet at treating AI agents as proper principals rather than as a user’s session cookie in a trench coat. It is also an exploratory draft with almost no deployed base, which in standards terms means it is a sketch on the back of a very ambitious envelope.
It does not replace XAA/ID-JAG or SPIFFE. It answers a different question:
- XAA asks: may this app (agent) reach that app (MCP server) for this user, as decided by enterprise admin policy?
- AAuth asks: who is this caller (what agent build, not what instance), what is it trying to do right now (mission), and did an actual human say yes (blindly approving everything), across organisations?
The draft’s best argument is against OAuth 2.1 plus Dynamic Client Registration plus bearer tokens, and on that front it lands some decent punches. Its weakest point is that it barely acknowledges the incumbent stack exists: token exchange, ID-JAG, Transaction Tokens, CIBA and DPoP get no engagement at all. One is reminded of a man announcing a new bridge without mentioning the river’s existing six.
Its other big weakness is also its main selling point. No pre-registration and no vetting means trust decisions get pushed onto a consent dialog and onto each individual resource. Both are famously difficult to run centrally, and enterprises do rather like running things centrally.
Verdict [inference]: worth watching as a signal of where agent auth might go, and as a source of ideas competitors may borrow. Not something any customer is demanding you match this quarter.
What it actually is
Where it came from [source]. Dick Hardt, an author of OAuth 2.0 and founder of Hellō, started it after concluding that OAuth fits an MCP server about as well as a bowler hat fits a labrador. He calls it an “exploratory doc”, which is admirably honest and I wish more vendors would try it (interview).
Where it stands [spec/source]. It’s an individual IETF Internet-Draft, draft-hardt-oauth-aauth-protocol-11, dated 25 September 2026, expiring 29 March 2027, with no working group adoption. A proposed OpenID Foundation working group aims for an Implementers Draft in Q2 2027 and Final in Q1 2028. The charter shows no approval date. The proposers are Hardt, Karl McGuinness, Christian Posta, Jared Hanson (Keycard) and Wayne Chang (SpruceID).
The core idea [spec]. Every HTTP client owns a keypair and an identifier of the form aauth:local@domain. Every request is signed using HTTP Message Signatures (RFC 9421). No bearer tokens, no API keys, no client registration. It is, in short, a polite refusal to carry anything that can be nicked out of a log file. Bonus question: how we would distinguish one instance of the same agent from another?
The cast [spec]. Agent, agent provider (AP), resource, person server (PS) and access server (AS). These are roles rather than deployment units, so one server can play several parts, like a village am-dram society.
The tokens [spec]. All JWTs, all bound to a key:
| Token | Issued by | Carries |
|---|---|---|
agent_token | agent provider | agent identifier, agent public key (cnf), optional ps; SHOULD live ≤24h |
person_token | person server | per-resource pseudonymous person id; identity only, no authorisation; ≤1h |
resource_token | resource | what access is requested, agent_jkt key thumbprint; ≤5 min |
auth_token | PS (3-party) or AS (4-party) | person sub, scope, ps, tenant, mission_s256, cnf; ≤1h |
Five access modes [spec]. Agent identity; resource-managed (2-party); person identity; PS authorisation (3-party); federated (4-party). A resource can mix them per endpoint, which is flexible in the way a buffet is flexible.
Mid-task approval [spec]. A resource replies 401 or 202 with an AAuth-Requirement header, and the agent polls a pending URL while a human decides whether to allow it. “Pending” is a normal protocol state rather than an error, which is more civilised than most things in this industry.
Missions (optional) [spec]. An agent-proposed, person-approved Markdown description of what it’s up to, identified by its SHA-256 hash (mission_s256), which then travels through the tokens. Question: do we want to trust that the agent says it’s about to do vs what it will actually do?
How the identity trick works
Validating aauth:local@domain [spec]:
- The identifier’s
domainis the agent provider’s domain. - A verifier fetches
https://{iss}/.well-known/aauth-agent.json, requiresissuerto match the fetch URL byte for byte, and collects the provider’s JWKS. - It checks the agent token signature against that JWKS, then confirms the HTTP request signature uses the key in
cnf.jwk.
Trust is one JWKS per provider, not one key per agent. Nobody can mint aauth:foo@domain with a different key unless they can sign as that provider. Identifiers are compared exactly, and the local part must never be parsed for decisions, which will be a relief to anyone who has watched people parse email addresses with regular expressions.
A gap I noticed. I found no explicit verification step stating that the identifier’s domain must equal the iss host. The structure implies it. The verification list doesn’t say it. In security specs, “implies” is doing the work of a man holding a door with his foot.
Compared with classic PKI [spec]
- No CA, CDP, CRL or OCSP. The trust root is DNS plus TLS to the (agents) provider’s domain, which is Web PKI one hop removed.
- Nobody vouches for a provider. You prove you own a domain by serving a JWKS, and that is the whole interview.
- Revocation is push, not pull. The draft states that verifying a token doesn’t ask the issuer about it. A resource learns of a revocation only when one reaches its revocation endpoint. An agent token shown directly to a resource has no revocation path whatsoever; exposure is capped by its lifetime, 24 hours at most. Why not embrace the Universal Logout?
- The draft’s own advice is to issue shorter-lived tokens rather than count on revocation reaching every holder. Which is a gentle way of saying “pray less, expire more”.
- JWKS responses are cached (no refetching one issuer more than once a minute, entries dropped after 24 hours at most). A compromised provider key has no revocation mechanism; verifiers notice at their next refresh.
- The draft does not say which providers a resource should accept. An open resource accepts any domain that serves a valid JWKS. An allowlist is possible. Nobody specifies how to build or distribute one.
Where do the agent’s keys come from? [spec for the draft; inference for the gaps]
From the agent provider (the builder). How the agent proves itself to that provider is “platform-specific”, and lives in the informational bootstrap draft:
| Deployment | Per the bootstrap draft |
|---|---|
| Web app | Non-extractable WebCrypto keys in IndexedDB (software, not hardware); provider attests |
| Mobile | Durable key in Secure Enclave or Keystore; App Attest or Play Integrity at enrolment |
| Self-hosted | The user’s own domain acts as provider; no attestation, “the user is the trust anchor” |
| Desktop | Marked TBD |
| Server workload or container | Marked TBD (SPIFFE, WIMSE and cloud attestation named as future topics) |
| CLI, SaaS chatbot with no dedicated container, KMS-backed | Not covered |
The recommended pattern is a durable key held by the provider’s enrolment plus an ephemeral per-token signing key. A new durable key is a new agent, and the PS handles continuity. Sub-agents carry parent_agent and an identifier like planner.7f3c+search1, one level only. They never call the PS; the parent relays for them.
For a multi-tenant chatbot with no dedicated container, or for something like Claude Code subagents, the draft offers no recipe. A vendor acting as provider and minting ephemeral keys per session or subagent looks the natural fit. That is my inference, not anything the draft says. The draft is, at this point, a cliffhanger.
Who sees what, which turns out to matter rather a lot
The auth_token carries no agent identifier and no delegation chain (Appendix C.1.6 and C.1.11) [spec]. The resource sees a pseudonymous per-resource person sub, the PS, the tenant, the scope, mission_s256 and the signing key. It does not see which agent turned up.
NB: good luck selling this to enterprises.
The authors’ reasoning: naming the agent or provider would let resources pin policy to them and break the person’s portability across agents. An earlier act claim was removed because it served no reader and exposed the person’s tooling. The principle, in the draft’s words, is that the resource enforces (!!!) and the person server attributes. The PS holds the full chain, the agent-to-person binding, the mission log and the revocation records.
Exceptions: in the two-party modes the resource sees the agent token. In 4-party mode the AS receives it and can evaluate attestation or platform claims.
This is a genuinely interesting privacy position, and it also means the party who gets burgled is never quite the party who has the CCTV. Hold that thought.
Consent and missions [spec]
- The consent screen mixes resource-asserted content (name, description, scope descriptions) with agent-asserted content (the agent’s
justification,platform,device, clarification answers). The PS MUST visually distinguish them and MUST NOT decide on agent-asserted content alone where resource-asserted content covers the same operation. Sensible. - The user can ask questions through a clarification chat relayed to the agent, so you may now interrogate your software about its intentions. Do not expect it to crack.
- The mission hash makes the mission provable, in that the PS can’t later attach the identifier to different text. It does not tell the user what the agent will actually do. Resources and access servers see only the hash.
approved_toolsandapproved_resourcesare advisory. The draft says nothing in the protocol enforces them, and that the auth token is the only hard control on offer, covering remote resources only.- The draft puts it best itself: the agent chooses the words and gains from being believed. Quite so.
- Missions have two states, active and terminated. Mission control endpoints are deferred to a companion “supervision” spec that is still TBD.
How it stacks up against the incumbents
| OBO / token exchange | XAA / ID-JAG | SPIFFE / WIMSE | AAuth | |
|---|---|---|---|---|
| Principal | user, app as client | user plus client id | workload | agent plus person, kept separate |
| Trust anchor | one authorisation server | the enterprise IdP | a trust domain | DNS plus TLS of the provider and PS |
| Token | bearer (DPoP optional) | bearer access token from a grant | SVID or token per workload | signed every request, key-bound |
| Consent | up front, per app | admin policy decides ahead of time, no prompt | none | at runtime, per resource |
| Registration | per provider | client and resource AS must trust the IdP | within trust domain | none |
| Cross-domain | with federation work | yes, via the IdP | stops at the trust-domain boundary | the design goal |
| Multi-hop | act chains, loosely standardised | single hop; later hops lack a standard end-user credential [source] | via Transaction Tokens | upstream_token via the PS |
| Maturity | widely deployed | WG draft -06, shipping (Okta, Ping, Descope; clients Claude, VS Code) [source] | mature; AIMS draft -01 informational | individual draft -11, near-zero adoption |
XAA builds on RFC 8693 plus the RFC 7523 JWT bearer grant (Auth0, oauth.net). It is centralised and policy-first. Karl McGuinness argues ID-JAG carries a user and a client id but nothing tying it to a specific agent, deployment or task, and that later hops lack an end-user credential (notes). Those gaps are precisely what AAuth aims at.
WIMSE AIMS (draft-ietf-wimse-aims-01, informational; Defakto, AWS, Zscaler, Ping, Parecki) treats an agent as a workload and composes OAuth, Transaction Tokens and CIBA. This is the incumbent-friendly route, and it has the great virtue of not requiring everyone to rewrite everything.
“Why not just use OAuth?” The draft’s answer (Appendix C.4.5) [spec]
client_idmeans something only at the AS that issued it; AAuth identifiers are verifiable by anybody.- Pre-registration. In AAuth, the first API call is the registration.
- Bearer tokens versus key-bound signed requests.
- OAuth has no cryptographic resource identity; AAuth resources sign resource tokens.
- No missions, permission endpoints, audit logging or interaction relay in OAuth.
- In OAuth the AS always belongs to the resource owner; AAuth separates the person’s server from the resource’s.
The MCP example is the sharpest: OAuth 2.1 there needed DCR, which still leaves a different client_id per server, bearer tokens, no server identity and no governance. Fair cop.
The draft concludes that AAuth complements OAuth rather than burying it: resources can wrap OAuth infrastructure behind the AAuth-Access token, and PSes can delegate user authentication to OpenID Connect providers. On DPoP it is gracious, calling it the right choice for adding proof-of-possession to existing OAuth deployments. On GNAP it is less so, describing its generality as a liability.
Human approval: CIBA versus AAuth [spec/source]
| CIBA (Core 1.0) | AAuth | |
|---|---|---|
| Who asks | a client with a user hint calls the OpenID provider | the agent calls the PS (or the resource’s AS) |
| Channel | out-of-band to an authentication device | 202 with URL and code; PS may relay by push, tap or message |
| Result | tokens via poll, ping or push | auth_token bound to the agent’s key, via polling |
| What the user sees | binding_message matching both devices | agent-written mission or justification, labelled apart from resource-asserted scope text |
| Rich detail | RAR authorization_details | Markdown; the draft calls RAR “combinatorially explosive” |
| Anti-spam | optional user_code | interaction-code rate limit; nothing about a rogue agent flooding a PS |
| Scope | one client, one OP | cross-domain, chains across hops |
| Maturity | final, shipping (Auth0 Async Authorization) | draft |
For a single known client and provider, CIBA does the same job today. [inference] Do not let a good protocol talk you out of a working one.
What it’s good for
- Open-world agents that discover MCP servers or APIs at runtime, where DCR and per-server registration hurt like a dentist’s waiting room.
- Retiring API keys. No shared secret to leak; a stolen token without the private key can’t be replayed.
- Cross-domain delegation. The resource learns the person (pseudonymously) and the consented scope, and the person’s relationship survives a change of agent.
- Approval mid-task, treated as a first-class state rather than a sad afterthought.
- Incremental adoption. A resource can stop at merely knowing who the agent is.
- Privacy. Per-resource directed person ids mean resources can’t correlate a person across other resources by id.
Where it creaks
Trust and identity
- No provider vetting; a domain is the entire cost of an identity. No registry, no confusable-domain check, no lookalike language. I grepped for homograph, confusable, typosquat, spoof, impersonate and phishing and came back with nothing. The only related rule is that internationalised domains use ASCII A-labels.
aauth:copilot@microsoft.comand...@rnicrosoft.comare both valid, and both distinct. Spot the difference at 4:55pm on a Friday. - Consent is where lookalikes ought to be caught, and the screen is thin. On first contact the PS SHOULD show the provider’s name and logo (from provider metadata) plus agent-supplied
platformanddevice. The name and logo are written by the provider. The draft demands attribution for agent-asserted content, but not for provider-asserted content, and does not require showing or checking the domain. - A new lookalike is a first-time prompt. The PS keys agents by
(iss, sub), so each new identity is “a new-agent enrolment”, exactly the kind of prompt users scrutinise least. - In three-party mode the resource can’t help, since it never sees the provider.
- Attestation is delegated to the provider and is optional. A resource cannot verify it.
- The controls the draft permits but doesn’t require: organisation admin pre-authorisation of agents (one sentence), PS-side brand or reputation checks, resource-side provider allowlists in two-party modes. Do all of those and the model starts to look suspiciously like XAA.
Blocking a rogue agent
- In the two-party modes a resource can block by agent identifier, provider or key. Question: can it distinguish one instance from another?
- In 3-party and 4-party modes a decision keyed on agent identifier, in the draft’s phrase, holds in the two-party modes and nowhere else. In 3-party the resource has the signing key, the person
(iss, sub), thetenantand the PS. In 4-party the AS can evaluate the agent token. - A rogue agent that generates a fresh key looks like a new caller. Key blocks work only if new keys are hard to come by, which depends on the provider.
- The real controls sit at the provider (stop issuing, revoke; self-signed agents aren’t allowed) and the PS (deny, cascade revocation by agent identity, terminate a mission). Question: are they trying to re-invent an IdP and ship it as People Server (PS)?
- The draft defines no path for a resource to report misbehaviour back to the PS or provider. Revocation flows from issuers to holders, never the other way. The resource can shout, but nobody has been given an ear. Hint: ITP solutions and a shared signals framework.
- Local actions (tool calls, files, shell) are outside the protocol unless the agent volunteers to call the PS’s permission and audit endpoints, which the PS cannot enforce.
Auditability
- Auditable at the PS. Partial at the resource, which can say this key and this pseudonymous person did something, but not which agent.
- The audit endpoint is self-reported by the agent. An autobiography, then, rather than a witness statement.
- Signatures give request-time authentication, not long-term non-repudiation. Once a key leaves the provider’s JWKS the signature can’t be re-verified. Durable evidence means archiving verified artefacts and timestamping, and the measures, per the draft, trade privacy for durability.
Policy and centralisation
- Deterministic policy sits at resources and access servers; contextual supervision at the PS; agent governance at the provider. Missions are, in the draft’s words, intentionally not a machine-evaluable policy language.
- There is no enterprise policy plane in the spec. Central control exists only if the enterprise runs the PS and a provider, or an AS per resource. That product category does not exist yet. [inference]
- Compare XAA, where the enterprise IdP decides by admin policy before any user sees a prompt. AAuth moves that decision to a person at the consent dialog, or to each resource. [inference] One of these approaches assumes people read consent dialogs. I’ll leave you to guess which.
- The draft has a section titled “PS as High-Value Target” and calls the PS a sensitive data aggregation point. A compromised PS signing key forges identity claims for every resource that accepts it. Who runs the PS is left open; the charter lists identity providers, enterprises and consumer services. I do admire a document that labels its own crown jewels.
Abuse and denial of service
- No pre-registration means no registration gate. Any keypair can send a signed request.
- The draft does provide: a 60-second signature window, an optional replay cache (no nonce mechanism), mandatory egress admission before fetching issuer metadata, a JWKS fetch limit, interaction codes of at least 40 bits with rate limiting,
slow_downpolling, arate_limitedrevocation error, and thetenantclaim for refusing an abusive organisation. - There is no dedicated DoS section. An unknown provider can make you do an outbound metadata fetch and a signature verification before you can reject it. You’ll still want ordinary edge protection and a cap or allowlist for unknown providers.
- I found nothing against a rogue agent flooding a PS with approval requests. Prompt fatigue is raised by Aembit but not addressed by the draft. Anyone who has ever clicked “Allow” on a phone out of sheer weariness knows how this ends.
Local, in-house and headless agents
Partially covered. A self-hosted agent is its own provider, with a self-hosted platform value, self-issued tokens, static hosting of metadata allowed, and a minimal PS appendix (four required metadata fields, tap-to-approve consent, loopback-only PS relying on the OS).
Headless agents get identity-only and resource-managed access with no PS needed (default access_mode is agent-token), async approval through the 202 pattern, requirement=approval completing via push, email or admin review, and a workload platform value.
Supervision, the draft says, can shift from human review to agent evaluation without changing the protocol. If the PS has no channel to the user and the agent didn’t declare the interaction capability, it returns a terminal user_unreachable. Rather poetic.
Not covered:
- A self-hosted agent needs a domain with publicly reachable HTTPS metadata, and verifiers apply egress admission before fetching it. (That would be a showstopper #1 for me).
- Nobody vouches for you. An external resource using a provider allowlist will not have you on it.
- Provider key custody is on you. If it’s compromised, it “mints identities for the whole domain”.
- Bootstrap guidance for desktop, containers, CLIs, chatbots and KMS is TBD or missing.
- An agent with no PS is limited to identity-only and resource-managed access.
- No standard approval-policy language, and the supervision companion for automated approval is TBD. A budgets draft is chartered for 2028. For genuinely unattended agents, the practical answer today is identity-only access plus pre-approved missions, which is to say no human safety net at all.
| Agent type | Fit |
|---|---|
| Vendor-published agent | Best fit: vendor is provider, with attestation and revocation |
| In-house agent calling your own resources | Works: you run provider and PS |
| In-house agent calling third-party resources | Weak: your provider is a stranger to them |
| Local developer agent (CLI, IDE) | Possible via self-hosted; bootstrap guidance missing |
| Ephemeral subagent | Covered (one level, parent-mediated) |
| Container or server workload | TBD |
Maturity and politics
- Near-zero deployed base [source: API Evangelist]. No support in Claude or ChatGPT as AAuth resources [source: Aembit].
- It needs every party (clients, resources, gateways) to implement signing and new flows. Aembit is unsure whether it ships as-is or gets folded into OAuth/OIDC extensions.
- Overlap with Token Exchange, Transaction Tokens and CIBA is “real and unresolved” [source: API Evangelist].
- Draft churn: revision 11, six chartered specs, interoperable behaviour unlikely before 2028.
- Critics exist. One commenter on Hardt’s post argues one identity per agent breaks down when agents spawn sub-agents. McGuinness asks whether missions can enforce limits across parties or merely tag work for correlation, and argues adoption depends on a surrounding stack hiding the mechanism, as SSPI hid Kerberos.
- Third-party coverage is mostly favourable explainers. I found no hostile critique, which in this industry is either a sign of quality or of a very quiet fortnight.
What I’d watch
- The OIDF AAuth working group: charter approval, and whether the Q2 2027 Implementers Draft actually happens. Also where the IETF OAuth WG lands.
- Okta, Auth0, Ping: any support for agent-key or signed-request authentication, or an AAuth-compatible PS role. That would mean convergence.
- WIMSE AIMS plus Transaction Tokens plus ID-JAG: does this stack close the gaps AAuth names (runtime consent, cross-domain delegation, signed requests)?
- XAA’s roadmap: McGuinness’s proposals, Agent Principal Profiles and Identity Continuation Assertion, look like the likely route for ID-JAG to deal with agent identity and later hops.
- Provider trust and PS products: will anyone ship a provider registry, allowlisting or lookalike detection? That decides whether open-world AAuth is safe for anyone who isn’t an enterprise.
- The supervision companion spec (Q3 2027 target), which would define automated approval and mission control.
- Gateways and MCP clients: do they ship signing and verification? A rollout hidden from developers is the realistic adoption path.
- Claude and ChatGPT as clients: neither supports AAuth today, and their stance will matter more than the spec text.
My view [inference]
XAA’s strengths are central admin control and an ecosystem that is shipping. AAuth’s gap is exactly the lack of a central policy plane and provider vetting. For enterprise customers, XAA plus SPIFFE already covers in-house agents, and AAuth adds little until the SPIFFE/WIMSE bridge and the supervision spec turn up.
The safe way to deploy AAuth in an enterprise is an enterprise-run PS that pre-authorises providers. That moves the model rather close to XAA and removes much of the pitch, which is a bit like fitting a gate to a very open field and then noting how much the field now resembles a garden.
If Okta wanted a role in an AAuth world, the natural one is the enterprise PS, where it already sits for XAA. That is an observation and not a statement of anyone’s product plan.
Sources
aauth.dev · draft-hardt-oauth-aauth-protocol · dickhardt/AAuth · bootstrap draft · OIDF AAuth WG charter · Posta deep dive · Aembit · API Evangelist · Apideck · Auth0 on ID-JAG · oauth.net Cross-App Access · draft-ietf-wimse-aims · Auth0 async authorization · Okta Cross App Access · OpenID CIBA Core · McGuinness notes · Hardt interview