Internet-Draft Agent Authenticator November 2026
Ganesan Expires 19 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-ganesan-agent-authenticator-00
Published:
Intended Status:
Standards Track
Expires:
Author:
H. S. Ganesan

Agent Authenticator: Hardware-Bound, Origin-Bound Authentication for AI Agents

Abstract

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.

Status of This Memo

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.

▲

Table of Contents

1. Introduction

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.

1.1. Goals and Non-Goals

The mechanism is designed to meet the following goals:

  1. The agent process does not hold private keys or any other secret that can be used to obtain tokens. It requests signatures from a separate authenticator.
  2. A credential can be used only with the relying party for which it was created. The origin is taken from the network connection rather than from the agent's output, so an agent that has been manipulated through prompt injection cannot direct a credential to another site.
  3. Agent keys are generated and held in secure hardware or in an attested cloud key service, and relying parties can learn how well a key is protected through a normalized assurance level.
  4. A named person approves each agent credential, and each high-risk action, using a passkey. The person's device need not be the device on which the agent runs.
  5. Deployment does not require a new identity system. Enterprise identity providers remain the policy authority, and services accept agent credentials through existing OAuth grants.
  6. Each action that the authenticator authorizes is recorded in a signed, tamper-evident log that can be exported to existing security monitoring systems.
  7. The same protocol is used whether the agent runs on a personal computer or in a cloud environment; only the implementation of the authenticator differs.

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.

1.2. Motivation

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.

1.2.1. Evidence from Real Incidents

Table 1
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].

1.2.2. Evidence from Credential Data

  • A study by Astrix Security [ASTRIX] of 5,205 open-source MCP servers found 88% need credentials, 53% use static API keys or PATs, only 8.5% use OAuth, and 79% pass keys through environment variables.
  • GitGuardian [GG-SPRAWL] found 28.65 million newly leaked secrets on public GitHub in 2025, an 81% increase in leaked secrets for AI services, and 24,008 secrets in MCP configuration files, 2,117 of them valid.

1.2.3. Gaps in Existing Standards

Table 2
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.

1.3. Requirements Language

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.

2. Terminology and Architecture

The architecture involves the roles listed below. Of these, only the Agent Authenticator is introduced by this document.

Table 3
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    |
                         +---------------+
Figure 1: Architecture overview

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:

Agent credential:
An RP-scoped key pair created and held by the AA for one agent instance.
Mandate:
A human-signed statement of what an agent credential may do, where, and until when.
Environment attestation:
Hardware evidence about where the AA's keys live and what runs there.
Assurance level (AL):
A normalized rating of environment attestation (Section 4).
Action record:
A signed, hash-chained record of one agent action, bound to the credential that authorized it.

2.1. Abbreviations

AA:
Agent Authenticator
AL:
assurance level
CAEP:
Continuous Access Evaluation Profile
COSE:
CBOR Object Signing and Encryption
DPoP:
Demonstrating Proof of Possession
EAT:
Entity Attestation Token
ID-JAG:
Identity Assertion JWT Authorization Grant
IdP:
identity provider
KMS:
key management service
MCP:
Model Context Protocol
OCSF:
Open Cybersecurity Schema Framework
PAT:
personal access token
RAR:
Rich Authorization Requests
RATS:
Remote ATtestation procedureS
RP:
relying party
SCITT:
Supply Chain Integrity, Transparency, and Trust
SIEM:
security information and event management
SSF:
Shared Signals Framework
TEE:
trusted execution environment
TPM:
Trusted Platform Module

3. Security Properties

The following table compares the security properties of passkeys with those of this mechanism. Properties P8 to P10 have no counterpart in passkeys.

Table 4
# 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.

4. Keys and Assurance Levels

The mechanism uses four keys. None of them is accessible to the agent process.

Table 5
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.

Table 6
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.

5. Data Formats

All structures are JSON Web Signatures [RFC7515] for HTTP and OAuth bindings, with a COSE [RFC9052] encoding for constrained and SSH bindings.

5.1. Mandate

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.

5.2. AgentData

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.

5.3. Assertion

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.

5.4. Attestation Statement

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.

5.5. AgentData Claim Definitions

Table 7
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)

6. Ceremonies

This section defines five ceremonies. Of these, only registration and step-up require a person to take part.

