betaFeedback

WorksComputer Science

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

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.

Introduction

Software agents built on large language models have moved from suggesting code to acting on it. A coding agent today may read a repository, run tests, push a branch, open a pull request, comment on an issue tracker through a Model Context Protocol (MCP) server, publish a package, or provision cloud resources. Each of these actions requires authenticating to a service that was designed for human users or for traditional workloads.

In practice, agents inherit whatever credentials sit in the developer’s environment: an SSH key, a GitHub personal access token, a cloud CLI profile, an npm token in a configuration file. These are bearer secrets. Whoever holds them can use them, from any machine, for anything they permit. Three properties of agents make this arrangement worse than it is for human developers. First, agents read untrusted content as part of their work (issues, pull-request titles, README files, dependency source), and that content can contain instructions; prompt injection turns any text the agent reads into a potential command. Second, agents spawn subprocesses whose behaviour the agent’s own safeguards do not observe. Third, agents act at machine speed without a human checking each step.

Section 3 documents five incidents from 2025 and 2026 in which these properties led to credential theft or misuse, and reviews data showing that static secrets remain the norm in agent tooling. The pattern is consistent: credentials were ambient, broadly scoped, exportable, and protected only by controls running inside the agent.

For human users, the industry’s answer to phishing and credential theft has been passkeys [1, 2]: per-site key pairs held in secure hardware, with the browser rather than the user deciding which site a key may be used for. Passkeys cannot be used by agents directly. They require a human gesture for each assertion and offer no programmatic enrollment. Yet their core properties are exactly what agents lack.

This paper asks what a passkey for agents should look like, and answers with a design we call the Agent Authenticator. Our contributions are:

  1. An analysis of documented agent-credential incidents that identifies four recurring failure classes (§ 3).

  1. A design that transfers passkey properties to autonomous agents and adds three properties passkeys lack: scoped authority through human-signed mandates, accountability of every assertion to a named human, and identity-bound action records (§ 5 and § 7).

  1. A deployment model showing how the design layers onto MCP authorization, OAuth token exchange, the Identity Assertion JWT Authorization Grant (ID-JAG), git, SSH and cloud workload identity, with one protocol for local and cloud agents (§ 6).

  1. A security analysis against an explicit threat model, including a mapping of the five incidents onto the design and a statement of residual risk (§ 8).

This paper presents the design rationale and analysis; we have not yet built a full implementation, and we state the resulting limitations in § 10.

Background

Passkeys. WebAuthn [1] and CTAP [2] define public-key credentials scoped to a relying party (RP) identifier. The authenticator holds the private key, often in secure hardware, and signs a challenge together with authenticator data that includes flags for user presence (UP) and user verification (UV) and a signature counter. The browser, not the user, supplies the origin, which is what makes passkeys phishing-resistant: a credential created for one site cannot be exercised by another.

OAuth delegation. OAuth 2.0 Token Exchange [3] lets a client exchange one security token for another, carrying both a subject (on whose behalf) and an actor (who is acting). The JWT authorization grant profile [4] lets a signed assertion be redeemed for an access token. Rich Authorization Requests [5] express fine-grained permissions as structured authorization details. DPoP [6] binds access tokens to a client-held key so that a stolen token is useless without that key. The Identity Assertion JWT Authorization Grant [7] combines token exchange and JWT grants so that an enterprise identity provider (IdP) can broker an application’s access to another application; enterprise IdPs have adopted it for agent access, and MCP uses it for enterprise-managed authorization [8].

Remote attestation. The RATS architecture [9] separates an attester that produces evidence about its state from a verifier that appraises it. The Entity Attestation Token (EAT) [10] is a standard claims format for such evidence. Platform mechanisms that can attest to hardware key storage include TPM 2.0 key attestation, Apple App Attest, Android key attestation, and confidential-computing reports from AMD SEV-SNP, Intel TDX and AWS Nitro Enclaves.

Transparency logs. SCITT [11] defines transparency services that register signed statements and return receipts, making later deletion or equivocation detectable.

