Skip to content
IAM Insights

Explainers · Glossary

AAuth (Hardt)

AAuth · AAuth Protocol · draft-hardt-oauth-aauth-protocol

By Boston Identity · Explained · 6 min read

The short answer

AAuth is a draft protocol that gives each AI agent its own signing key and identity. The agent signs every API call instead of sending a shared secret, and brings in a person's consent when the API asks.

What it is
A protocol
Defined by
Individual IETF Internet-Draft (-11), not adopted
Who it's for
Teams letting agents call APIs across companies
In our briefings
20By month of the source: 2025-12: 0, 2026-01: 0, 2026-02: 0, 2026-03: 2, 2026-04: 1, 2026-05: 0, 2026-06: 0, 2026-07: 1, 2026-08: 0, 2026-09: 8, 2026-10: 4, 2026-11: 11by month, last 12
01

What is AAuth (Hardt)?

AAuth is an Internet-Draft written by Dick Hardt of Hellō. It is a draft, not yet a standard, and its header lists no Internet Engineering Task Force (IETF) working group.S1 It defines how an agent gets access to a resource, meaning an API or data set the agent wants to use.Abstract

The draft starts from a gap in OAuth. An OAuth client has no identity of its own: a client ID issued by Google means nothing at GitHub.§1.1 API keys go further down the same road. They are shared secrets copied to wherever the software runs, and the draft argues that such a secret will end up somewhere it should not be.§1.1 Agents make this harder, because they find services at run time and need decisions in the middle of long tasks.§1.2

AAuth's answer is that every agent holds its own key. Each request carries an HTTP Message Signature (RFC 9421), so none of its tokens is a bearer token, one that works for whoever holds it.§1.3 No pre-registration is needed either: the first call to a resource is the registration.§1.3

AAuth is not an OAuth extension, despite "oauth" in the draft's file name. No IETF group has adopted it, and its appendix argues that OAuth cannot be extended to fit agents.2

02

How does AAuth (Hardt) work?

The agent works for a person and deals with up to four servers. Its agent provider (AP) issues its identity, and the resource is the API it calls. The person server (PS) speaks for the person, and an access server (AS) is a policy engine some resources run.§3

Figure steps
  1. The agent gets its identity
  2. The agent signs every call
  3. The resource asks who the person is
  4. The resource writes down what it needs
  5. The person server gets consent
  6. The agent calls with the auth token
Fig. 1

How an AAuth agent gets its identity, signs its calls and brings in a person's consent when a resource asks.

Drawn from the AAuth draft -11, sections 4 to 7

Swipe for the full figure →

  1. The agent gets its identity

    The agent makes its own key pair and proves itself to its agent provider in a way that depends on the platform. The provider then issues an agent token, a signed JSON Web Token (JWT) that binds the key to an identifier of the form aauth:local@domain.§4.1 Agent tokens should not last more than 24 hours, so the provider decides at least daily whether to keep vouching for the agent.§5.1

  2. The agent signs every call

    The agent signs each request with its key and attaches the agent token. A resource may stop here and grant or deny access based on which agent is calling. The draft says this mode replaces API keys with cryptographic identity.§4.2.1 A resource may instead run its own login or existing OAuth flow, then give the agent a session token that must not work without the agent's signature.§6.2, §6.3

  3. The resource asks who the person is

    When the resource needs to know who the agent works for, it answers 401 and asks for a person token.§6.4 The agent gets one from its person server. That token names one resource, lasts at most an hour and must not carry any scope.§7.1.2 It promises continuity, meaning the same person over time, and says nothing about identity proofing.§7.1.1

  4. The resource writes down what it needs

    For access beyond identity, the resource issues a resource token. This JWT ties together the resource, the person, the agent's key and the scope requested.§6.7 It should not live longer than five minutes.§6.7.1

  5. The person server gets consent

    The agent carries the resource token to its person server, which may ask the person to approve. The server must show the agent's stated reason as the agent's own claim, set apart from what the resource said.§7.4 If the resource runs an access server, the person server federates with it and the access server issues the auth token; otherwise the person server issues it.S1

  6. The agent calls with the auth token

    The agent signs its next request and presents the auth token, which is bound to the same key.§5 The resource can ask for more at any time with a new resource token, and agents must be ready for that step-up.§6.5 There is no refresh token. When an auth token expires, the agent starts again with a fresh resource token, so the resource has a say every time.§7.9