6.1. Registration

  1. The runtime asks the RP (or the IdP acting for it) to register an agent credential. The RP returns a nonce and its RP ID.
  2. The AA creates a key pair scoped to that RP ID in secure hardware.
  3. The AA builds the attestation statement (Section 5.4) bound to the nonce.
  4. The AA builds a draft mandate and sends it to the human approver: locally as an OS prompt, remotely as a push or QR code to their phone.
  5. The human reviews a plain-language rendering of the mandate and signs it with their passkey.
  6. The RP verifies the attestation, the approver signature and the mandate, then stores the agent credential public key linked to the human's account, separately revocable.
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
Figure 2: Registration

6.2. Authentication

  1. The agent calls an RP through the runtime. The RP returns a challenge.
  2. The runtime fills rp_id and origin from the connection and forwards the request to the AA.
  3. The AA checks the mandate (RP allowed, action allowed, not expired, AL still met), writes an action record, and signs AgentData.
  4. The RP verifies the assertion (Section 6.6), then issues a short-lived access token bound to the agent key with DPoP [RFC9449].

6.3. Step-Up

  1. The RP requires ha for an action in the mandate's step_up list, or the AA requires it by local policy.
  2. The AA sends the action summary to the approver's authenticator (same device, or phone via push or hybrid transport).
  3. The human approves with a passkey assertion over SHA-256(AgentData).
  4. The AA attaches it and sets 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      |
   |         |<----------------------------------------|
Figure 3: Authentication with step-up

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.

6.4. Sub-Delegation

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.

6.5. Revocation

  • Any of these MUST revoke an agent credential: mandate expiry, human or administrator revocation, IdP session revocation, failed re-attestation, broken action-record chain.
  • The AA is an OpenID Shared Signals Framework [SSF] receiver: a CAEP session-revoked or credential-change event from the IdP destroys the matching keys.
  • The AA is also a Shared Signals transmitter: it emits events when attestation fails or tampering is detected.
  • RPs MAY check credential status via a token status list for offline verification.

6.6. Relying Party Verification Procedure

On receiving an assertion, the RP MUST perform these steps in order and MUST reject the request if any step fails:

  1. Look up the agent credential by cred_id. Reject if unknown or revoked.
  2. Verify that rp_id equals the RP's own RP ID and origin is an origin the RP serves.
  3. Verify that challenge equals a nonce the RP issued, is unexpired, and has not been used before.
  4. Verify the signature over AgentData with the stored credential public key.
  5. Verify that counter is greater than the stored value, then store it. A non-increasing counter indicates a cloned credential; the RP MUST revoke it.
  6. Verify that mandate_hash matches the mandate stored at registration and that the mandate has not expired.
  7. Verify that action is permitted by the mandate's authorization_details.
  8. Verify that al is at least the mandate's min_al and the RP's own policy minimum.
  9. If the action is in the mandate's 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).
  10. Only then issue a short-lived access token bound to the agent key with DPoP [RFC9449], or perform the action.

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.

7. Protocol Bindings

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.

Table 8
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.

8. Action Records

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.

8.1. What Is Recorded

The AA records the following types of event:

Action events:
Every tool call or API call the AA signs or refuses, one record per action.
Identity events:
Registration, mandate signed, step-up approved or denied, revocation, re-attestation result.
Local actions:
File edits and shell commands reported by the runtime, labeled as runtime-reported.
Integrity events:
AA start and stop, heartbeats, chain verification failures.
OS events (optional profile):
Raw process, file and network activity, for deployments that need forensic depth.

8.2. Record Generation

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>"
}
Table 9
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.

  • Records are signed only by the AA.
  • Arguments are stored as a hash by default; full arguments stay in the local log.
  • Runtime-reported records MUST carry source: runtime.
  • The AA MUST emit a signed heartbeat at a fixed interval, so a stopped AA leaves a provable gap.

8.3. Tamper Evidence

  1. Each record carries the hash of the previous record, so edits, deletions and reordering are detectable.
  2. The evidence key is held in secure hardware and rotates per epoch (forward-secure), so a later compromise cannot forge past records.
  3. The evidence_head member of AgentData commits the chain to each RP, so RPs hold independent witnesses.
  4. At each epoch, and on every ha event, the AA registers a signed statement with the chain head on a SCITT transparency service [RFC9943].

8.4. SIEM Delivery

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).

9. Deployment Profiles

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.

Table 10
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

10. Implementation Status

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.

11. Security Considerations

The mechanism limits what a compromised agent can do and makes tampering with records detectable. It does not protect against a fully compromised host.

Table 11
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.

12. Privacy Considerations

13. IANA Considerations

13.1. Media Types

IANA is requested to register the following media types [RFC6838] in the "Media Types" registry [IANA.MEDIA].

13.1.1. application/agent-mandate+jwt