Problem Analysis

Incidents

Table 1 summarizes five documented incidents. We selected incidents that involved coding agents or developer credentials, were publicly analyzed, and illustrate distinct failure mechanisms.

IncidentWhat happenedRoot cause
GitHub MCP prompt injection (2025) [12]A malicious issue in a public repository caused an agent to read private repositories and publish their contents in a public pull request.One broadly scoped token covered every repository the user could reach.
Comment and Control (2026) [13]A crafted pull-request title hijacked several CI-hosted coding agents, which leaked repository secrets back through the code host itself.Secrets were ambient in the agent’s environment; untrusted text was treated as instructions.
Coding-agent exploits (2025–2026) [14]Crafted branch names exfiltrated tokens; repository settings files bypassed trust prompts; write sandboxes were escaped.Controls ran inside the agent and could be disabled by repository content.
Nx “s1ngularity” (2025) [15]Malicious package versions harvested 2,349 credentials from 1,079 developer machines, invoking locally installed AI CLIs to search for secrets.Tokens and keys on disk were readable by any local process.
Shai-Hulud worm (2025–2026) [16]A self-propagating worm stole npm and GitHub tokens and republished itself into packages the victims maintained.Long-lived publish tokens were usable from any machine.

Table 1. Documented incidents involving agent or developer credentials.

These incidents are consistent with broader measurements. An analysis of 5,205 open-source MCP servers found that 88% require credentials, 53% rely on static API keys or personal access tokens, and only 8.5% use OAuth [17]. A 2026 survey of public GitHub found 28.65 million newly leaked secrets in 2025, an 81% rise in leaked AI-service secrets, and 24,008 secrets in MCP configuration files, of which 2,117 were valid [18].

Failure classes

Across the incidents we identify four failure classes:

F1 Ambient bearer secrets. Credentials are readable by the agent, its subprocesses and co-resident code, and usable from anywhere.

F2 In-agent controls. Safeguards run inside the process they are meant to constrain, so content that subverts the agent can also subvert its safeguards. F3 Over-broad scope. Credentials authorize far more than the task requires and persist far longer.

F4 Missing attribution. Services cannot distinguish an agent’s actions from its human’s, and nothing binds an action to the person who authorized it.

Why existing mechanisms fall short

Passkeys address F1 for humans but cannot be operated autonomously. OAuth 2.1 and MCP authorization address F3 with scopes and expiry but issue bearer tokens by default and say nothing about where the client’s keys live. ID-JAG lets an IdP decide which applications an agent may reach, but it is anchored in the user’s login session and carries no evidence about the agent’s key or execution environment. Workload identity systems remove static secrets for cloud services but have no notion of a human approver and fit developer laptops poorly. Secret vaults and proxies keep secrets out of the model’s context, addressing part of F1, but the secrets remain bearer tokens and the approach is not standardized. No existing mechanism addresses all four classes together.

Threat Model and Goals

Adversaries. We consider four adversaries.

  • A1, content injector: controls text the agent reads (issues, pull requests, documentation, tool outputs, dependency source) and can therefore steer the model’s outputs and tool calls.

  • A2, co-resident code: malicious code running on the same host as the agent with the same user privileges, for example a compromised dependency’s install script.

  • A3, network and origin attacker: operates servers the agent might be induced to contact and can observe or replay traffic it receives.

  • A4, compromised cloud image: controls the software image of a cloud sandbox in which an agent runs, but not the underlying confidential-computing hardware.

Out of scope. An adversary with administrator or kernel privileges on a developer machine, physical attacks on secure hardware, a compromised IdP, and a human approver who knowingly approves harmful actions. We discuss the consequences of these exclusions in § 10.

Goals.

G1 No credential usable to mint tokens ever reaches the model process.

G2 A1 cannot cause an agent to authenticate to an origin for which no credential was provisioned.

G3 Agent keys are non-exportable, and relying parties can learn, in a normalized form, how strongly they are protected.