03

Why does AAuth (Hardt) matter now?

AAuth's premise is that OAuth clients and API keys have no identity of their own. It also holds that workload identity schemes such as SPIFFE and WIMSE (Workload Identity in Multi-System Environments) stop at the edge of one trust domain.1 One outside design names it. Eve Maler's UMA for Agents, an extension of the User-Managed Access (UMA) standard that sets terms at the resource, would have agents identify themselves through AAuth or one of several similar methods, and she calls the work really early.3 Hardt has also written companion drafts on top of the base protocol. R3 lets an agent ask for an API's named operations instead of scope strings.4 Budgets caps what an agent may spend at each resource.5

The token a resource finally receives says who the person is and what was granted, but not which agents carried the request; that chain is kept at the person server.6 Uber, the Cross App Access draft and the IETF's workload identity architecture all carry the chain or the narrowing in each hop instead.6

Its standing is weak. After twelve revisions it is still an individual draft, and its four listed implementations are all marked exploratory.2 We forecast that no IETF working group adopts it by 30 September 2027.7

04

Where does it fit?

Compared withHow AAuth (Hardt) differs
OAuthIn OAuth, each server issues a client its own identifier, which means nothing anywhere else.§1.1 In AAuth the agent's identifier and key belong to the agent, and any party can check them without pre-registration.§1.1
WIMSE ArchitectureThe WIMSE work lets workloads prove who they are without shared secrets, but inside one enterprise's trust domain.§1.1 AAuth aims at agents that cross company lines. On delegation they part ways: the WIMSE architecture requires every hop to narrow scope, and AAuth keeps the chain out of the token.6
HTTP Signature KeysHTTP Signature Keys is the layer underneath, which binds signing keys to JWTs and lets servers find them.§1.3 That layer proves possession of a key, but on its own it does not say who an agent works for.8
DPoPAAuth's appendix argues that Demonstrating Proof of Possession (DPoP), along with OAuth, the Grant Negotiation and Authorization Protocol (GNAP) and mutual TLS, cannot be extended to agents.2 It binds each request to the agent's own key with an HTTP Message Signature instead.§1.3
05

What goes wrong?

  • The person server holds the most risk. The draft says a compromised person server could affect all the agents and missions it manages.9
  • A person token fails open if a resource does not check its type, and the draft says deployments should test this case.9 Only the token's type header tells a person token from an auth token.§7.1.4
  • Revocation may not arrive. Every endpoint that receives a revocation message is a should, so a server without one honors a revoked token until it expires.10
  • Authority need not shrink. When one agent passes work to another service, the downstream scope need not be a subset of the upstream scope.6
  • Missions are for people to read. A mission is Markdown text the person approves, and the draft says it is not a machine policy language.11 Nothing in the protocol enforces a mission's list of pre-approved tools.§8.2
  • Device checks are optional. The bootstrap guide makes device attestation optional throughout.12
06

What should a security leader ask?

  1. 01

    Which of our APIs would serve an agent on its identity alone, with no person token behind the request?

  2. 02

    Who would run the person server for our staff's agents, and what happens at every resource if its signing key leaks?

  3. 03

    Do our resources check the token type on every request, so a person token can never stand in for an auth token?

  4. 04

    How long do the tokens we accept live, given that a revocation may never reach us?

  5. 05

    When a request reaches us, can we see which agents passed it along, or only the person and the grant?

07

Sources