Type name:
application
Subtype name:
agent-mandate+jwt
Required parameters:
N/A
Optional parameters:
N/A
Encoding considerations:
binary; a JWT is a sequence of base64url-encoded values separated by period characters
Security considerations:
See Section 11 of this document
Interoperability considerations:
N/A
Published specification:
Section 5.1 of this document
Applications that use this media type:
Agent Authenticators, relying parties and identity providers that process agent mandates
Fragment identifier considerations:
N/A
Additional information:
Magic number(s): N/A; File extension(s): N/A; Macintosh file type code(s): N/A
Person and email address to contact for further information:
Harish Santhanalakshmi Ganesan, harishsg99@gmail.com
Intended usage:
COMMON
Restrictions on usage:
none
Author:
Harish Santhanalakshmi Ganesan
Change controller:
IETF

13.1.2. application/agent-assertion+jwt

Type name:
application
Subtype name:
agent-assertion+jwt
Required parameters:
N/A
Optional parameters:
N/A
Encoding considerations:
binary; a JWT is a sequence of base64url-encoded values separated by period characters
Security considerations:
See Section 11 of this document
Interoperability considerations:
N/A
Published specification:
Section 5.3 of this document
Applications that use this media type:
Agent Authenticators, relying parties and identity providers that process agent assertions
Fragment identifier considerations:
N/A
Additional information:
Magic number(s): N/A; File extension(s): N/A; Macintosh file type code(s): N/A
Person and email address to contact for further information:
Harish Santhanalakshmi Ganesan, harishsg99@gmail.com
Intended usage:
COMMON
Restrictions on usage:
none
Author:
Harish Santhanalakshmi Ganesan
Change controller:
IETF

13.2. OAuth URI

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.

URN:
urn:ietf:params:oauth:token-type:agent-assertion
Common Name:
Agent assertion
Change Controller:
IETF
Specification Document:
Section 5.3 of this document

13.3. JSON Web Token Claims

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.

Table 12
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

13.4. Agent Authenticator Registry Group

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.

13.4.1. Agent Assurance Levels Registry

Template: Level name; Description; Reference. Initial contents:

Table 13
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

13.4.2. Agent Action Decision Values Registry

Template: Value; Description; Reference. Initial contents:

Table 14
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

14. References

14.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC7515]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, , <https://www.rfc-editor.org/info/rfc7515>.
[RFC7523]
Jones, M., Campbell, B., and C. Mortimore, "JSON Web Token (JWT) Profile for OAuth 2.0 Client Authentication and Authorization Grants", RFC 7523, DOI 10.17487/RFC7523, , <https://www.rfc-editor.org/info/rfc7523>.
[RFC7638]
Jones, M. and N. Sakimura, "JSON Web Key (JWK) Thumbprint", RFC 7638, DOI 10.17487/RFC7638, , <https://www.rfc-editor.org/info/rfc7638>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8693]
Jones, M., Nadalin, A., Campbell, B., Ed., Bradley, J., and C. Mortimore, "OAuth 2.0 Token Exchange", RFC 8693, DOI 10.17487/RFC8693, , <https://www.rfc-editor.org/info/rfc8693>.
[RFC9052]
Schaad, J., "CBOR Object Signing and Encryption (COSE): Structures and Process", STD 96, RFC 9052, DOI 10.17487/RFC9052, , <https://www.rfc-editor.org/info/rfc9052>.
[RFC9334]
Birkholz, H., Thaler, D., Richardson, M., Smith, N., and W. Pan, "Remote ATtestation procedureS (RATS) Architecture", RFC 9334, DOI 10.17487/RFC9334, , <https://www.rfc-editor.org/info/rfc9334>.
[RFC9396]
Lodderstedt, T., Richer, J., and B. Campbell, "OAuth 2.0 Rich Authorization Requests", RFC 9396, DOI 10.17487/RFC9396, , <https://www.rfc-editor.org/info/rfc9396>.
[RFC9449]
Fett, D., Campbell, B., Bradley, J., Lodderstedt, T., Jones, M., and D. Waite, "OAuth 2.0 Demonstrating Proof of Possession (DPoP)", RFC 9449, DOI 10.17487/RFC9449, , <https://www.rfc-editor.org/info/rfc9449>.
[RFC9711]
Lundblade, L., Mandyam, G., O'Donoghue, J., and C. Wallace, "The Entity Attestation Token (EAT)", RFC 9711, DOI 10.17487/RFC9711, , <https://www.rfc-editor.org/info/rfc9711>.
[WebAuthn]
Cappalli, T., Ed., Kumar, A., Ed., Lundberg, E., Ed., Miller, M., Ed., Pascoe, Ed., and N. Satragno, Ed., "Web Authentication: An API for accessing Public Key Credentials Level 3", W3C REC-webauthn-3-20260825, , <https://www.w3.org/TR/2026/REC-webauthn-3-20260825/>. Latest version available at https://www.w3.org/TR/webauthn-3/.