G4 Every credential and every high-risk action is approved by a named human, possibly on a different device from the agent.

G5 Authority is scoped to services, actions, resources and time, and can only narrow under delegation.

G6 The design deploys over existing IdPs and services.

G7 One protocol serves local and cloud agents.

Design

Architecture

Figure 1 shows the roles. The agent is the model-driven process and everything it spawns; we treat it as untrusted. The agent runtime is the harness that launches the agent and owns its network connections. The Agent Authenticator (AA) is a daemon running in a separate privilege domain that holds keys in secure hardware, enforces mandates and signs. Relying parties are the services the agent calls. An enterprise IdP may sit in front of relying parties as the policy authority. The human approver holds an ordinary passkey.

Roles in the Agent Authenticator design

Figure 1. Roles in the Agent Authenticator design. Only the authenticator holds keys; the runtime fixes the origin; the IdP keeps policy authority.

The central design decision mirrors the browser’s role in WebAuthn: the runtime, not the model, supplies the origin of every request, taking it from the live TLS connection. The model can ask for an action but cannot name the origin that the resulting signature is bound to.

Keys and assurance levels

Four keys participate (Table 2); none is accessible to the model process. Agent credential keys are scoped to a single relying party, so a credential for one service is cryptographically useless at any other.

KeyHolderLifetime
Approver keyHuman’s passkey authenticatorLong-lived; device-bound passkeys recommended
AA identity keyAA secure hardwareLife of the device or cloud environment
Agent credential keyAA secure hardware, one per agent and relying partyLocal: until mandate expiry or revocation. Cloud: one task
Evidence keyAA secure hardware, separate from credential keysRotated per epoch, forward-secure

Table 2. Keys in the design.

Relying parties should not need to understand every vendor’s attestation format. The AA converts platform evidence into an EAT [10] carrying a normalized assurance level (AL), appraised by a RATS verifier [9]:

  • AL3: keys in a trusted execution environment that also isolates the agent’s code, with the runtime measured (SEV-SNP, TDX, Nitro, Arm CCA).

  • AL2: keys in dedicated secure hardware, host software not isolated (TPM 2.0, Secure Enclave via App Attest, Android StrongBox).

  • AL1: keys in a platform keystore without hardware isolation, or cloud workload identity only.

  • AL0: software keys.

Policies are written against levels, for example “publishing requires AL2 and human approval”, rather than against platforms.

Mandates

A mandate is a statement signed by the human approver that bounds what an agent credential may do. It names the agent credential by key thumbprint [19], the AA and its minimum assurance level, the permitted relying parties, the permitted actions expressed as RAR authorization_details [5], the actions that require fresh human approval, whether sub-delegation is allowed, and an expiry. The approver signs it with an ordinary WebAuthn assertion whose challenge is the mandate’s hash, so no change to authenticators is needed.

{ "typ": "agent-mandate+jwt", "sub": "<human id>",
  "agent_cred": { "jkt": "<agent key thumbprint>" },
  "aa": { "id": "<AA key thumbprint>", "min_al": "AL2" },
  "rps": ["github.com", "registry.npmjs.org"],
  "authorization_details": [
    { "type": "git", "actions": ["push"],
      "locations": ["github.com/acme/api"], "refs": ["agent/fix-*"] } ],
  "step_up": ["merge", "publish", "delete"],
  "delegable": false, "exp": 1762480000 }

AgentData and assertions

Every assertion signs an AgentData structure, the analogue of WebAuthn’s authenticator data. It contains the RP identifier and origin (both supplied by the runtime), the RP’s challenge, the credential identifier, the mandate hash, the assurance level, a strictly increasing counter, the action being authorized, and two flags that replace UP and UV: mb (the agent is acting within its mandate) and ha (a human approved this specific action). When ha is set, the assertion also carries the approver’s WebAuthn assertion over the hash of the AgentData.

Ceremonies