›Evidence: 12 claims from 6 briefings
  1. 1BI-FIND-2026-0365 · AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeAAuth's premise is that an OAuth client or an API key has no identity of its own and that SPIFFE and WIMSE stop at one trust domain, so it gives each agent one: an identifier of the form aauth:local@domain issued by an Agent Provider and bound to an Ed25519 key by a short-lived agent token, so that 'every agent has its own cryptographic identity' and 'the first API call to a resource is the registration'. No credential in the protocol is a bearer credential; every request is signed, and a resource can challenge for more at any time. In its lightest mode the draft pitches this as a drop-in for API keys: 'this replaces API keys with cryptographic identity.' What an agent token attests about the software behind the key is left to companion specifications.
  2. 2BI-FIND-2026-0369 · AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeAfter twelve revisions AAuth is an individual submission with 'Workgroup: TBD' in its header; the datatracker lists it as not endorsed by the IETF and no adoption is stated in the text, despite the oauth in its filename. Four implementations are listed, Hellō's own TypeScript, .NET samples, a Python demonstration and a Keycloak extension, every one at 'Level of maturity: exploratory', with no interoperability event or production deployment. The appendix argues that OAuth, GNAP, DPoP and mTLS cannot be extended to agents and that MCP's experience with dynamic client registration proves it, and it never mentions the working-group drafts that cover the same ground, the identity-assertion grant and identity chaining among them. The draft's own supervision, mission-control and event specifications are TBD or on GitHub.
  3. 3BI-FIND-2026-0889 · Eve Maler says the push to give every AI agent a responsible human misses agents a company does not ownMaler says the field's focus on making sure every agent has a responsible human misses agents a company does not own: "Bob's bot seeking to access Alice's or Alice Corp's stuff." Her answer is UMA for Agents, which she describes as a profile and extension of the UMA standard in which the resource owner sets terms that stay in force when she is not around, using MyTerms (IEEE 7012) extended for agent permissions, one of which can be "ask me". Agents would identify themselves through AAuth or one of several similar methods. The design is resource-centric: borrowing zero trust's protect surface, she says a company need not inventory every agent, only set conditions at the resources worth protecting. There is an open-source implementation at u4a.ai, and in her words it is "really early, and we don't know where we're going with it."
  4. 4BI-FIND-2026-0540 · AAuth's R3 lets an agent ask for an API's named operations, and a person approve one exact callR3 replaces scope strings with operations the resource itself names. A resource lists the vocabularies it speaks (MCP, OpenAPI, AsyncAPI, OData and three more); the agent requests operations by those names; the resource answers with a JSON document describing them, including a plain-language summary, what data is touched and what cannot be undone, identified by the SHA-256 of its exact bytes. The person's server shows that description for consent, the issuer writes the granted operations and the hash into the access token, and the resource enforces from the token alone: "No token introspection or R3 document fetch is needed at enforcement time." The agent sees only the hash and its own grant, never the document.
  5. 5BI-FIND-2026-0538 · Hardt's AAuth Budgets caps what an agent may spend at each resource, and hides the person's real limit from itHardt treats a spending budget like scope: "A budget is an authorization, not a hint." The agent asks, the resource sets the unit and may lower the amount, and the person's server and the access server may only lower it further, never change the unit. The resource then enforces the amount as a hard cap on that one access token, reserving a request's maximum cost and committing the actual cost afterwards. The person's overall ceiling appears on no token and "may not be shared with the agent", on the argument that "a ceiling the agent can read is a ceiling the agent plans against". So the person's server is not in the request path; it supervises only when the agent comes back at expiry or exhaustion to ask for more.
  6. 6BI-FIND-2026-0366 · AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeThe token a resource finally receives says who the person is and what was granted, and nothing about which agents carried it. 'An auth token carries no agent identifier and no delegation chain'; the chain lives at the Person Server, which logs it, and an earlier revision's chain claim was removed. Sub-agents are one level deep and call chaining passes an upstream token whose 'downstream scope need not be a subset' of the upstream one, though an auth token's scope 'MUST NOT be broader' than the resource token it answers. That is the opposite design from the one the rest of the field is converging on: Uber ships a per-hop actor chain inside the token, the Cross App Access draft puts the agent as actor into the assertion, and the IETF's workload-identity architecture requires every hop to re-scope. AAuth answers the question of whether authority shrinks per hop with: not in the token, and not necessarily.
  7. 7BI-CALL-2026-0062 · AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeNo IETF working group adopts AAuth as a working-group document by 30 September 2027. Twelve revisions over the draft's life have not produced an adoption call, the header still reads 'Workgroup: TBD', the OAuth group is advancing its own agent drafts on the opposite design, and the only implementations are exploratory. An adoption call that succeeds in any group before that date settles this wrong.
  8. 8BI-FIND-2026-0767 · The signing-key draft under AAuth offers eight ways to trust a key, and only one says who the agent works forHardt and Meunier's draft adds a Signature-Key header so a signed HTTP request carries the key that signed it, and lets the parties pick how the server comes to trust that key: 'The trust model is a scheme, not a fixed choice.' There are eight schemes, from a bare public key and a key thumbprint to a published key set, an X.509 chain and a JWT. Only the JWT scheme describes 'instances act on behalf of an authority', an issuer vouching for the signer, and how that JWT is obtained is left out. For the thumbprint scheme the draft says it 'provides pseudonymous identity, not verified identity'. The layer AAuth stands on proves possession of a key; on its own it does not say who an agent works for.
  9. 9BI-FIND-2026-0370 · AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeThe draft's security section names its own concentration of risk. 'Compromise of a PS could affect all agents and missions it manages', because the Person Server's signing key can forge identity for every resource; a person token 'fails open' if a resource does not check its type, and 'Deployments SHOULD test this case explicitly'; agents are bound to one person each, incremental consent can erode scope over time, and key rotation costs non-repudiation. The draft also says 'No single party is the policy decision point', which is true of the protocol and not of the deployment, where the Person Server is where the chain, the missions and the audit all live.
  10. 10BI-FIND-2026-0368 · AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeRevocation is a signed message keyed by issuer and token identifier that cascades from Agent Provider to Person Server to Access Server to resource, and every endpoint that receives it is a SHOULD. The draft states the consequence itself: 'A server without one honors a revoked token until its exp.' The protection is the lifetimes, five minutes for a resource token, an hour for person and auth tokens, up to a day for an agent token, which is also the answer the OpenID Foundation's whitepaper gave when it called revocation across agent chains unsolved.
  11. 11BI-FIND-2026-0367 · AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeAAuth's version of intent is a document. A mission is Markdown the person approves, hashed into every downstream token as mission_s256 and logged by the Person Server; the draft says it is 'not a machine policy language', that 'Missions do not change; they accumulate context', and leaves the Markdown structure and the mission-control endpoint to later revisions and companion specifications. The person token that anchors it 'MUST NOT contain scope or account' and promises 'continuity', not identity proofing. For the open question of whether intent is a new access-control primitive or attribute-based access control renamed, this draft's answer is neither: intent is an audit artefact that travels with the token for a human to read later.
  12. 12BI-FIND-2026-0688 · AAuth's bootstrap guide makes device attestation optional and lets a new key mean a new agentThe AAuth bootstrap draft, revised to -02 on 28 September, tells implementers how an agent gets its first key and token on each platform, and binds them to nothing. It removed every normative requirement after -00. Device attestation is optional throughout: a phone app's agent provider "typically" checks Apple App Attest or Google Play Integrity, a browser agent's keys are protected only by the sandbox, and a self-hosted agent publishes one key with no attestation or enrollment step. Rotating that long-lived key creates a new agent identity, although the core AAuth draft says an agent's identifier stays stable across rotations. Revoking an enrollment stops the next token but not the current one, which a resource that took it directly honors until it expires.

