Why agent identity is a new problem

We already identify software: service accounts, API keys, mTLS certificates, SPIFFE workload identities. So why is agent identity a genuinely new problem?

Because an autonomous agent combines three properties that existing machine-identity tooling was not built to express together: it acts on behalf of a principal, it decides what to do across many steps, and it needs per-action, revocable authority. A service account is a fixed caller with fixed rights. An agent is a delegate with judgement.

The Cloud Security Alliance states the gap plainly: autonomous AI agents have “created a new identity category that legacy non-human identity models were not built to handle, because agents are ephemeral, delegate authority across trust boundaries, and act without a human present.” Microsoft’s agent platform adds that agents need “purpose-built identity constructs” of their own.

This page explains what the older tools did, exactly what is different about agents, what that looks like as a request flow, the mistakes teams make, and which standards address which gap. For the practice that closes the gap, see What is Know Your Agent (KYA)?.

What we had before

Each prior actor type solved part of the problem — and left a gap.

  • Service accounts and API keys authenticate a caller. They prove a secret was presented, but they do not say who the caller represents, what it is allowed to do beyond a static scope, or how to revoke access quickly and precisely. OWASP created a dedicated non-human-identity risk list precisely because such identities carry distinct risks.
  • Workload identity (for example SPIFFE/SPIRE) gives services cryptographic identities derived from where and what they are, not a shared secret. Excellent for service-to-service calls — but a workload identity identifies a workload, not a principal or a mandate.
  • mTLS and certificates prove possession of a private key and support revocation, but they are hard to scope to fine-grained, short-lived permissions.
  • OAuth 2.0 introduced delegated authorization: a token with scopes, issued to a client acting “on behalf of the resource owner.” This is the closest ancestor of agent identity — and the reason agent identity work is landing in the IETF’s OAuth community.

None of these was designed for software that chooses its next action.

What is actually different about agents

1. They act on behalf of someone

A service account usually acts for itself or its owner-operator. An agent acts for a principal — a person or organisation that is legally accountable. Identity therefore needs a link from agent to principal, not just an agent credential. This is why IETF OAuth work for AI agents threads the agent’s identity through user consent and into the access token, so the delegation path is documented.

2. Authority is dynamic and per-action

You cannot express “this agent may pay up to €200 for a train ticket today” as a static account. The authority must be scoped, time-bound, and evaluated per request. OAuth’s Rich Authorization Requests (RFC 9396) let a client request fine-grained `authorization_details`, and the Model Context Protocol authorisation spec is built on OAuth so tool calls can be constrained.

3. They are probabilistic

Traditional authorization is deterministic: a rule either matches or it does not. An agent’s behaviour is generated, so it can be manipulated. NIST lists prompt injection among the risks of weak agent identity and governance, and the OWASP LLM Top 10 treats prompt injection as a leading risk that can “enable unauthorized access” or “execute arbitrary commands in connected systems.” Identity does not fix that, but identity is what stops a manipulated or spoofed agent from being trusted anyway.

4. They need verifiable claims, not just keys

Proving an agent is who it says — that it runs approved code, under a named principal, with a defined mandate — calls for tamper-evident, machine-verifiable evidence. SPIFFE’s identity documents are “proven as authentic” and “proven to belong to the presenter.” The W3C Verifiable Credentials data model defines the issuer/holder/verifier roles for exactly this kind of claim, and payment protocols such as AP2 use verifiable digital credentials so a merchant can check the user’s intent rather than infer it.

5. They need to be identifiable to strangers

An agent increasingly interacts with services that have no prior relationship with it — browsing, purchasing, booking. Web Bot Auth lets a previously unknown agent cryptographically sign its HTTP requests so a site can verify it is a legitimate, registered bot. This is a different shape from enterprise IAM, where both sides are usually known to each other.

6. They need fast, precise revocation

Compromise or misalignment must be stoppable in seconds, scoped to one agent or one mandate, without disabling a whole integration. That requires revocation paths — OAuth token revocation (RFC 7009), or credential status and short expiry — designed in from the start.

Step by step: an API-key call vs an agent action

The difference is easiest to see as two request flows.

A classic API-key call:

  1. The caller presents a static key.
  2. The service checks the key against a stored value.
  3. If it matches, the caller gets whatever the key’s static scope allows.
  4. There is no principal, no per-action limit, and no clean way to revoke one caller without rotating a key others may share.

That model answers one question — does the caller hold valid credentials? — and assumes the caller is benign and tightly scoped by construction.

A modern agent action:

  1. The agent presents a cryptographic identity; the service verifies it against the issuer’s published key material.
  2. The agent presents a scoped, time-bound delegation that names the principal and the permitted actions.
  3. The service evaluates this request against current policy: is the agent still approved, and is this action inside its mandate?
  4. High-risk actions trigger a step-up approval from the human principal.
  5. The action is logged with the agent, principal and mandate.
  6. If the mandate is revoked, or a credential expires, the next request fails — narrowly.

The gap between these two flows is the whole point. The first proves possession of a secret; the second establishes identity, principal, authority and revocability.