Registration. The runtime requests registration from the relying party, which returns a nonce. The AA creates a key pair scoped to that RP in secure hardware and produces an attestation bound to the nonce. It then presents a plain-language rendering of a draft mandate to the human, locally or on their phone, and the human signs it with their passkey. The relying party verifies the attestation, the approver’s signature and the mandate, and stores the credential public key as a separately revocable credential linked to the human’s account.

Authentication and step-up. Figure 2 shows authentication. The AA checks the mandate before signing: the RP and action must be permitted, the mandate unexpired, and the assurance level still met. For actions listed as requiring approval, the AA sends a summary of exactly that action to the approver’s device; the approval signs the hash of the AgentData, so it covers one action and cannot be replayed. Because the approval travels to the human’s own authenticator, the ceremony is identical whether the agent runs on the same laptop or in a remote enclave.

Authentication with optional step-up

Figure 2. Authentication with optional step-up. Routine calls skip steps 6–7 and are signed on the mandate alone.

Relying-party verification. The relying party verifies, in order: the credential exists and is not revoked; the RP identifier and origin match its own; the challenge is fresh and unused; the signature is valid; the counter has increased (a non-increasing counter indicates cloning and triggers revocation); the mandate hash matches the registered mandate, which has not expired; the action is permitted by the mandate; the assurance level meets both the mandate and local policy; and, where required, a valid human approval over this AgentData is attached. Only then does it issue a short-lived access token bound to the agent key with DPoP [6]. A relying party may delegate the policy checks to its IdP through token exchange but always performs the cryptographic checks itself.

Sub-delegation. An agent may hand a narrower task to another agent only if its mandate allows. The child mandate must be a subset of the parent in relying parties, actions and expiry and may not lower the minimum assurance level, so authority narrows monotonically along a delegation chain, and every hop’s key must itself be attested.

Revocation. Mandate expiry, administrator action, IdP session revocation, failed re-attestation or a broken action-record chain revoke a credential. The AA subscribes to OpenID Shared Signals [20] so that a revocation at the IdP destroys the corresponding keys, and it emits signals when attestation fails.

Deployment

Bindings to existing protocols

A design that requires every service to adopt a new protocol will not be adopted. Table 3 lists how the AA plugs into mechanisms services already run. Two points deserve comment. First, ID-JAG requires the user’s identity assertion as the token-exchange subject; our binding presents the agent assertion as the actor token, which matches token exchange’s semantics of one party acting for another [3] and leaves IdP policy in control. Second, for relying parties that support none of these mechanisms, the AA may obtain legacy tokens through a broker, but it records the action at no higher than AL1 and never exposes the token to the model.

BindingMechanismRole of the AA
MCPMCP authorization with DPoP and workload-identity extensions [8]Acts as the MCP client’s auth provider; tokens bound to the agent key
Enterprise IdPID-JAG: token exchange then JWT grant [7, 3, 4]Agent assertion is the actor token; IdP applies policy
OAuth APIsJWT grant or token exchange with RARAssertion redeemed for a key-bound access token
Git over HTTPSgit credential helperPer-remote tokens; no tokens on disk
Git over SSHssh-agent with a key type modelled on FIDO SSH keysSignatures carry flags and mandate hash
CloudWorkload identity federationShort-lived cloud credentials; no static keys
Package registriesTrusted publishingPublishing requires human approval

Table 3. Bindings onto existing mechanisms.

Local and cloud profiles

The protocol is identical in both settings; only the AA’s form and the attainable assurance differ. On a developer machine the AA is a system daemon using the TPM or Secure Enclave, typically reaching AL2. It must run outside the agent’s user or sandbox and sign only for processes it launched, identified by process lineage and, where the operating system offers it, code signature. In the cloud, the AA is a sidecar or enclave key service; keys are released only after the environment’s attestation matches an expected measurement, reaching AL3 in confidential computing, and credentials last for one task. When a session moves from a laptop to the cloud, the cloud agent receives a fresh credential under a child mandate; the local key is never copied.

Action Records