›In our briefings

The claim each of the newest briefings on AAuth (Hardt) would have you leave with.

  1. AAuth's premise is that an OAuth client or an API key has no identity of its own and that SPIFFE and WIMSE stop at one trust domain, so it gives each agent one: an identifier of the form aauth:local@domain issued by an Agent Provider and bound to the agent's own signing key by a short-lived agent token (the draft recommends Ed25519, which every party must support), so that 'every agent has its own cryptographic identity' and 'the first API call to a resource is the registration'. No credential in the protocol is a bearer credential; every request is signed, and a resource can challenge for more at any time. In its lightest mode the draft pitches this as a drop-in for API keys: 'this replaces API keys with cryptographic identity.' What an agent token attests about the software behind the key is left to companion specifications.

    AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeBI-FIND-2026-0365

  2. Six voices say that knowing who an agent is and what it may access does not settle whether its next action is right, so the check has to look at what the agent is doing while it runs. Steven Rennick of Ciena says "we might know who the agent is and what it's allowed to do, but we really don't know how it's going to make those decisions," so trust has to become continuous and work at runtime. Sathvik Krishnamurthy, an investor with Security Leadership Capital speaking on Entrust's podcast, says identity and zero trust do not control an agent's behavior, and that a layer on top of them has to. Josh Woodruff of the Cloud Security Alliance and MassiveScale AI says zero trust checks who you are and what you can reach, and agents need one more check on every action: what are you doing right now, and is it allowed? Michael Davis of JPMorganChase says most detective controls only ask whether a tool call is allowed, and wants security to look at the actions themselves, not just the permissions. Sagar Batchu of Speakeasy retells an agent that deleted a production database with a valid full-access token: it "had valid credentials, but it didn't have valid intent." Dror Zelber of Radware wants each action compared with the agent's stated intent and goals, and blocked when they do not match. A seventh voice, Maia Iyer of IBM Research, describes the idea behind one such check, which could flag an outgoing call the user never asked for, and calls checks of this kind a soft layer for defense in depth. They differ on how much intent can carry. Rennick and Zelber would judge each action against the agent's intent. Woodruff says the checkpoint must be able to refuse an action whatever the intent was, because an agent with the right intent can still do damage. Rennick adds that judging actions by their outcomes as well is the desired end state, but he does not think the technology is there yet.

    Knowing who an agent is and what it may reach is not enough, six voices say: check each action as it runsBI-FIND-2026-2330

  3. Davis says JPMorgan has, "for certain cases", removed an agent's ability to read an email and send it in the same session, because the bank does not want those toxic combinations for that type of user with that agent. He raised it while agreeing with the host's example of an MCP server built without a delete tool: "We've done very similar." He goes on to say it is hard to design a permission system that is intuitive to people, readable by machines and verifiable. We read the session cut as a workaround for that gap.

    JPMorgan won't let some agent sessions read and send email at once, says its security architectBI-FIND-2026-1971

