| Internet-Draft | Agent Authenticator | November 2026 |
| Ganesan | Expires 19 May 2027 | [Page] |
This document specifies the Agent Authenticator, a mechanism that lets autonomous software agents, such as AI coding agents, authenticate to services with properties comparable to passkeys: keys held in secure hardware, no shared secrets, binding to the service's origin that a manipulated agent cannot override, attested execution environments, and explicit human approval of each agent and of high-risk actions. The same protocol serves agents on personal computers and in cloud environments. It is a profile over existing mechanisms rather than a new identity system: it uses OAuth 2.0 Token Exchange, the Identity Assertion JSON Web Token (JWT) Authorization Grant, and Model Context Protocol (MCP) authorization, and it binds each agent action to a signed, tamper-evident record.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
Software agents built on large language models increasingly act on behalf of people when using services such as code hosts, package registries, model APIs, MCP servers and cloud platforms. This document specifies how an agent authenticates to those services with properties comparable to passkeys, without giving the agent any secret it could leak. It defines one new component, the Agent Authenticator, along with its data formats, ceremonies and bindings to existing OAuth, MCP, git and cloud mechanisms.¶
The mechanism is designed to meet the following goals:¶
The following are out of scope: replacing OAuth, OpenID Connect or WebAuthn; agent-to-agent messaging; and assessing whether an agent's output is correct.¶
Coding agents today authenticate with the same bearer secrets humans use (PATs, API keys, npm tokens, cloud keys), stored where the model, its subprocesses and any malware can read them. The incidents below, all reported in 2025 or 2026, illustrate the resulting failures.¶
| Incident (date) | What happened | Root cause | Property |
|---|---|---|---|
| GitHub MCP prompt injection (May 2025) | A malicious issue in a public repo made an agent pull private repo data and publish it in a public PR | Broad PAT covering every repo the user can reach | P8 mandate scopes repos and actions; P5 step-up for cross-repo writes |
| Comment and Control (Apr 2026) | One PR title hijacked several CI coding agents, which leaked repo secrets back through GitHub itself | Secrets ambient in the agent's environment | P2 model never holds secrets; P8 review agents get no write or secret scopes |
| Six coding-agent exploits (2025-2026) | Branch names stole tokens; repo settings files skipped trust dialogs; sandboxes were escaped | Controls lived inside the agent and could be bypassed from repo content | AA enforces policy outside the agent; P9 every agent registered and tied to a human |
| Nx s1ngularity (Aug 2025) | Malicious package versions harvested 2,349 credentials from 1,079 developer machines, using local AI CLIs to hunt for secrets | Tokens and keys readable on disk by any local process | P1, P2 nothing to steal; AA signs only for processes it launched |
| Shai-Hulud worm waves (Sep 2025 - Oct 2026) | Self-propagating worm steals npm and GitHub tokens and republishes itself into every package the victim maintains | Long-lived publish tokens usable from any machine | P7 no exportable credentials; publish requires ha
|
Sources: [INVARIANT], [CSA-CI], [VB-EXPLOITS], [NX-LEAK] and [SHAI-HULUD].¶
| Standard | What it gives | What is missing for agents |
|---|---|---|
| WebAuthn / passkeys | Phishing-resistant, hardware-bound keys | Needs a human gesture on every use; no programmatic enrollment |
| OAuth 2.1 / MCP authorization | Scoped, expiring tokens; standard discovery | Bearer tokens by default; no binding to a device or attested environment |
| ID-JAG / Cross App Access | IdP decides which apps an agent may reach | Based on the user's session; no proof of where the agent key lives or that a human approved it |
| Workload identity (SPIFFE, WIMSE, cloud federation) | Secretless identity for cloud workloads | Cloud-centric; no human approver; weak fit for laptops |
| Secret vaults and proxies | Keep secrets out of the model's context | Still bearer secrets underneath; no standard format, origin binding or attestation |
The author is not aware of an existing standard that combines hardware-bound keys, origin binding that survives prompt injection, a human-signed scope, environment attestation, and a single protocol for local and cloud agents.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
The architecture involves the roles listed below. Of these, only the Agent Authenticator is introduced by this document.¶
| Role | What it is | Passkey analog |
|---|---|---|
| Human approver | The accountable person who owns or delegates to the agent | User |
| Approver authenticator | The human's passkey device (phone, laptop, security key) | Authenticator |
| Agent | The model-driven process (coding agent, its subprocesses and tools) | None (untrusted caller) |
| Agent runtime | The harness that launches the agent and owns its network connections | Browser / client |
| Agent Authenticator (AA) | Daemon that holds agent keys in secure hardware, enforces mandates, signs assertions and action records | Authenticator |
| Relying party (RP) | Service the agent calls: code host, package registry, model API, MCP server, cloud | Relying party |
| Identity provider (IdP) | Enterprise policy authority, such as a single sign-on provider | None |
| Evidence pipeline | Local sealed log, SIEM and a SCITT transparency service | None |
+--------------------+
| Enterprise IdP |
| policy, revocation |
+---------+----------+
| token exchange
| (ID-JAG)
+-----------+ call +---------------+ assert. +--------------------+
| Agent |------->| Agent runtime |-------->| Relying parties |
| (no keys) | | sets origin | | GitHub, npm, MCP |
+-----------+ +---+-------^---+ +--------------------+
sign | | signed
request v | assertion
+-----------+ approval +---------------+ revocation (SSF/CAEP)
| Human |----------->| Agent |<------------- from IdP
| (passkey) | | Authenticator |
+-----------+ | keys in HW |
+---------------+
The agent can request a signature but never receives a key. The runtime supplies the origin of each request from its own connection state, and only the Agent Authenticator holds keys. Where an IdP is present, it remains the policy authority and can revoke an agent's access.¶
This document uses the following terms:¶
The following table compares the security properties of passkeys with those of this mechanism. Properties P8 to P10 have no counterpart in passkeys.¶
| # | Property | Passkeys | This specification |
|---|---|---|---|
| P1 | No shared secrets | Public-key challenge-response | Same; RPs store only public keys |
| P2 | Key non-exportable | Platform or roaming authenticator | TPM, Secure Enclave, StrongBox, TEE or attested cloud KMS; model process never sees keys |
| P3 | Origin binding | Browser sets origin; key scoped to RP ID | Runtime sets origin from the TLS connection; key scoped to RP ID; model output can never choose it |
| P4 | Attestation | Optional authenticator attestation | Required environment attestation, normalized to assurance levels |
| P5 | Presence / verification | UP and UV flags | MB flag (acting within mandate) and HA flag (human approved this action) |
| P6 | Clone detection | Signature counter | Signature counter plus action-record chain head in every assertion |
| P7 | Sync | Passkeys may sync | Agent credentials are never synchronized; in the cloud profile they are destroyed when the task ends |
| P8 (new) | Scoped authority | None | Mandate: RP list, actions, resources, expiry, minimum assurance |
| P9 (new) | Accountability | None | Every assertion names its human approver and mandate hash |
| P10 (new) | Identity-bound evidence | None | Every authorized action yields a signed, hash-chained action record |
P3 is the property that most directly addresses prompt injection. If an agent is instructed to send a credential to a server controlled by an attacker, it cannot do so: no credential exists for that origin, and the agent has no way to set the origin itself.¶
The mechanism uses four keys. None of them is accessible to the agent process.¶
| Key | Held by | Created | Lifetime |
|---|---|---|---|
| Approver key | Human's passkey authenticator | Normal WebAuthn registration with the IdP or RP | Long-lived; device-bound passkey RECOMMENDED for approvals |
| AA identity key | AA secure hardware | AA install or cloud environment boot | Life of the device or environment |
| Agent credential key | AA secure hardware | Per agent instance, per RP | Local: until revoked or mandate expiry. Cloud: one task |
| Evidence signing key | AA secure hardware, separate from credential keys | With the AA identity key | Rotated per epoch, forward-secure |
Verifiers MUST base policy decisions on the normalized assurance level defined below, rather than on vendor-specific attestation formats.¶
| Level | Meaning | Example evidence |
|---|---|---|
| AL3 | Keys in a TEE that also isolates the agent's code; runtime measured | AWS Nitro, Intel TDX, AMD SEV-SNP, Arm CCA attestation report |
| AL2 | Keys in dedicated secure hardware; host software not isolated | TPM 2.0 key attestation, Apple App Attest, Android StrongBox key attestation |
| AL1 | Keys in a platform keystore without hardware isolation, or cloud workload identity only | Android TEE-only keystore, cloud instance identity document, SPIFFE SVID |
| AL0 | Software key | None |
The AA converts vendor evidence into an Entity Attestation Token [RFC9711] carrying al, platform, key-protection claims and a freshness nonce. A RATS [RFC9334] verifier appraises it; a separate EAT profile is expected to standardize the mapping.¶
A passkey that is synchronized between devices authenticates the person but does not identify the device that was used. Approvals that require device binding (Section 6.3) MUST use a device-bound authenticator or carry a separate platform device attestation.¶
All structures are JSON Web Signatures [RFC7515] for HTTP and OAuth bindings, with a COSE [RFC9052] encoding for constrained and SSH bindings.¶
The mandate is signed by the human approver.¶
{
"typ": "agent-mandate+jwt",
"iss": "<IdP or approver identifier>",
"sub": "<human id>",
"agent_cred": { "jkt": "<agent key thumbprint, RFC 7638>" },
"aa": { "id": "<AA identity key thumbprint>", "min_al": "AL2" },
"rps": ["code.example", "registry.example", "mcp.example"],
"authorization_details": [
{ "type": "git", "actions": ["push"],
"locations": ["code.example/acme/api"],
"refs": ["agent/fix-*"] },
{ "type": "mcp", "tools": ["jira.read", "jira.comment"] }
],
"step_up": ["merge", "publish", "secrets.read", "delete"],
"delegable": false,
"exp": 1762480000
}
¶
The jkt member is a JWK Thumbprint [RFC7638]. The approver signs the mandate through a WebAuthn [WebAuthn] assertion whose challenge is SHA-256(mandate). The authorization_details member reuses [RFC9396] so IdPs and RPs evaluate it with existing policy engines.¶
AgentData is the signed core of every assertion, analogous to WebAuthn authenticatorData.¶
{
"rp_id": "code.example",
"origin": "https://api.code.example",
"challenge": "<RP nonce>",
"cred_id": "<agent credential id>",
"flags": { "mb": true, "ha": false, "ev": true },
"mandate_hash": "<SHA-256 of mandate>",
"al": "AL2",
"counter": 412,
"evidence_head": "<hash of latest action record>",
"action": { "type": "git.push",
"target": "acme/api@agent/fix-123" }
}
¶
The origin and rp_id members are filled by the runtime from the live connection. The AA MUST reject any request where they do not match a credential's scope.¶
The assertion is AgentData signed by the agent credential key. When ha is set, it also carries the approver's WebAuthn assertion over SHA-256(AgentData) for this specific action.¶
Used at registration only: an EAT [RFC9711] containing the AA identity key, the agent credential public key, al, platform evidence (raw vendor statement, optional), the RP-provided nonce, and the environment measurement where AL3 applies.¶
| Claim | Type | Requirement | Meaning |
|---|---|---|---|
rp_id
|
string | REQUIRED | RP ID the credential is scoped to; set by the runtime |
origin
|
string | REQUIRED | Origin of the live TLS connection; never set by the agent |
challenge
|
string | REQUIRED | Fresh nonce from the RP, at least 128 bits |
cred_id
|
string | REQUIRED | Identifier of the agent credential |
flags
|
object | REQUIRED |
mb within mandate, ha human approved, ev action record written |
mandate_hash
|
string | REQUIRED | SHA-256 of the mandate in force |
al
|
string | REQUIRED | Assurance level, AL0 to AL3 |
counter
|
integer | REQUIRED | Strictly increasing per credential |
action
|
object | REQUIRED | Action type and target the signature authorizes |
evidence_head
|
string | OPTIONAL | Hash of the latest action record (Section 8) |
This section defines five ceremonies. Of these, only registration and step-up require a person to take part.¶
Human Agent Agent Relying approver Authenticator runtime party / IdP | | | | | | | 1. register | | | |--------------->| | | | 2. nonce, RP ID| | | |<---------------| | | 3. create key | | | |<---------------| | | |--+ 4. HW key, | | | |<-+ attestation | | | 5. draft mandate | | | |<-----------------| | | | 6. passkey signs | | | |----------------->| | | | | 7. key, attest.| | | | mandate | | | |--------------->| | | | | 8. submit | | | |--------------->| | | | |--+ 9. verify | | | |<-+ and store
rp_id and origin from the connection and forwards the request to the AA.¶
ha for an action in the mandate's step_up list, or the AA requires it by local policy.¶
SHA-256(AgentData).¶
ha. The approval covers exactly that action and cannot be replayed.¶
This ceremony is the same for local and cloud agents, because the approval is always made on the person's own authenticator.¶
Agent Runtime Authenti- Human Relying | | cator (phone) party | | | | | | 1. call | | | | |-------->| 2. request | | | | |---------------------------------------->| | | 3. challenge | | |<----------------------------------------| | | 4. sign + | | | | | origin | | | | |------------>| | | | | |--+ 5. mandate | | | |<-+ check | | | | | 6. approve? | | step-up: | | |------------>| | risky | | | 7. passkey | | actions | | |<------------| | only | | 8. signed | | | | |<------------| | | | | 9. assertion | | |---------------------------------------->| | | 10. DPoP-bound token | | |<----------------------------------------|
Steps 6 and 7 apply only to actions that require approval, such as merging, publishing or deleting. For other actions, the AA signs on the basis of the mandate alone.¶
An agent MAY hand a narrower task to another agent only if delegable is true. The parent AA signs a child mandate that MUST be a subset of the parent (RPs, actions, expiry) and MUST NOT lower min_al. Every hop's credential MUST be attested; the chain travels with the assertion and is verifiable offline.¶
On receiving an assertion, the RP MUST perform these steps in order and MUST reject the request if any step fails:¶
cred_id. Reject if unknown or revoked.¶
rp_id equals the RP's own RP ID and origin is an origin the RP serves.¶
challenge equals a nonce the RP issued, is unexpired, and has not been used before.¶
counter is greater than the stored value, then store it. A non-increasing counter indicates a cloned credential; the RP MUST revoke it.¶
mandate_hash matches the mandate stored at registration and that the mandate has not expired.¶
action is permitted by the mandate's authorization_details.¶
al is at least the mandate's min_al and the RP's own policy minimum.¶
step_up list or RP policy requires approval, verify that ha is set and that the attached WebAuthn assertion is a valid signature by the registered approver key over SHA-256(AgentData).¶
An RP that delegates policy to an IdP (Section 7) MAY perform steps 6 to 9 by passing the assertion to the IdP in token exchange, but MUST still perform steps 1 to 5.¶
This section describes how the mechanism maps onto protocols that relying parties already support. In most cases the agent itself needs no changes, because the runtime and the AA handle authentication on its behalf.¶
| Binding | Where it plugs in | How the assertion is used |
|---|---|---|
| MCP | MCP authorization [MCP-AUTH] and its DPoP and workload identity extensions | AA acts as the MCP client's auth provider; tokens are DPoP-bound to the agent key |
| Enterprise IdP | ID-JAG [ID-JAG]: token exchange [RFC8693] then JWT bearer grant [RFC7523] | The user's identity assertion is the subject token and the agent assertion is the actor token; the IdP applies its own policy and issues the ID-JAG |
| Agent gateways | Gateway authorization on each tool call | Gateway verifies the assertion, reads al, ha and mandate hash, asks the IdP for the decision |
| Generic OAuth APIs | JWT bearer or token exchange with authorization details [RFC9396] | RP swaps the assertion for a short-lived, key-bound access token |
| Git over HTTPS | git credential helper | Helper asks the AA for a token per remote; no PATs on disk |
| Git over SSH | ssh-agent protocol with a key type modeled on OpenSSH FIDO keys | AA acts as an ssh-agent; signatures carry flags and mandate hash |
| Commit signing | SSH or Sigstore-style signing | Commits signed by the agent key; trailer names approver and mandate hash |
| Cloud | Workload identity federation | AA or IdP issues a token the cloud trusts; no static cloud keys |
| Package registries | Trusted publishing | Publish requires ha; provenance records agent identity |
| Agent hooks | Pre-tool-use hooks in coding agents | Hook routes risky actions to step-up before they run |
Some relying parties support none of these mechanisms. For such an RP, the AA MAY fetch a legacy token through a broker, but MUST record al as no higher than AL1 and MUST NOT expose the token to the model process.¶
Action records are written and signed by the AA, using keys held in the same secure hardware as the agent's credentials. The agent cannot create or modify them.¶
The AA records the following types of event:¶
The AA writes one record per agent action at the moment it signs or refuses it. Because every request that needs a credential passes through the AA, the AA observes every action that the agent takes against a relying party.¶
{
"seq": 1042,
"time": "2026-11-06T14:03:22Z",
"agent": { "cred": "<agent key thumbprint>",
"name": "coding-agent@laptop-17" },
"human": "priya@acme.example",
"mandate_hash": "<SHA-256 of mandate>",
"action": {
"kind": "mcp.tool_call",
"rp": "mcp.example",
"tool": "jira.comment",
"target": "PROJ-142",
"args_hash": "sha256:<hash of arguments>"
},
"decision": "allowed",
"flags": { "mb": true, "ha": false },
"al": "AL2",
"source": "daemon",
"parent_seq": 1039,
"prev_hash": "<hash of record 1041>",
"sig": "<signature by evidence key>"
}
¶
| Action | How the AA sees it | source |
|---|---|---|
| MCP tool call to a remote server | AA is the MCP client's auth provider and signs each call | daemon |
| API call (code host, registry, cloud, model API) | AA signs the request or the token exchange | daemon |
| git push, commit signing | AA acts as git credential helper and ssh-agent | daemon |
| Step-up request, approval or denial | AA runs the ceremony | daemon |
| Action refused as outside the mandate | AA refuses to sign and records why | daemon |
| Local tool (file edit, shell command, local MCP server) | Runtime reports it to the AA through its hook | runtime |
The decision member takes one of the following values: allowed, step_up_approved, step_up_denied, denied_out_of_scope, denied_origin_mismatch, denied_revoked.¶
The parent_seq member ties each action to the one that led to it, so one task, including sub-agent hand-offs, can be reconstructed as a single sequence of actions, from the request that started the task to its last tool call.¶
evidence_head member of AgentData commits the chain to each RP, so RPs hold independent witnesses.¶
ha event, the AA registers a signed statement with the chain head on a SCITT transparency service [RFC9943].¶
Records are emitted as OCSF [OCSF] events so common SIEMs ingest them without a custom parser. Tool and API calls map to API Activity (6003), authentication and step-up to Authentication (3002), and mandate grants and revocations to Account Change (3001).¶
The protocol does not change between the two profiles below. What differs is how the AA is implemented and which assurance level it can reach.¶
| Aspect | Local profile (developer machine) | Cloud profile (sandbox, VM, enclave) |
|---|---|---|
| AA form | OS daemon in a separate privilege domain from the agent | Sidecar, enclave key service, or attested cloud KMS |
| Key storage | TPM 2.0, Secure Enclave | Confidential-computing enclave, vTPM, or KMS with attestation-gated release |
| Typical AL | AL2 (AL1 without secure hardware) | AL3 in confidential computing, AL1 with instance identity only |
| Human approval | Same device or phone | Always remote: phone via push or hybrid flow |
| Credential lifetime | Until mandate expiry or revocation | One task; keys destroyed when the environment ends |
| Key isolation rule | AA MUST run outside the agent's user or sandbox and sign only for processes it launched | AA MUST release keys only after attestation matches the expected measurement |
| Hand-off | A session moving to the cloud gets a new credential under a child mandate; it never copies the local key | Same rule in reverse |
This section is to be removed before publishing as an RFC.¶
This section records the status of known implementations of the protocol defined by this specification at the time of posting of this Internet-Draft, and is based on a proposal described in [RFC7942]. The description of implementations in this section is intended to assist the IETF in its decision processes in progressing drafts to RFCs. Please note that the listing of any individual implementation here does not imply endorsement by the IETF. Furthermore, no effort has been spent to verify the information presented here that was supplied by IETF contributors. This is not intended as, and must not be construed to be, a catalog of available implementations or their features. Readers are advised to note that other implementations may exist.¶
According to [RFC7942], "this will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature. It is up to the individual working groups to use this information as they see fit".¶
At the time of writing, there are no known implementations. A reference implementation of the Agent Authenticator for Linux with TPM 2.0, for macOS with the Secure Enclave, and for one confidential-computing environment is planned.¶
The mechanism limits what a compromised agent can do and makes tampering with records detectable. It does not protect against a fully compromised host.¶
| Threat | Mitigation | Residual risk |
|---|---|---|
| Prompt injection sends agent to attacker origin | P3 origin binding; no credential exists for that origin | Injection can still misuse allowed RPs within the mandate |
| Injection abuses an allowed RP | Narrow mandates, step-up for destructive actions, action records | Damage up to mandate scope |
| Token theft from agent memory or logs | Model never holds keys; tokens DPoP-bound and short-lived | A token used from the same host before expiry |
| Same-user malware borrows the AA | AA in separate privilege domain, process-lineage check, ha for risky actions |
Local administrator can subvert the AA |
| Administrator deletes or edits records | Hash chain, forward-secure hardware signing, RP-held heads, SCITT receipts | Later events may be missing, but the gap is provable |
| Approval fatigue | Plain-language rendering of exactly what is signed; rate limits; risk-tiered ha
|
Humans can still approve bad requests |
| Replay of approvals | Approval signs SHA-256(AgentData) including RP challenge and counter |
None known |
| Stale attestation | Fresh nonce at registration; periodic and per-ha re-attestation |
Window between re-attestations |
| Over-broad sub-delegation | Child mandate must be a subset; min_al cannot drop |
Depends on correct policy authoring |
Three limitations should be noted. The record mechanisms detect tampering but do not prevent it. Guarantees on personal computers are weaker than those available in attested enclaves. Finally, assurance ultimately depends on the attestation roots of hardware and cloud vendors.¶
al, not raw vendor evidence, and AAs use per-RP credential keys (P3).¶
al, for example using anonymous credentials such as BBS signatures or TPM Direct Anonymous Attestation, is left for future work.¶
IANA is requested to register the following media types [RFC6838] in the "Media Types" registry [IANA.MEDIA].¶
IANA is requested to register the following value in the "OAuth URI" registry [IANA.OAUTH]. The agent assertion is used as the actor_token in token exchange [RFC8693], so that the agent is identified as acting on behalf of the user named by the subject token.¶
IANA is requested to register the following claims in the "JSON Web Token Claims" registry [IANA.JWT]. For each, the Change Controller is IETF and the Specification Document is Section 5.5 of this document.¶
| Claim Name | Claim Description |
|---|---|
| agent_cred | Agent credential, identified by key thumbprint |
| mandate_hash | Hash of the mandate in force |
| al | Agent environment assurance level |
| evidence_head | Hash of the latest action record |
IANA is requested to create a new registry group named "Agent Authenticator" containing the two registries below. Both use the "Specification Required" registration policy [RFC8126]. Designated experts should check that a proposed value is clearly defined, does not duplicate an existing value, and, for assurance levels, states the evidence a verifier needs to assign it.¶
Template: Level name; Description; Reference. Initial contents:¶
| Level | Description | Reference |
|---|---|---|
| AL0 | Software key | This document |
| AL1 | Platform keystore without hardware isolation, or cloud workload identity only | This document |
| AL2 | Dedicated secure hardware; host software not isolated | This document |
| AL3 | TEE that also isolates the agent's code, with measured runtime | This document |
Template: Value; Description; Reference. Initial contents:¶
| Value | Description | Reference |
|---|---|---|
| allowed | Action signed within the mandate | This document |
| step_up_approved | Human approved the action | This document |
| step_up_denied | Human declined the action | This document |
| denied_out_of_scope | Action outside the mandate | This document |
| denied_origin_mismatch | Origin did not match the credential scope | This document |
| denied_revoked | Credential or mandate revoked | This document |
This section is to be removed before publishing as an RFC.¶
The specification may be split into smaller documents, each sent to the group that owns that layer.¶
| Document | Venue | Contents |
|---|---|---|
| EAT profile for agent keys | IETF RATS | Vendor evidence to AL0-AL3 mapping |
| Agent assertion and mandate profile | IETF OAuth, with WIMSE | AgentData, mandate, token exchange and ID-JAG use |
| Delegated approval extension | W3C WebAuthn WG, FIDO Alliance | Passkey signing of mandates and per-action approvals |
| Agent action-record profile | IETF SCITT, plus OCSF | Records, chain, anchoring and OCSF mapping |
| MCP binding | MCP authorization working groups | DPoP and workload identity usage with the AA |
This draft builds on the WebAuthn, OAuth, RATS, WIMSE and SCITT work of the W3C, the FIDO Alliance and the IETF.¶