Because every credentialed call must pass through the AA to be signed, the AA observes every action that touches a service without monitoring the operating system. It writes one record per action at the moment it signs or refuses it, recording which agent, under which human’s mandate, performed which action on which target, with which outcome (allowed, step-up approved or denied, or denied for scope, origin or revocation). Records are signed by the AA’s evidence key, never by the agent, and hash-chained; each assertion carries the current chain head, so every relying party holds an independent witness; and chain heads are periodically registered with a SCITT transparency service [11]. Local actions that involve no credential, such as file edits, can be reported by the runtime but are labelled as runtime-reported, since the agent’s own harness produced them. A signed heartbeat makes an interruption of the AA detectable. These mechanisms are tamper-evident rather than tamper-proof: an administrator on the host can stop the AA, but cannot do so without leaving a provable gap.

Security Analysis

We argue informally that the design meets its goals against the adversaries of § 4.

G1 against A1 and A2. The model process never holds a credential: it receives neither private keys, which remain in secure hardware, nor long-lived tokens, and the access tokens issued after authentication are DPoP-bound to the agent key. A1 can at most cause the agent to request actions. A2, running with the same user privileges, cannot extract hardware-held keys; it can attempt to ask the AA to sign, which the AA refuses for processes outside the lineage it launched. On platforms where lineage cannot be established reliably this check is weaker; high-risk actions additionally require human approval, which A2 cannot forge.

G2 against A1 and A3. The origin and RP identifier in AgentData come from the runtime’s view of the connection, and credentials are scoped per relying party. An agent induced to contact an attacker’s server has no credential for that origin, and an assertion captured by A3 is bound to a different RP identifier, a single-use challenge and a counter, so it cannot be replayed elsewhere. A1 can still misuse relying parties the mandate permits; G5 bounds that damage.

G3 and A4. Keys are generated in secure hardware and never leave it; the normalized assurance level is derived from appraised attestation evidence. In the cloud profile, keys are released only to environments whose measurements match expectations, so A4’s modified image does not receive them.

G4 and G5. Credentials are unusable until a mandate signed with the approver’s passkey is registered, and step-up approvals sign the specific AgentData, binding a human decision to one action. Mandates use RAR’s structured permissions, and child mandates must be subsets of their parents.

Mapping to incidents. Table 4 states, for each incident, the expected outcome under the design. These are qualitative judgments derived from the incident reports and the design, not measurements.

IncidentOutcomeMechanism
GitHub MCP injectionContainedMandate limits the agent to named repositories; cross-repository publication outside them is refused.
Comment and ControlBlockedNo secrets exist in the agent’s environment; review agents receive no secret-reading scope.
Coding-agent exploitsContainedPolicy is enforced by the AA outside the agent, so repository content cannot disable it; tokens are not exposed to exfiltrate.
Nx s1ngularityBlockedNo credentials on disk to harvest; hardware keys cannot be read.
Shai-Hulud wormBlockedPublishing requires per-action human approval, and credentials cannot be used from other machines.

Table 4. Expected outcome of each incident under the design (qualitative).

Related Work

Standards work on agent identity. The IETF WIMSE working group’s AIMS document [21] composes workload identity, OAuth and shared signals into a model for agent authentication and authorization, treating agents as workloads; it does not bind agent keys to devices or to a human approver’s passkey. AAuth [22] gives each agent its own signing key and signs every request, with optional platform attestation in its bootstrap guidance. The PTV draft [23] binds agent identity to TPM-anchored attestation of model and policy, and condition-bound credentials [24] make TPM-resident keys usable only while a verified user is present on an endpoint. That design centres on endpoint-resident keys; our cross-device step-up targets the case of a cloud agent acting for a human on a different device. ID-JAG [7] and MCP’s enterprise-managed authorization [8] give IdPs control over which applications an agent may reach; our design supplies them with stronger evidence rather than replacing them. The FIDO Alliance has formed working groups on agentic authentication and delegation for commerce [25], and NIST’s NCCoE has begun a project on software and AI agent identity [26].

