What is Know Your Agent (KYA)?

Know Your Agent (KYA) is the practice of establishing and verifying what an autonomous software agent is, who is accountable for it, what it is authorised to do, and whether it can be trusted to act — before you give it access, authority, or money.

KYA is the agent-era counterpart to Know Your Customer (KYC): KYC verifies the customer; KYA verifies the agent. If you are new to that comparison, start with KYA vs KYC vs KYB.

KYC asks a human a question once, at onboarding: is this customer who they say they are? KYA asks a question at machine speed, per request: is this the agent it claims to be, who stands behind it, and is this specific action within its mandate? That shift — from a periodic identity check to a continuous authority check — is why KYA is a governance discipline, not a form to fill in.

No standards body formally defines “Know Your Agent” as a term as of October 2026; we use it here as an umbrella label for the practice described on this page. The underlying activity — identity, authorisation, accountability and governance for agents — is real and is being standardised right now.

This page defines KYA, breaks it into layers, walks through a worked example, lists the mistakes teams make, gives a readiness checklist, and maps the standards you can use today.

Why KYA exists

For decades, the actor on the other side of a digital transaction was either a person or a fixed piece of software. Identity practice grew around those two cases: KYC for people and companies (a regulatory anti-money-laundering duty built on customer due diligence), and machine identity for services and workloads (credentials for a process, not a principal).

Autonomous agents break that split. An agent is software, but it acts on behalf of a person or an organisation, often for many steps, with its own initiative and tool access. The service it talks to must decide, per request: is this really the agent it claims to be, who stands behind it, and is this specific action within its authority?

NIST’s National Cybersecurity Center of Excellence (NCCoE) frames the same gap: as systems become capable of taking autonomous actions, “traditional identity and access management approaches may not fully address emerging challenges,” and it is running a project on standards-based approaches to identify, manage and authorise access and actions taken by software and AI agents.

The OpenID Foundation puts it precisely: today’s authentication and authorization standards can already secure many simple agents, but “the frameworks that secure today’s agents weren’t designed for recursive delegation chains, cross-domain trust propagation, or the scale of authorization decisions that autonomous systems will demand.”

That decision — whether to trust this agent, for this action, now — is what KYA operationalises. The work is not one check at onboarding; it is a lifecycle: enrol, verify, authorise, monitor, and revoke.

The five questions KYA answers

  1. Identity — What is this agent, technically? Does it have a verifiable identifier?
  2. Principal — Who is legally accountable for its actions?
  3. Authority — What is it permitted to do, for how long, up to what limits?
  4. Evidence — Can it prove it is what it claims to be, and can actions be traced?
  5. Lifecycle — How is it onboarded, monitored, and revoked?

If you can answer all five for a given agent, you have done KYA for it. If you can answer only “it presented an API key”, you have not.

What KYA covers

KYA sits at the intersection of several established disciplines. It does not replace them; it names the gap between them.

LayerQuestionTypical standards / practice
IdentityWho or what is the actor?SPIFFE workload identity; purpose-built agent identities in cloud IdPs
PrincipalWho is accountable?KYC/KYB due diligence; the agent’s principal under delegation
DelegationOn whose authority does it act?OAuth 2.0 “on behalf of”; OAuth token exchange (RFC 8693)
CredentialsWhat proves its rights?Short-lived, attested credentials; cryptographic workload identity
PermissionsWhat may it do?Scoped, least-privilege tokens; zero-trust per-request policy
AuditWhat did it do?Logging and record-keeping; agent lifecycle management
RevocationHow is it stopped?Short-lived credentials; token revocation; credential/agent disablement

Each row has mature standards; the KYA problem is joining them into one verifiable chain from principal to agent to action. Several of these terms have their own entries — see agent identity, principal, delegation and revocation.

How KYA works, step by step

