Agent Authenticator: Passkey-level hardware-bound authentication for AI agents
Agent Authenticator: Passkey-Grade, Hardware-Bound Authentication for AI Agents
The authors propose the Agent Authenticator design, porting passkeys' hardware-bound keys, per-service isolation, and runtime origin binding to AI agents, and map it to 5 credential incidents for a qualitative analysis.
Four attacker classes: A1 content injectors control the text the agent reads; A2 malicious code on the same host with the same privileges; A3 network and origin attackers can operate servers and replay traffic; A4 control the cloud sandbox software image but not the confidential-computing hardware. Out of scope: administrator/kernel privileges, physical hardware attacks, a compromised IdP, and a human who knowingly approves a malicious operation.
- AI coding agents use the same bearer keys as humans (personal access tokens, API keys) to access services, and these keys can be read by the model process, subprocesses and malicious code on the same host; the authors state that the prompt injection and supply-chain worm incidents of 2025–2026 show that this arrangement fails in predictable ways.
- Proposes the Agent Authenticator design: a separate daemon holds per-service isolated keys in hardware, at runtime pins the origin from the TLS connection, humans sign a scoped mandate with a passkey, high-risk actions require cross-device step-up approval, and every action generates a signed hash-chain record; layered as a profile on top of MCP, OAuth, ID-JAG, git, and SSH.
- No experiments. The authors performed an informal security analysis and mapped 5 documented incidents to the design: a qualitative judgment that 3 were blocked and 2 were contained (Table 4), and the authors note that these judgments are not measurement results.
- The authors state that there is no complete implementation and no performance, usability or deployment measurements; the security analysis is informal, with Tamarin formal verification planned; desktop systems make it hard to prove which process requested a signature; hardware attestation can be correlated across services; step-up approvals may cause approval fatigue.
The authors propose the Agent Authenticator design, providing AI agents with Passkey-level hardware-bound authentication to replace the personal access tokens, API keys and package registry tokens currently shared with humans. The paper points out that these secrets are stored in locations readable by the model, subprocesses and same-host malware, and that prompt injection attacks against coding agents and self-propagating supply chain worm incidents in 2025 and 2026 show that this arrangement fails in predictable ways; although Passkey solves a similar problem for humans, each use requires a human gesture and cannot be operated by an autonomous process. The design includes per-service hardware-bound keys, no shared secrets, provenance binding enforced by the runtime rather than the model, standardized attestation of the execution environment, human-signed scoped authorization, and cross-device human approval for high-risk operations. The protocol can be deployed as a profile on top of existing mechanisms such as MCP authorization, OAuth token exchange, git and SSH, and generates a signed hash-chain record for each authorized action.
Paper analysis
What problem does this paper attempt to solve?
Agents reuse human bearer keys, leading to credential theft; the paper proposes a design that ports passkey properties to agents.
Core problem: AI coding agents authenticate to services with the same bearer keys as humans (personal access tokens, API keys, package registry tokens), and these keys are stored where the model, its subprocesses, and same-host malicious code can all read them; the authors argue this arrangement fails in predictable ways.
- Setting and importance: coding agents can push code, publish packages, call model APIs, and operate cloud resources; they read untrusted content (issues, PR titles, READMEs, dependency source code), prompt injection can turn any text into instructions, and agents act at machine speed with no human checking each step.
- Shortcomings of existing mechanisms (as stated in the paper): passkeys require a human gesture for every use and cannot be operated by an autonomous process; OAuth 2.1 and MCP authorization issue bearer tokens by default regardless of where the client key is stored; ID-JAG carries no evidence of the agent's key or execution environment; workload identity has no notion of a human approver; key vaults are still bearer tokens and are not standardized. The authors state that no existing mechanism addresses all four failure classes at once.
- Core observation: passkeys solve a similar problem for humans—per-site key pairs stored in secure hardware, with the browser rather than the user deciding which site a key can be used for; these are exactly the properties agents lack.
- What the paper proposes: the Agent Authenticator design, providing per-service hardware-bound keys, no shared secrets, runtime-enforced origin binding, normalized attestation of the execution environment, human-signed scoped mandates, cross-device human approval for high-risk actions, and signed hash-chain action records; layered as a profile on top of existing mechanisms.
- Threat model (Section 4):
- A1 content injectors: control the text the agent reads (issues, PRs, docs, tool output, dependency source code) and can steer model output and tool calls.
- A2 co-resident code: malicious code running on the same host with the same user privileges as the agent, such as an install script from a compromised dependency.
- A3 network and origin attackers: operate servers the agent may be induced to contact and can observe or replay the traffic they receive.
- A4 compromised cloud image: control the cloud sandbox's software image but not the underlying confidential-computing hardware. Out of scope: administrator/kernel privileges, physical attacks on secure hardware, a compromised IdP, and a human who knowingly approves a harmful operation.
What related research exists?
Related work falls into three groups: agent identity standards drafts, enterprise products, and academic research; the paper positions itself as binding hardware and mandate within a single credential.
Agent identity standards work
- IETF WIMSE's AIMS draft (2026): combines workload identity, OAuth and shared signals into an agent authentication and authorization model, treating the agent as a workload; the paper notes that it does not bind the agent key to a device or to a human approver's passkey.
- AAuth (2026): gives each agent an independent signing key and signs each request, with optional platform attestation in the bootstrapping guidance.
- PTV draft (2026) and condition-bounded credentials (2026): the former binds agent identity to TPM-anchored model and policy attestation; the latter makes a TPM-resident key usable only when a verified user is present, and the paper notes that it centers on endpoint-resident keys, whereas this paper's cross-device step-up targets the scenario of a cloud agent acting for a human on another device.
Enterprise products
- Microsoft Entra ID (2026), DigiCert (2026), Cisco Duo (2026): provide, respectively, directory identity and conditional access, certificate-backed agent credentials, and per-tool-call authorization and audit logs at the gateway. The paper states that to its knowledge, no product binds the agent key to attested hardware and a passkey-signed mandate within a single credential.
Academic research
- South et al. (2025): extends OAuth and OpenID Connect to implement authentication delegation from humans to AI agents; the paper states that this work shares its delegation model and adds hardware binding, runtime-enforced origin binding and attestation.
- Personhood credentials (2024): addresses the complementary problem—proving that a human rather than an AI is online.
Existing mechanisms used as design foundations (not comparison baselines): WebAuthn/CTAP, OAuth Token Exchange, JWT authorization grants, RAR, DPoP, ID-JAG, RATS/EAT, SCITT, OpenID Shared Signals; the paper's deployment model layers on top of these mechanisms (Table 3).
The authors position this paper as: porting the core properties of passkeys to autonomous agents, and adding three properties passkeys lack—human-signed constrained authorization, per-assertion accountability to a named human, and action records bound to identity; for ID-JAG and MCP enterprise authorization it provides stronger evidence rather than a replacement.
How does the paper address this problem?
An independent daemon holds the hardware key, the origin is fixed at runtime, a human passkey signs the mandate, and high-risk actions are approved across devices.
Overall approach: port the browser's role in WebAuthn—the origin for each request is provided by the runtime rather than the model; keys, mandate checks and signing all reside in the Agent Authenticator (AA) daemon, which is in a different privilege domain from the agent, and the agent itself is treated as untrusted.
Architecture and keys
- Role division (Figure 1): agent (the model and its subprocesses, holds no keys), agent runtime (owns the network connection, takes the origin from the live TLS connection), AA (independent privilege-domain daemon), relying party (service), enterprise IdP (policy authority), human approver (holds an ordinary passkey).
- Four key types (Table 2): approver key (human passkey, long-lived), AA identity key (device or cloud environment lifetime), agent credential key (one per agent × relying party, locally until mandate expiry or revocation, one task in the cloud), evidence key (rotated per epoch, forward-secure, separate from the credential key).
- Normalized assurance levels: the AA converts platform evidence into EAT, and RATS verifiers rate it across five levels from AL3 (TEE with isolated agent code, e.g. SEV-SNP, TDX, Nitro, Arm CCA) to AL0 (software keys); policies are written by level, e.g. publishing requires AL2 plus human approval.
Mandate and assertions
- Mandate: a statement signed by the human approver that limits what the agent credential may do; it contains the credential designated by key thumbprint, the AA and minimum assurance level, allowed relying parties, actions expressed as RAR authorization details, actions requiring renewed human approval, whether sub-delegation is allowed, and expiry time; it is signed with an ordinary WebAuthn assertion (challenge is the mandate hash), requiring no changes to authenticators.
- AgentData: the structure signed by each assertion, containing the RP identifier and origin (both provided by the runtime), the RP's challenge, the credential identifier, the mandate hash, the assurance level, a strictly increasing counter, the authorized action, and two flags mb (acting within the mandate) and ha (a human approved this action) that replace UP/UV; when ha is set, the assertion carries the approver's WebAuthn assertion over the AgentData hash.
Ceremony flows
- Registration: the runtime requests registration from the relying party, the AA generates the RP-specific key pair in hardware and produces an attestation bound to a nonce, and shows the human a plain-language version of the mandate for passkey signing; after verification the relying party stores the credential public key as an individually revocable credential.
- Authentication and step-up (Figure 2): the AA checks the mandate before signing; for actions listed as requiring approval, it sends a digest of the action to the approver's device, and the approval signature covers the AgentData hash and is non-replayable; routine calls skip the approval step.
- Relying party verification: it checks in order that the credential is not revoked, the RP identifier and origin match, the challenge is fresh, the signature is valid, the counter increases (no increase is treated as cloning and triggers revocation), the mandate matches and is not expired, the action is allowed, the assurance level is met, and a valid human approval is attached when required; it then issues a short-lived access token bound to the agent key using DPoP.
- Sub-delegation and revocation: a sub-mandate must be a subset of the parent mandate in relying parties, actions and expiry time and must not lower the minimum assurance level; expiry, administrator action, IdP session revocation, re-attestation failure, or a break in the action-record chain all revoke the credential, and the AA subscribes to OpenID Shared Signals.
Deployment and action records
- Binding to existing mechanisms (Table 3): MCP authorization (the AA acts as the client auth provider, tokens bound to the agent key), ID-JAG (the agent assertion as actor token), OAuth API, git credential helper, ssh-agent, cloud workload identity federation, package registry trusted publishing; for relying parties that do not support these mechanisms, the AA can obtain legacy tokens via a proxy, but the action record is no higher than AL1 and the token is not exposed to the model.
- Local and cloud profiles: the protocol is the same, only the AA form and the attainable assurance level differ; locally it is a system daemon using TPM or Secure Enclave (typically AL2), in the cloud a sidecar or enclave key service (up to AL3 under confidential computing, with the credential living for only one task).
- Action records: the AA writes a record for each action when signing or denying, signed by the evidence key and hashed into a chain, with each assertion carrying the current chain head, and the chain head periodically registered to a SCITT transparency service; the authors describe these mechanisms as tamper-evident rather than tamper-proof.
What experiments did the paper conduct?
The paper has no experiments: only a documentary analysis of 5 incidents, an informal safety argument, and a qualitative incident mapping (Table 4).
Experimental Setup
- The paper explicitly states that no full implementation was built and reports no performance, usability, or deployment measurements (Section 10), so there is no model under test, dataset, baseline, or review method.
- The paper's empirical content is document analysis: Section 3 selects 5 publicly analyzed incidents from 2025–2026 (Table 1), with selection criteria being that they involve coding agents or developer credentials, have been publicly analyzed, and exhibit different failure mechanisms.
- Two external measurements are also cited: an analysis of 5,205 open-source MCP servers [17], and a 2026 public GitHub secret-leak investigation [18].
Main Results
The paper's "results" are a distillation of failure classes and a qualitative mapping, with no numerically tabulated experimental results.
Content Result Source Failure classes 4 classes: F1 ambient bearer keys, F2 in-agent control, F3 overly broad scope, F4 lack of attribution Section 3.2 Incident mapping 5 incidents: 3 judged Blocked, 2 judged Contained Table 4 MCP server credentials 88% require credentials, 53% rely on static API keys or personal access tokens, 8.5% use OAuth cited [17] GitHub leak investigation 28.65 million new leaked secrets in 2025, AI service secret leaks up 81%, 24,008 secrets in MCP configuration files of which 2,117 are valid cited [18] - The authors note that the judgments in Table 4 are qualitative judgments derived from incident reports and the design, not measurement results.
- The authors state that these incidents are consistent with broader measurements: credentials are ambient, broadly scoped, exportable, and protected only by in-agent controls.
Incident Mapping Details (Table 4)
- The 3 judged Blocked: Comment and Control (no secrets exist in the agent environment, and the reviewing agent has no permission to read secrets), Nx s1ngularity (no harvestable credentials on disk, hardware keys unreadable), Shai-Hulud worm (publishing requires per-action human approval, credentials cannot be used from other machines).
- The 2 judged Contained: GitHub MCP injection (the mandate is limited to the specified repository, and cross-repository publishing is rejected), coding agent exploitation (policy is enforced by the AA outside the agent, repository content cannot disable it, and tokens are not exposed).
Informal Security Analysis (Section 8)
- G1/G2: the authors argue that the model process never holds credentials, so A1 can at most make the agent request an action; A2 cannot extract hardware keys, and the AA refuses to sign for processes it did not launch; assertions captured by A3 are bound to a different RP identity, a one-time challenge, and a counter, and cannot be replayed elsewhere.
- G3/G4/G5: keys are generated inside hardware and never leave it; credentials are unusable until the mandate is registered; a child mandate must be a subset of the parent mandate. The authors acknowledge that this check is weaker on platforms where process lineage cannot be reliably established.
Other Ablations and Analyses
- No ablations, parameter analyses, or sensitivity experiments.
What are some points that can be further explored?
The authors list limitations including no implementation, informal analysis, weak local process identity, privacy, and approval fatigue, and plan formal verification and standardization.
Limitations and future directions noted by the authors
- No implementation or measurement (Section 10): a complete Agent Authenticator has not been built, and there are no performance, usability or deployment measurements; the next step is a reference implementation on Linux+TPM 2.0, macOS+Secure Enclave, and a confidential computing environment.
- Analysis is informal (Section 10): the authors plan to model registration, authentication, step-up and sub-delegation with a symbolic protocol verifier such as Tamarin, and to prove origin binding, non-replayability of approvals, and monotonic delegation.
- Local process identity (Section 10): most desktop operating systems cannot attest which process requested a signature, and the AA's process-lineage check is a software control that an administrator-level attacker can bypass; the authors consider running the agent in a lightweight virtual machine worth researching.
- Privacy (Section 10): hardware attestation can be correlated across relying parties, and sending only a normalized level only partially mitigates this; unlinkable presentation using anonymous credentials or Direct Anonymous Attestation is future work.
- Human factors (Section 10): step-up approvals may cause approval fatigue, and whether people seriously review such prompts requires user studies.
- Roots of trust and adoption (Section 10): assurance ultimately depends on hardware and cloud providers' attestation roots; adoption depends on IdPs and services accepting agent assertions, and the authors plan to advance protocol standardization.
Scope of experimental coverage
- The paper has no experiments: no system under test, dataset, baseline or metric; the only quantitative content is a documentation review of 5 incidents (Table 1) and two external measurements (references [17], [18]).
- The incident mapping is a qualitative judgment (Table 4), and the authors note it is not a measurement result; the paper reports no performance, usability or deployment data.
- The threat model explicitly excludes: administrator/kernel-privilege attackers, physical attacks on secure hardware, a compromised IdP, and a human who knowingly approves harmful actions (Section 4).
- The security analysis (Section 8) is an informal per-goal argument without formal verification.
Summarize the main content of the paper
An authentication design that ports passkey properties to agents: hardware keys, runtime origin binding, human mandate, action records, no implementation.
A design and analysis paper on agent authentication, addressing the problem that coding agents reuse human bearer keys and that the keys can be read by the model process and by same-host code.
- Problem: the authors analyze 5 incidents from 2025–2026 (Table 1) and distill four failure classes: ambient bearer keys, in-agent control, overly broad scope, and lack of attribution; they also cite a measurement that of 5,205 open-source MCP servers, 88% require credentials and only 8.5% use OAuth.
- Method: Agent Authenticator is a daemon in a separate privilege domain that holds per-service isolated keys in hardware; at runtime it pins the origin from the live TLS connection; humans sign a mandate with a passkey limiting service, action, resource, and time; high-risk actions require cross-device step-up approval; every action produces a signed hash-chain record registered to SCITT. In deployment it is a profile layered on top of MCP authorization, OAuth token exchange, ID-JAG, git, SSH, and cloud workload identity (Table 3).
- Main results: no experiments. An informal security analysis argues that the design satisfies seven goals against the four attacker classes; Table 4 maps the 5 incidents to the design, qualitatively judging 3 as blocked and 2 as contained, and the authors note this is not a measurement.
- Authors' conclusion: the authors argue that the design ports to autonomous agents the properties that make passkeys work for humans (hardware-held keys, per-service isolation, origin selected by trusted software), and adds agent-specific requirements (human-signed scoped mandates, cross-device per-action approval, normalized attestation, attributable action records), and can be adopted incrementally.
- Limitations: there is no implementation or measurement, and the analysis is informal; the authors plan a reference implementation, Tamarin formal verification, and standardization efforts.