Comparison: from API keys to agent identity

PropertyAPI key / static secretService accountWorkload identity (e.g. SPIFFE)Agent identity
What it provesPossession of a secretAn account with rightsAn attested workload’s identityAn agent’s identity, bound to a principal
LifetimeOften long-lived or non-expiringUsually long-livedShort-lived, rotated automaticallyShort-lived, scoped to a mandate
Names a principalNoNoNo (identifies the workload)Yes
Expresses delegated authorityNoNot beyond static rightsNoYes, explicit and scoped
RevocationRotate the keyDisable the accountExpiry and trust-bundle updatesRevoke the mandate or the agent identity
Per-action limitsNoNoNoYes, evaluated per request
Fit for autonomous agentsPoorPartialPartial (identity only)Purpose-built

Why “just treat it as a service account” fails

A service account model answers one question — does the caller hold valid credentials? — and implicitly assumes the caller is benign, deterministic, and tightly scoped by construction.

For an agent, that model leaves the hard questions unanswered:

  • Who is accountable if the agent acts wrongly?
  • Was this action within the mandate?
  • How do you prove the agent is the approved one and not a spoof?
  • How do you revoke precisely without collateral damage?
  • How do you keep a defensible record?

Those are KYA questions. They are not new in kind — KYC asked “who is this and should we trust them” of customers; zero trust asked it per request for resources, for “person and non-person entities” alike. They are new in combination: a non-human actor, a legal principal, per-action authority, and machine-verifiable evidence.

Common mistakes

  • Believing a longer API key is stronger identity. Length does not add a principal, a mandate or a revocation path. A leaked static key can be “inadvertently exposed through code repositories, logs, or configuration files.”
  • Assuming network location is trust. Zero trust’s basic tenet is to “remove the implicit trust in users, services, and devices based only on their network location, affiliation, and ownership.” An agent on an internal network is not thereby trustworthy.
  • Confusing impersonation with delegation. If a downstream service cannot tell whether the agent is the user or merely acts for the user, you cannot log or limit actions correctly. RFC 8693 exists to keep that distinction explicit.
  • Using scopes as the only limit. Scopes bound what kinds of access a token carries; they are not a per-action mandate with limits, expiry and approval steps.
  • Leaving orphaned agents. Agents “persist long after the business context that originally justified their privileges has changed,” and improper offboarding leaves exploitable identities behind. Inventory and lifecycle are part of the fix.
  • Expecting identity to stop prompt injection. It does not. Identity is the layer that prevents a manipulated agent from being trusted as though nothing happened.

What good looks like (in progress)

As of October 2026, no single standard solves agent identity end to end. But a workable pattern is assembling from existing pieces:

  1. A cryptographic agent identity (workload identity, certificates, or signed requests).
  2. A verifiable link to a principal (the KYC/KYB subject).
  3. A scoped, time-bound, revocable credential expressing the mandate.
  4. Per-request policy evaluation (zero trust) that checks identity and authority.
  5. Tamper-evident logs of actions and the authority behind them.
  6. A working revocation path.

Everything except the agent-specific conventions is mature technology. The new work — in the IETF, the OpenID Foundation, payments and the vendor ecosystems — is joining these into a coherent chain. For the practical verification steps, see how to verify an agent and code examples.

Standards map: which spec covers which gap

GapWhat addresses itSource
Verifiable workload identitySPIFFE identity documents (SVIDs), short-lived and attestedSPIFFE Concepts and specification
Delegation vs impersonationOAuth 2.0 token exchange semanticsRFC 8693
On-behalf-of flows for agentsOAuth extension identifying the acting agentIETF draft-oauth-ai-agents-on-behalf-of-user
Agent authentication and authorization modelApplying WIMSE and the OAuth family to agentsIETF draft-klrc-aiagent-auth
Fine-grained, per-request authorityRich Authorization Requests (`authorization_details`)RFC 9396
RevocationOAuth token revocation; short-lived credentialsRFC 7009; SPIFFE
Tool/agent protocol access controlOAuth-based authorisation for MCP serversModel Context Protocol authorisation spec
Identifiable unknown agentsCryptographic HTTP message signaturesWeb Bot Auth
Agent identities in platformsDedicated agent identity constructsMicrosoft Entra Agent ID; Google Cloud Agent Identity; Okta agent identity
Governance and accountabilityAgent identity and authorisation projectsNIST NCCoE; OpenID Foundation agentic-AI whitepaper
Proving user intent for paymentsVerifiable digital credentialsAgent Payments Protocol (AP2)

FAQ

Can’t I just give each agent its own service account? You can, and you should scope it tightly. But an account does not express a principal, a per-action mandate, or a revocable delegation. Use it as one layer, not the whole answer.

Is agent identity just OAuth again? OAuth is the closest fit and where much of the standards work lives. But OAuth’s classic model assumes a client and a user; agent-specific needs — identifying the agent itself, verifiable mandates, cross-domain strangers — are still being specified.