A KYA flow has a small number of moving parts. In sequence:

  1. Enrol the agent and bind it to a principal. The agent is registered, and the accountable principal (a person or organisation) is recorded. An agent identity is a purpose-built construct, distinct from user and workload identities; Microsoft’s agent platform describes agents receiving “purpose-built identity constructs to authenticate, authorize, govern, and protect these nonhuman identities.” The principal is the KYC/KYB subject — without it, nobody is answerable.
  2. Give the agent a verifiable identity. Rather than a shared static secret, modern practice issues a cryptographic identity. SPIFFE issues a Verifiable Identity Document (SVID) that is “proven as authentic” and “proven to belong to the presenter,” with private keys that are “short lived, rotated frequently and automatically.” Google Cloud’s Agent Identity is explicitly built on the SPIFFE standard.
  3. Express the mandate as scoped delegation. OAuth defines a client as “an application making protected resource requests on behalf of the resource owner and with its authorization.” RFC 8693 formalises the difference between delegation and impersonation, so a downstream service can see who is acting and on whose behalf.
  4. Issue least-privilege credentials. Authority is bounded in time, action and amount. Zero trust removes implicit trust based on network location and applies to “identity (person and non-person entities)”; agent platforms apply adaptive access policies and lifecycle controls to agents.
  5. Decide per request. Each call is evaluated against current policy: is this agent still the approved one, and is this action inside its mandate? The Model Context Protocol builds its authorisation on OAuth, with MCP servers acting as OAuth resource servers.
  6. Record what happened. Actions and the authority behind them are logged so the chain from principal to action can be reconstructed.
  7. Revoke fast and precisely. Compromise or misalignment must be stoppable in seconds, scoped to one agent or one mandate. Short-lived credentials reduce reliance on revocation, and explicit revocation paths exist for what remains.

Steps 1–4 establish who the agent is and what it may do. Steps 5–7 keep that true over time.

Worked example: an agent books and pays for a train ticket

This scenario is illustrative — it shows how the pieces fit; it is not a description of one product.

A traveller asks their assistant agent to “book the 07:14 to Tampere and pay for it.”

  1. The agent presents its identity to the booking service. That identity was issued when the agent was enrolled, and it is bound to the traveller’s account (the principal).
  2. The service checks the agent’s credential and verifies it against the issuer’s published key material. A short-lived credential means there is no long-lived API key sitting in a config file to leak.
  3. The agent presents a mandate — a scoped delegation — that says it may act for this traveller, for travel booking, up to a stated amount, until a stated time. Because the mandate distinguishes delegation from impersonation, the merchant can see both that the agent is acting and that it acts for the traveller.
  4. For payment, the agent presents a signed, verifiable credential expressing the traveller’s intent, so the merchant can verify intent cryptographically rather than infer it. The Agent Payments Protocol (AP2) describes this idea under the name Verifiable Digital Credentials.
  5. The booking service evaluates the request against policy — zero trust, per request — and, if the amount exceeds a threshold, requires a step-up approval from the traveller.
  6. The action is logged: which agent, acting for which principal, under which mandate, at what time.
  7. If the traveller later revokes the mandate, the next request fails — without disabling every other integration the assistant has.

If the agent had instead presented a shared API key, steps 1, 3, 4 and 7 would be impossible: a key proves only that someone holds a secret. That difference is the KYA gap in one example.

Common mistakes

  • Treating an API key as an identity. Static credentials “can be inadvertently exposed through code repositories, logs, or configuration files,” and long-lived secrets have “expiration dates that are too far in the future or that don’t expire at all.” A key proves possession of a secret; it does not name a principal or a mandate. See why agent identity is a new problem.
  • Skipping the principal. If you cannot say which human or organisation is accountable, you have authenticated software but not established accountability. An agent is a new identity category precisely because it is ephemeral and “acts without a human present.”
  • Granting account-level, not action-level, authority. A verified agent is not thereby allowed to do anything. Authority must be scoped per action, time-bounded and revocable.
  • Forgetting offboarding. OWASP warns that improper offboarding leaves stale non-human identities that “can be exploited by attackers to gain unauthorized access to sensitive systems and data.” An agent inventory with lifecycle governance is what prevents abandoned agents from lingering.
  • Assuming prompt-injection defences are identity. Prompt injection can cause an agent to enable “unauthorized access” or “execute arbitrary commands in connected systems.” Identity controls — scoped tokens, least privilege, human approval for high-risk actions — are the layer that keeps a manipulated agent from being trusted anyway.
  • Calling it done after onboarding. Authority and risk change; KYA must be continuous and revocable.