Products. Enterprise offerings register agents as directory identities with sponsors and conditional access [27], issue certificate-backed agent credentials with human owners and policies [28], or authorize each tool call at an agent gateway with identity-correlated audit logs [29]. None that we are aware of binds an agent’s key to attested hardware and to a passkey-signed mandate within one credential.

Research. South et al. [30] propose authenticated, scoped delegation from humans to AI agents by extending OAuth and OpenID Connect; our work shares the delegation model and adds hardware binding, runtime-enforced origin binding and attestation. Personhood credentials [31] address the complementary problem of proving that a human, not an AI, is present.

Limitations and Future Work

No implementation or measurements yet. This paper presents a design and an informal analysis. We have not built a full Agent Authenticator, so we report no performance, usability or deployment measurements. A reference implementation on Linux with TPM 2.0, on macOS with the Secure Enclave, and in one confidential-computing environment is the immediate next step.

Formal verification. The analysis in § 8 is informal. We plan to model registration, authentication, step-up and sub-delegation in a symbolic protocol verifier such as Tamarin and to state and prove origin binding, approval non-replay and monotonic delegation as formal properties.

Local process identity. Hardware protects keys from being copied, but most desktop operating systems cannot attest which process requested a signature. The AA’s process-lineage check is a software control, and an administrator-level adversary defeats it. Stronger local isolation, for example running agents in lightweight virtual machines with their own attestation, deserves study.

Privacy. Hardware attestation is linkable across relying parties. Sending only normalized levels mitigates this partially; unlinkable presentation using anonymous credentials or Direct Anonymous Attestation is future work.

Human factors. Step-up approvals invite approval fatigue. The design limits approvals to actions listed in the mandate and renders exactly what is being signed, but whether people review such prompts carefully needs user studies.

Trust roots and adoption. Assurance ultimately depends on hardware and cloud vendors’ attestation roots. Adoption depends on IdPs and services accepting agent assertions; the bindings in Section 6 are designed to minimize that cost, and we intend to pursue standardization of the protocol.

Conclusion

Agents need credentials, and today they get the worst kind: ambient, exportable, broadly scoped bearer secrets protected by controls that the agent itself can be talked out of. The Agent Authenticator transfers the properties that made passkeys effective for people, hardware-held keys, per-service scoping and an origin chosen by trusted software rather than by the party being protected, to autonomous agents, and adds what agents uniquely need: human-signed scoped mandates, per-action human approval that works across devices, normalized environment attestation, and records that bind every action to the credential and the person that authorized it. Because it deploys as a profile over MCP, OAuth, ID-JAG, git and cloud identity, it can be adopted incrementally. We hope this design provides a concrete starting point for standardizing how agents authenticate.

Acknowledgments and Use of Generative AI

The author used Claude (Anthropic), a large language model, to assist with literature search, drafting and editing text, preparing figures, and producing the LaTeX source. The author reviewed and edited all content, checked every reference against its original source, and takes full responsibility for the paper. The language model is not an author of this work.