Isn’t this solved by zero trust? Zero trust gives you the decision framework — evaluate every request, for person and non-person entities. KYA supplies the identity-and-authority inputs for that decision when the requester is an agent.

Do I need verifiable credentials? Not necessarily, but you need tamper-evident, verifiable evidence of identity and authority. Cryptographically signed credentials and mandates are the leading way to get it.

Why not just rely on short-lived tokens? Short lifetimes reduce the blast radius and reliance on revocation, and they are a genuine improvement. But a short-lived token still needs to say who the agent is and whose authority it carries; expiry alone does not supply a principal or a per-action mandate.

Keep reading

Sources

  1. Cloud Security Alliance, Agentic Identity: Emerging Standards and Security Guidance — https://labs.cloudsecurityalliance.org/research/csa-slack-20260916-225950-csa-styled/ (accessed 2026-10-03)
  2. Cloud Security Alliance, Agent Identity Governance Framework v1 — https://labs.cloudsecurityalliance.org/agentic/agentic-identity-governance-framework-v1/ (accessed 2026-10-03)
  3. Microsoft Learn, What is Microsoft Entra Agent ID? — https://learn.microsoft.com/en-us/entra/agent-id/what-is-microsoft-entra-agent-id (accessed 2026-10-03)
  4. NIST NCCoE, Agentic AI Identity and Authorization Project Resource Hub — https://pages.nist.gov/nccoe-ai-identity/ (accessed 2026-10-03)
  5. OWASP, Non-Human Identities Top 10 — https://owasp.org/projects/non-human-identities-top-10 (accessed 2026-10-03)
  6. OWASP Gen AI Security Project, LLM01:2025 Prompt Injection — https://genai.owasp.org/llmrisk/llm01-prompt-injection/ (accessed 2026-10-03)
  7. SPIFFE, SPIFFE Concepts — https://spiffe.io/docs/latest/spiffe-about/spiffe-concepts/ (accessed 2026-10-03)
  8. SPIFFE, Secure Production Identity Framework for Everyone (SPIFFE) specification — https://raw.githubusercontent.com/spiffe/spiffe/main/standards/SPIFFE.md (accessed 2026-10-03)
  9. IETF, RFC 6749: The OAuth 2.0 Authorization Framework — https://www.rfc-editor.org/rfc/rfc6749.html (accessed 2026-10-03)
  10. IETF, RFC 8693: OAuth 2.0 Token Exchange — https://www.rfc-editor.org/rfc/rfc8693.html (accessed 2026-10-03)
  11. IETF, RFC 9396: OAuth 2.0 Rich Authorization Requests — https://www.rfc-editor.org/rfc/rfc9396.html (accessed 2026-10-03)
  12. IETF, RFC 7009: OAuth 2.0 Token Revocation — https://www.rfc-editor.org/rfc/rfc7009.html (accessed 2026-10-03)
  13. IETF, draft-klrc-aiagent-auth-00: AI Agent Authentication and Authorization — https://www.ietf.org/archive/id/draft-klrc-aiagent-auth-00.html (accessed 2026-10-03)
  14. IETF, draft-oauth-ai-agents-on-behalf-of-user-02: OAuth 2.0 Extension: On-Behalf-Of User Authorization for AI Agents — https://datatracker.ietf.org/doc/html/draft-oauth-ai-agents-on-behalf-of-user-02 (accessed 2026-10-03)
  15. Model Context Protocol, Authorization — https://modelcontextprotocol.io/specification/draft/basic/authorization (accessed 2026-10-03)
  16. Cloudflare, Web Bot Auth — https://developers.cloudflare.com/bots/reference/bot-verification/web-bot-auth/ (accessed 2026-10-03)
  17. NIST, SP 800-207A: A Zero Trust Architecture Model for Access Control in Cloud-Native Applications in Multi-Cloud Environments — https://csrc.nist.gov/pubs/sp/800/207/a/final (accessed 2026-10-03)
  18. Google Cloud, Agent Identity overview — https://docs.cloud.google.com/iam/docs/agent-identity-overview (accessed 2026-10-03)
  19. Okta, Okta Secures AI — Identity for the Agentic Enterprise — https://www.okta.com/solutions/secure-ai/ (accessed 2026-10-03)
  20. Agent Payments Protocol (AP2) — https://ap2-protocol.org/ (accessed 2026-10-03)
  21. OpenID Foundation, Identity Management for Agentic AI (whitepaper, October 2025) — https://openid.net/wp-content/uploads/2025/10/Identity-Management-for-Agentic-AI.pdf (accessed 2026-10-03)
  22. W3C, Verifiable Credentials Data Model v2.0 (W3C Recommendation, 15 May 2025) — https://www.w3.org/TR/vc-data-model-2.0/ (accessed 2026-10-03)

Know Your Agent (KYA) explains agent identity, verification and accountability. This is an explainer, not legal or compliance advice — see our Sources & methodology. New to KYA? Start with What is Know Your Agent? and the glossary.

Last reviewed: 8 October 2026. Sources are listed with the page and in our Sources & methodology.