A KYA readiness checklist

Use these as questions a system must be able to answer for each agent it lets in:

  1. Can we name the agent’s principal, and is that principal verified (KYC/KYB where regulated activity is involved)?
  2. Does the agent have a cryptographic identity we can verify, rather than a shared secret?
  3. Is the mandate explicit, scoped, time-bounded and provable?
  4. Can we evaluate each request against current policy, not just at onboarding?
  5. Do we hold a record that reconstructs principal, mandate and action?
  6. Can we revoke the agent or its mandate quickly and narrowly?
  7. Is the agent in an inventory, so nothing is orphaned?

A “no” anywhere is the gap KYA is meant to close. For the mechanics of checking an agent, see how to verify an agent; for implementation snippets, see code examples.

How KYA relates to neighbouring ideas

  • KYC is a regulated anti-money-laundering duty to identify and verify customers (people and legal persons), per FATF Recommendation 10. KYA borrows its discipline but asks about the agent, not the customer.
  • KYB (Know Your Business) is the industry label for applying due diligence to legal entities, including beneficial ownership. It tells you who the company is, not what its agent is doing.
  • IAM (identity and access management) manages accounts and permissions inside your estate. It usually assumes the actor is a known employee or service; it does not, by itself, establish who is behind an external agent.
  • Zero trust (NIST SP 800-207) says do not trust by network location; evaluate every request against policy, for person and non-person entities. KYA supplies the identity-and-authority inputs that a zero-trust decision needs for agents.
  • AI governance frameworks set up policy and accountability for AI systems. KYA is the operational identity layer those policies need at the point of access.

Where the standards are today

KYA is emerging, not settled. Several workstreams matter as of October 2026:

  • NIST NCCoE is running a project on software and AI agent identity and authorization, aiming at practical, standards-based guidance for identifying, authorising and governing agents.
  • The OpenID Foundation published an October 2025 whitepaper on identity management for agentic AI, recommending that agents “conform to rigorous, interoperable profiles of existing identity standards.”
  • SPIFFE provides short-lived, attested workload identity — the substrate several agent identity products build on.
  • W3C Verifiable Credentials Data Model 2.0 is a W3C Recommendation (15 May 2025). It defines the issuer/holder/verifier roles and the data model for tamper-evident claims, which agent credentials can reuse.
  • OAuth and the IETF carry delegation: RFC 8693 formalises delegation versus impersonation, and IETF drafts describe agent authentication/authorization and OAuth “on-behalf-of” flows that thread the agent’s identity through consent into the access token.
  • The Model Context Protocol authorisation spec is built on OAuth, with MCP servers acting as OAuth resource servers — the practical control point for tool-using agents.
  • The EU AI Act imposes transparency duties: Article 50 requires providers to ensure people are informed when they interact with an AI system, explicitly covering “chatbots, AI agents, and avatars,” and applies from 2 August 2026. For high-risk systems, Article 12 requires that the system technically allow the automatic recording of events (logs) over its lifetime. That is transparency and record-keeping, not full identity verification.
  • Payments are moving fastest, with protocols such as AP2 using verifiable digital credentials so an agent can prove the user’s intent.

None of these is a complete KYA standard. Treat any vendor claim of a finished “KYA product” with care; the useful question is which of the five questions above it actually answers, and with which verifiable evidence.

Common misconceptions

  • “It’s just API keys with extra steps.” API keys authenticate a caller; they do not express a principal, a scope, an expiry, or a revocable mandate. Identity is necessary but not sufficient for KYA.
  • “The model is the agent.” A model is a component. The agent is the running system that holds credentials and takes actions; that system is what must be identified and limited.
  • “Prompt guards are agent security.” Prompt-injection defences are valuable, but they are not identity. An attacker who impersonates a trusted agent does not need to attack the prompt.
  • “KYA is a one-time onboarding check.” Authority and risk change; KYA must be continuous and revocable.
  • “KYA means the agent is safe.” It does not. KYA is an identity-and-accountability discipline: can you tell who the agent is, who is answerable for it, what it is allowed to do, and how to revoke it. It is not a judgement that the agent is good or harmless.

This is our working definition, written to be useful rather than authoritative. It is grounded in the primary sources listed below; where the field has no settled answer, we say so.