›Cited in 20 briefings

Every briefing that discusses this term, newest first.

  1. AAuth gives every agent its own key, then keeps the delegation chain out of the token on purpose

    Draft · · IETF Datatracker · Dick Hardt, Hellō · Sep 25, 2026

  2. Knowing who an agent is and what it may reach is not enough, six voices say: check each action as it runs

    Field signals · · 14 voices from the field · Dec 2025 to Nov 2026

  3. JPMorgan won't let some agent sessions read and send email at once, says its security architect

    Podcast · · Insecure Agents · "Is This Tool Call Allowed? It's Never That Simple": Michael Davis (J.P. Morgan) · Sep 9, 2026

  4. Secure the action, not just access: CSA's Josh Woodruff on the Agentic Trust Framework and AARM

    Podcast · · Insecure Agents · Governance Is the Accelerator: Josh Woodruff (CSA) on Getting Agents Out of Pilot Purgatory · Oct 21, 2026

  5. Barclays mandates one gateway for its agents' budgets, blocks and audit, and its AI engineering director says the setup is not yet tested at scale

    Podcast · · Insecure Agents · The Fishbowl Problem: Agent Identity Across Clouds and Vendors, with Andy McMahon (Barclays) · Oct 5, 2026

  6. AAuth carries the signals an agent's approval needs, Hardt says; the brain that decides does not exist yet

    Podcast · · Collateral Dialogue · Self-Driving Software: What OAuth Can’t Do for AI Agents | Dick Hardt, Hello · Sep 2, 2026

  7. Eve Maler says the push to give every AI agent a responsible human misses agents a company does not own

    Podcast · · Identity at the Center · #453 - Treating Identity Like a Product with Eve Maler · Oct 12, 2026

  8. The PEDIGREE draft has verifiers re-check every ancestor of an agent's token, without saying how to fetch them

    Draft · · IETF Datatracker · Karthik Rampalli, Glyphzero Labs · Apr 25, 2026

  9. OpenA2A's draft aims to keep secrets from the agent, and says no implementation yet supports its new controls

    Draft · · IETF Datatracker · Abdel Fane, OpenA2A · Oct 2, 2026

  10. The signing-key draft under AAuth offers eight ways to trust a key, and only one says who the agent works for

    Draft · · IETF Datatracker · Dick Hardt et al. · Sep 13, 2026

  11. TPX replaces an app's embedded AI provider key with a capped, metered grant the user approves at their provider

    Article · · tokenpony.dev · Alex Polvi · Jul 20, 2026

  12. AAuth's bootstrap guide makes device attestation optional and lets a new key mean a new agent

    Draft · · IETF Datatracker · Dick Hardt, Hellō · Sep 28, 2026

  13. AAuth's R3 lets an agent ask for an API's named operations, and a person approve one exact call

    Draft · · IETF Datatracker · Dick Hardt · Sep 28, 2026

  14. AAuth Events gives an agent an inbox, and the subscription tells the resource which agent is listening

    Draft · · IETF Datatracker · Dick Hardt · Sep 28, 2026

  15. Hardt's AAuth Budgets caps what an agent may spend at each resource, and hides the person's real limit from it

    Draft · · IETF Datatracker · Dick Hardt · Sep 28, 2026

  16. Cisco's SD-Card puts an A2A Agent Card in a selective-disclosure token, and leaves its registry out of scope

    Draft · · IETF Datatracker · Suhas Nandakumar et al. · Mar 2, 2026

  17. Mission-Bound OAuth's author now says the mission object does not belong in OAuth

    Article · · Control Plane by Karl McGuinness · Karl McGuinness · Mar 15, 2026

  18. Rosenberg and White's AAuth now has the resource server, not the agent, write and sign the approval text

    Draft · · IETF Datatracker · Jonathan Rosenberg et al. · Oct 20, 2025

  19. Agentic JWT binds an agent's token to its task and its own code, but it is one author's draft, not a standard

    Paper · · arXiv (cs.CR preprint 2509.13597) · Abhishek Goswami · Sep 16, 2025

  20. In GNAP (RFC 9635), a client is known by its key, and tokens stay key-bound unless the server flags them bearer

    Article · · RFC Editor · Justin Richer et al. · Oct 1, 2024

In our columns

  1. An agent kill switch stops what crosses your gateway. Elsewhere, tokens run until expiry

    Column · Oct 11, 2026

  2. Agent tokens leave out who acted, so keep the log where agents can't reach it

    Column · Oct 5, 2026

Related terms

What appears alongside AAuth (Hardt) in the same briefings.

AAuth BudgetsHellōHTTP Message SignaturesGNAPHTTP Signature KeysDPoPCross App AccessOAuth

Was this explainer useful?

Share this explainer

Pass it on. Every claim has a permanent number, so what you share today still points at the same words next year.