References

  1. [1]W3C. Web authentication: An API for accessing public key credentials, level 3. W3C Recommendation, 25 August, 2026.
  2. [2]FIDO Alliance. Client to authenticator protocol (CTAP) 2.2. FIDO Alliance Proposed Standard, 2025.
  3. [3]M. Jones, A. Nadalin, B. Campbell, J. Bradley, and C. Mortimore. OAuth 2.0 token exchange. RFC 8693, 2020.
  4. [4]M. Jones, B. Campbell, and C. Mortimore. JSON Web Token (JWT) profile for OAuth 2.0 client authentication and authorization grants. RFC 7523, 2015.DOI
  5. [5]T. Lodderstedt, J. Richer, and B. Campbell. OAuth 2.0 rich authorization requests. RFC 9396, 2023.DOI
  6. [6]D. Fett, B. Campbell, J. Bradley, T. Lodderstedt, M. Jones, and D. Waite. OAuth 2.0 demonstrating proof of possession (DPoP). RFC 9449, 2023.DOI
  7. [7]A. Parecki, K. McGuinness, and B. Campbell. Identity assertion JWT authorization grant. Internet-Draft draft-ietf-oauth-identity-assertion-authz-grant-04, work in progress, 2026.
  8. [8]Model Context Protocol. MCP authorization specification and authorization interest group charter, 2026.
  9. [9]H. Birkholz, D. Thaler, M. Richardson, N. Smith, and W. Pan. Remote ATtestation procedureS (RATS) architecture. RFC 9334, 2023.DOI
  10. [10]L. Lundblade, G. Mandyam, J. O’Donoghue, and C. Wallace. The entity attestation token (EAT). RFC 9711, 2025.DOI
  11. [11]H. Birkholz, A. Delignat-Lavaud, C. Fournet, Y. Deshpande, and S. Lasker. An architecture for trustworthy and transparent digital supply chains. RFC 9943, 2026.DOI
  12. [12]Invariant Labs. GitHub MCP exploited: Accessing private repositories via MCP, 2025.
  13. [13]Cloud Security Alliance. Research note on prompt injection of AI coding agents in CI pipelines (7 august 2026), 2026.
  14. [14]VentureBeat. Six exploits broke AI coding agents. IAM never saw them, 2026.
  15. [15]GitGuardian. The Nx slngularity attack: Inside the credential leak, 2025.
  16. [16]Elastic Security Labs. Shai-hulud strikes again: CHAINDROP worm hits 400+ npm packages, 2026.
  17. [17]Astrix Security. Astrix researchers uncover credential risk in the majority of MCP servers, 2025.
  18. [18]GitGuardian. The state of secrets sprawl 2026, 2026.
  19. [19]M. Jones and N. Sakimura. JSON Web Key (JWK) thumbprint. RFC 7638, 2015.DOI
  20. [20]OpenID Foundation. Shared signals framework, CAEP and RISC 1.0. OpenID Foundation Final Specifications, 2025.
  21. [21]P. Kasselman, J. Lombardo, Y. Rosomakho, B. Campbell, N. Steele, and A. Parecki. AI identity management system (AIMS). Internet-Draft draft-ietf-wimse-aims, work in progress, 2026.
  22. [22]D. Hardt. AAuth protocol. Internet-Draft draft-hardt-oauth-aauth-protocol-11, work in progress, 2026.
  23. [23]A. Damodaran. The prove-transform-verify (PTV) protocol for attested agent identity. Internet-Draft draft-anandakrishnan-rats-ptv-agent-identity-01, work in progress, 2026.
  24. [24]T. Nguyen-Huu, S. Nikitin, and J. O’Leary. Condition-bounded credentials for workload and agent identity: Non-exfiltratable keys and validity by presence. Internet-Draft draft-winmagic-wimse-condition-bounded-credentials-01, work in progress, 2026.
  25. [25]Help Net Security. FIDO alliance wants to keep AI agents from going rogue on online payments, 2026.
  26. [26]NIST National Cybersecurity Center of Excellence. Accelerating the adoption of software and AI agent identity and authorization (concept paper and comment summary), 2026.
  27. [27]Microsoft. Governing agent identities: Microsoft Entra ID governance, 2026.
  28. [28]DigiCert. AI agent trust: Identity, security and governance, 2026.
  29. [29]Cisco Duo. Duo brings identity and authorization across AI agent gateways, 2026.
  30. [30]T. South, S. Marro, T. Hardjono, R. Mahari, C. D. Whitney, D. Greenwood, A. Chan, and A. Pentland. Authenticated delegation and authorized AI agents. arXiv:2501.09674, 2025.arxiv.org/abs/2501.09674
  31. [31]S. Adler, Z. Hitzig, S. Jain, et al. Personhood credentials: Artificial intelligence and the value of privacy-preserving tools to distinguish who is real online. arXiv:2408.07892, 2024.arxiv.org/abs/2408.07892

Paper details

vlnc:W_th5xy7gt
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 2

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Claude (Anthropic)

View statement
Looking for related papers…
Contents