FAQ

Is “Know Your Agent” an official standard? No. There is no single ratified standard called KYA. The term names a real, emerging problem; the building blocks are standards such as SPIFFE, OAuth/RFC 8693, the MCP authorisation spec and the OpenID Foundation’s agentic-AI work.

Is KYA only for AI/LLM agents? The term is used mostly for AI agents, but the discipline applies to any delegated autonomous actor. Classic bots and RPA already needed parts of it.

Who needs to do KYA? Anyone who lets an external or semi-autonomous agent act on their systems or accounts: API and platform teams, payments and fintech, and any organisation extending KYC/AML or IAM to agents.

Is KYA a legal requirement? Not as such. Specific duties sit in other rules — for example the EU AI Act’s transparency duty from 2 August 2026, and AML customer due diligence for the principal. KYA is the practice that connects them; it is not itself a named legal obligation.

How is KYA different from KYC and KYB? KYC and KYB verify the human or company. KYA verifies the agent and its authority. They stack: you still need KYC/KYB on the principal. See KYA vs KYC vs KYB.

Is this legal advice? No. This is an explanation for practitioners. For compliance decisions, take professional advice.

Keep reading

Sources

  1. NIST NCCoE, Agentic AI Identity and Authorization Project Resource Hub — https://pages.nist.gov/nccoe-ai-identity/ (accessed 2026-10-03)
  2. NIST NCCoE, Software and AI Agent Identity and Authorization — https://www.nccoe.nist.gov/projects/software-and-ai-agent-identity-and-authorization (accessed 2026-10-03)
  3. OpenID Foundation, New whitepaper tackles AI agent identity challenges — https://openid.net/new-whitepaper-tackles-ai-agent-identity-challenges/ (accessed 2026-10-03)
  4. 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)
  5. SPIFFE, SPIFFE Concepts — https://spiffe.io/docs/latest/spiffe-about/spiffe-concepts/ (accessed 2026-10-03)
  6. IETF, RFC 8693: OAuth 2.0 Token Exchange — https://www.rfc-editor.org/rfc/rfc8693.html (accessed 2026-10-03)
  7. IETF, RFC 6749: The OAuth 2.0 Authorization Framework — https://www.rfc-editor.org/rfc/rfc6749.html (accessed 2026-10-03)
  8. Model Context Protocol, Authorization — https://modelcontextprotocol.io/specification/draft/basic/authorization (accessed 2026-10-03)
  9. NIST, SP 800-207: Zero Trust Architecture — https://nvlpubs.nist.gov/nistpubs/specialpublications/NIST.SP.800-207.pdf (accessed 2026-10-03)
  10. 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)
  11. 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)
  12. Google Cloud, Agent Identity overview — https://docs.cloud.google.com/iam/docs/agent-identity-overview (accessed 2026-10-03)
  13. OWASP, Non-Human Identities Top 10 — https://owasp.org/projects/non-human-identities-top-10 (accessed 2026-10-03)
  14. OWASP Gen AI Security Project, LLM01:2025 Prompt Injection — https://genai.owasp.org/llmrisk/llm01-prompt-injection/ (accessed 2026-10-03)
  15. EU AI Act, Article 50: Transparency Obligations for Providers and Deployers of Certain AI Systems — https://artificialintelligenceact.eu/article/50/ (accessed 2026-10-03); official text: Regulation (EU) 2024/1689
  16. European Commission, Transparency obligations under Article 50 of the AI Act — https://digital-strategy.ec.europa.eu/en/faqs/transparency-obligations-under-article-50-ai-act (accessed 2026-10-03)
  17. FATF, The FATF Recommendations (Recommendation 10, Customer Due Diligence) — https://www.fatf-gafi.org/en/publications/Fatfrecommendations/Fatf-recommendations.html (accessed 2026-10-03)
  18. Agent Payments Protocol (AP2) — https://ap2-protocol.org/ (accessed 2026-10-03)
  19. 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)
  20. 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)
  21. 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)
  22. EU AI Act, Article 12: Record-Keeping — https://artificialintelligenceact.eu/article/12/ (accessed 2026-10-03); official text: Regulation (EU) 2024/1689

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.