14.2. Informative References

[AIMS]
Kasselman, P., Lombardo, J., Rosomakho, Y., Campbell, B., Steele, N., and A. Parecki, "AI Identity Management System", Work in Progress, Internet-Draft, draft-ietf-wimse-aims-00, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-aims-00>.
[ASTRIX]
Astrix Security, "Astrix Researchers Uncover Credential Risk in the Majority of MCP Servers", , <https://astrix.security/learn/news/astrix-researchers-uncover-credential-risk-in-the-majority-of-mcp-servers/>.
[CSA-CI]
Cloud Security Alliance, "Research Note: AI Coding Agent CI Prompt Injection", , <https://labs.cloudsecurityalliance.org/wp-content/uploads/2026/08/CSA_research_note_ai_coding_agent_ci_prompt_injection_20260807-csa-styled.pdf>.
[GG-SPRAWL]
GitGuardian, "The State of Secrets Sprawl 2026", , <https://www.gitguardian.com/state-of-secrets-sprawl-report-2026>.
[IANA.JWT]
IANA, "JSON Web Token (JWT)", <https://www.iana.org/assignments/jwt>.
[IANA.MEDIA]
IANA, "Media Types", <https://www.iana.org/assignments/media-types>.
[IANA.OAUTH]
IANA, "OAuth Parameters", <https://www.iana.org/assignments/oauth-parameters>.
[ID-JAG]
Parecki, A., McGuinness, K., and B. Campbell, "Identity Assertion JWT Authorization Grant", Work in Progress, Internet-Draft, draft-ietf-oauth-identity-assertion-authz-grant-04, , <https://datatracker.ietf.org/doc/html/draft-ietf-oauth-identity-assertion-authz-grant-04>.
[INVARIANT]
Invariant Labs, "GitHub MCP Exploited: Accessing private repositories via MCP", , <https://invariantlabs.ai/blog/mcp-github-vulnerability>.
[MCP-AUTH]
Model Context Protocol, "Model Context Protocol: Authorization", , <https://modelcontextprotocol.io/>.
[NX-LEAK]
GitGuardian, "The Nx s1ngularity Attack: Inside the Credential Leak", , <https://blog.gitguardian.com/the-nx-s1ngularity-attack-inside-the-credential-leak/>.
[OCSF]
OCSF Project, "Open Cybersecurity Schema Framework", , <https://schema.ocsf.io/>.
[RFC6838]
Freed, N., Klensin, J., and T. Hansen, "Media Type Specifications and Registration Procedures", BCP 13, RFC 6838, DOI 10.17487/RFC6838, , <https://www.rfc-editor.org/info/rfc6838>.
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.
[RFC8126]
Cotton, M., Leiba, B., and T. Narten, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 8126, DOI 10.17487/RFC8126, , <https://www.rfc-editor.org/info/rfc8126>.
[RFC9943]
Birkholz, H., Delignat-Lavaud, A., Fournet, C., Deshpande, Y., and S. Lasker, "An Architecture for Trustworthy and Transparent Digital Supply Chains", RFC 9943, DOI 10.17487/RFC9943, , <https://www.rfc-editor.org/info/rfc9943>.
[SHAI-HULUD]
Elastic Security Labs, "Shai-Hulud Strikes Again: CHAINDROP Worm Hits 400+ npm Packages", , <https://www.elastic.co/security-labs/shai-hulud-chaindrop-npm-supply-chain>.
[SSF]
Tulshibagwale, A., Cappalli, T., Scurtescu, M., Backman, A., Bradley, J., and S. Miel, "OpenID Shared Signals Framework Specification 1.0", , <https://openid.net/specs/openid-sharedsignals-framework-1_0-final.html>.
[VB-EXPLOITS]
VentureBeat, "Six exploits broke AI coding agents. IAM never saw them", , <https://venturebeat.com/security/six-exploits-broke-ai-coding-agents-iam-never-saw-them>.

Appendix A. Standardization Path

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.

Table 15
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

Appendix C. Acknowledgments

This draft builds on the WebAuthn, OAuth, RATS, WIMSE and SCITT work of the W3C, the FIDO Alliance and the IETF.

Author's Address

Harish Santhanalakshmi Ganesan