Agent Authenticator: Passkey-Grade, Hardware-Bound Authentication for AI Agents

Harish Santhanalakshmi GanesanarXiv 2026 · arXiv

TL;DR

Current AI agents operate using "bearer secrets"—static API keys and tokens that are easily stolen via prompt injection or local malware. This paper proposes the Agent Authenticator, a framework that brings hardware-bound, passkey-grade security to autonomous agents by separating the untrusted model from a trusted runtime and enforcing human-signed "mandates" for all actions.

What Problem Does This Paper Address?

We are currently in the "Wild West" of AI agent security. As coding agents move from suggesting code to acting on it—pushing to GitHub, publishing npm packages, and provisioning cloud infrastructure—they require credentials. Today, these agents typically inherit the developer’s own secrets (SSH keys, personal access tokens).

The author identifies four critical failure classes in this setup:

  1. Ambient Bearer Secrets: Credentials live in memory or on disk where the model or co-resident malware can read them.
  2. In-agent Controls: Security safeguards run inside the same process as the agent, meaning a successful prompt injection can simply tell the agent to ignore its own rules.
  3. Over-broad Scope: Tokens often grant "full access" when the agent only needs to edit one file.
  4. Missing Attribution: Services can’t distinguish between a human action and an agent action.

While humans have "passkeys" to solve these issues, passkeys require a physical human gesture (like a fingerprint) for every single use—a requirement that breaks the "autonomous" part of an autonomous agent.

Methods

The paper introduces the Agent Authenticator (AA), a design that mirrors the security architecture of a web browser but for AI. The core innovation is the separation of roles:

  • The Agent: The untrusted LLM-driven process. It holds no keys.
  • The Agent Runtime: A trusted harness that launches the agent and owns the network connection. Crucially, the runtime—not the model—determines the "origin" (the destination website) of a request.
  • The Authenticator: A daemon running in a separate privilege domain (using TPM or Secure Enclave hardware) that holds the actual cryptographic keys.

Key technical components include:

  • Human-Signed Mandates: Before an agent starts, a human signs a "mandate" (a scoped policy) using their own passkey. This defines exactly what repositories, actions, and timeframes the agent is allowed to operate within.
  • Normalized Attestation: The system uses Entity Attestation Tokens (EAT) to provide "Assurance Levels" (AL0-AL3), allowing a service to know if an agent is running in a secure hardware enclave or just as a software script.
  • Cross-Device Step-up: For high-risk actions (like deleting a production database), the AA can trigger a "step-up" request to the human’s phone for a one-time approval.

Datasets

The paper does not use a traditional training dataset. Instead, it evaluates the design against a "dataset" of five documented (speculative/future-dated) security incidents from 2025 and 2026. These include:

  • GitHub MCP prompt injection: An agent tricked into leaking private repos.
  • Shai-Hulud worm: A self-propagating supply-chain worm that stole npm tokens.
  • Nx "s1ngularity": A malicious package that harvested credentials from developer machines.

The author also cites a survey of 5,205 open-source Model Context Protocol (MCP) servers to establish that 88% currently require credentials, yet only 8.5% use secure OAuth flows.

Key Insights and Ideas

  • The "Browser" for Agents: The most significant "aha moment" is the realization that the agent's runtime must act like a browser. Just as a browser doesn't let a website decide its own origin, the agent runtime must enforce the destination of a request to prevent an agent from being "tricked" into sending credentials to an attacker's server.
  • Hardware-Bound Identity: By binding keys to a specific TPM or cloud enclave, the "bearer" nature of secrets is destroyed. Even if an attacker steals the agent's current session token, they cannot use it from a different machine.
  • Accountability via Hash-Chaining: The AA produces a signed, hash-chained record of every action. This creates a tamper-evident audit log that binds every API call back to a specific human mandate.

Key Results

The paper provides a qualitative security analysis showing that the Agent Authenticator design would have blocked or contained all five of the analyzed real-world (and near-future) incidents.

  • Containment: In the GitHub MCP injection case, the "Mandate" would have restricted the agent to specific repositories, preventing it from accessing the private data the attacker targeted.
  • Blocking: In the credential-harvesting cases (like Nx s1ngularity), the attack would fail because there are no static secrets on disk to harvest; the keys are locked in hardware and only accessible to the specific agent process.

Limitations and Future Work

  • No Implementation Yet: The author candidly admits this is a design rationale and analysis; a full reference implementation (for Linux/TPM and macOS/Secure Enclave) is the immediate next step.
  • Local Process Identity: Most desktop OSs struggle to cryptographically prove which local process is requesting a signature. An administrator-level attacker could still potentially spoof the agent's identity to the Authenticator.
  • Approval Fatigue: If mandates are too narrow, humans will be bombarded with "step-up" requests on their phones, leading to "blind clicking" and undermining the security model.
  • Privacy: Hardware attestation can be used to "fingerprint" and track agents across different services. The author suggests "Direct Anonymous Attestation" as a future research path to mitigate this.

Summary updated

Abstract

AI coding agents now push code, publish packages, call model APIs and operate cloud resources on behalf of developers. They authenticate to these services with the same bearer secrets humans use, personal access tokens, API keys and package-registry tokens, stored where the model, its subprocesses and any co-resident malware can read them. Incidents in 2025 and 2026, including prompt-injection attacks on coding agents and self-propagating supply-chain worms, show that this arrangement fails in predictable ways. Passkeys solved the analogous problem for humans, but they require a human gesture on every use and cannot be operated by an autonomous process. We present the Agent Authenticator, a design that gives agents passkey-grade authentication properties: per-service hardware-bound keys, no shared secrets, origin binding enforced by the runtime rather than the model, normalized attestation of the execution environment, human-signed scoped mandates, and cross-device human approval for high-risk actions. The same protocol serves agents on developer laptops and in cloud enclaves, and it deploys as a profile over existing mechanisms, MCP authorization, OAuth token exchange including the Identity Assertion JWT Authorization Grant, git and SSH, rather than as a new identity system. The authenticator also produces a signed, hash-chained record of each action it authorizes. We analyze the design against a threat model centered on prompt injection and same-host compromise, map it onto five documented incidents, and discuss its limits.
BibTeX
@misc{ganesan2026agent,
  author = {Harish Santhanalakshmi Ganesan},
  title = {{Agent Authenticator: Passkey-Grade, Hardware-Bound Authentication for AI Agents}},
  year = {2026},
  eprint = {2611.19536},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.19536},
}

Loading related content...

Figure