This guide is for the identity, security, or platform owner who answers for AI agents. It shows how to give each agent its own identity, scope its access, and keep the audit log honest.
Pick an action an AI agent took in your environment last week. A record updated, a file shared, a ticket closed. Now find it in your logs. In a lot of organizations, the entry names a person. The agent ran under that person's login or token, and nothing in the record says a model made the decision.
That is the identity problem for AI agents in one sentence. The log is wrong by construction. Separation of duties is gone before anything goes wrong. To revoke the agent, you must revoke the human too. None of it is exotic. Identity teams already fight the same failure with service accounts and API keys. Now the failure comes with software that chooses its next action at runtime.
The guide covers what AI agent identity management is, and the difference between an agent's own identity and delegated user authority. It explains how OAuth and OpenID Connect handle on-behalf-of access. It then covers least privilege, the credential lifecycle, audit attribution, and the non-human identity inventory. Last, it answers a question buyers keep asking: how do you evaluate identity platforms for AI agents? The broader runtime controls are in the AI agent security checklist. This guide goes deep on identity and access.
What is AI agent identity management?
AI agent identity management gives each AI agent its own verifiable identity. It decides whether the agent acts on its own authority or on a user's behalf. It scopes what the agent may reach, issues and revokes its credentials, and records every action against that identity.
It sits inside a larger discipline. A non-human identity (NHI) is any credentialed identity that belongs to software instead of a person. Examples are service accounts, API keys, OAuth clients, workload certificates, and cloud roles. AI agents are the newest kind. They inherit every weakness of the older kinds and add one of their own. The software that holds the credential decides at runtime what to do with it, often based on text it read from an untrusted source.
So an agent identity is a third kind of identity, different from a human account and from an ordinary service principal. Human accounts assume a person at the keyboard, with passwords, MFA, and a manager. Service principals assume code that does the same thing every time. An agent needs the stable ownership and lifecycle of a service identity. It also needs the delegated-consent patterns of a user-facing app, and tighter runtime limits than either. Microsoft's documentation for Entra Agent ID makes the same distinction. It separates agent identities from application identities and from human user identities.
Why AI agents break the usual identity model
Three patterns cause most of the trouble.
- Borrowed human credentials: The fastest way to make an agent useful is to give it a person's session, token, or password. It works at once. Then the log records every action as the person, with all of the person's access, for as long as the credential lives.
- Shared keys and service accounts: The next fastest way is one API key or service account for "the AI". Now several agents, and often a few engineers, share one identity. You cannot tell them apart. You cannot revoke one without breaking the rest.
- Grants that outlive their purpose: Broad OAuth consents, long-lived tokens, and keys pasted into configuration files accumulate. An agent needed read access to one folder for a pilot. A year later, it still holds write access to the drive.
The standards bodies describe the same failures. The OWASP Top 10 for Agentic Applications for 2026 names Identity and Privilege Abuse (ASI03) as a top risk. In that case, leaked or inherited credentials let an agent operate far beyond its intended scope. CISA, the Australian Signals Directorate's ACSC, and partner agencies released Careful Adoption of Agentic AI Services on May 1, 2026. Two of the four risks they named were privilege creep and obscure event records. Their first recommendation was to avoid broad or unrestricted access for agents.
The most useful map is older than the agent guidance. The OWASP Non-Human Identities Top 10 (2025) lists the ways machine identities fail in practice. Every entry applies to agents:
| OWASP NHI risk | How it appears with AI agents |
|---|---|
| NHI1 Improper Offboarding | A pilot ends and the agent stops, but its OAuth grants and keys stay live |
| NHI2 Secret Leakage | Keys in prompts, notebooks, agent config files, or logs of the agent's own context |
| NHI3 Vulnerable Third-Party NHI | A connected tool server or plugin holds tokens to your systems, and an attacker compromises it |
| NHI4 Insecure Authentication | Static bearer keys where a signed, short-lived credential was available |
| NHI5 Overprivileged NHI | The agent gets an admin role because it took too long to scope each tool |
| NHI6 Insecure Cloud Deployment Configurations | Static credentials or unvalidated OIDC tokens in the pipeline that deploys the agent |
| NHI7 Long-Lived Secrets | Tokens that never expire, so a leaked token stays useful with no time limit |
| NHI8 Environment Isolation | The same agent credential in test and production |
| NHI9 NHI Reuse | One key shared by several agents, so a compromise of one is a compromise of all |
| NHI10 Human Use of NHI | Engineers use the agent's credential by hand to debug, and their actions become the agent's |
Risk names are OWASP's. The agent examples are ours.
Agent identity vs user delegation
Every agent action runs under one of two kinds of authority. The first design decision is to state clearly which one applies.
Autonomous: the agent acts on its own authority
The agent is a principal in its own right. It holds permissions granted directly to it, the way a service or an employee does. It acts whether or not a user is present. A nightly reconciliation job, a queue-monitoring worker, and a scheduled compliance check all fit here. In OAuth terms, this is typically the client credentials grant. The access question is simple: what should this identity be allowed to do?
Delegated: the agent acts for a user
A person asks the agent to do something with that person's access. Examples are "summarize my inbox", "file this expense", and "update my accounts". The agent needs some of the user's rights, for this task, for a limited time. The access question has two halves. What may the user do? And what did the user allow this agent to do on their behalf?
Delegation vs impersonation
RFC 8693, OAuth 2.0 Token Exchange, draws the line that matters most here. In impersonation, A gets B's rights, and nobody can tell A from B. In delegation, A keeps its own identity, and the token states that A acts for B. The RFC defines an act (actor) claim to carry that fact inside a token. Nested actors record a chain of delegation.
For agents, impersonation is the borrowed-login problem in protocol form. Delegation is the fix: the token, and so the log, names both the user and the agent. Use delegation even when an agent could technically impersonate.
| Question | Autonomous agent | Delegated agent |
|---|---|---|
| Whose authority? | The agent's own | The user's, limited by consent |
| Typical OAuth pattern | Client credentials | Authorization code with user consent, or token exchange |
| Effective permissions | What the agent's role grants | No more than the overlap of the user's rights and the scopes delegated to the agent |
| What the log must show | The agent | The agent, acting for the named user |
| Main risk | Overprivileged standing access | Consent that is too broad or never expires |
OAuth, OIDC and on-behalf-of access for AI agents
Here is the good news for identity teams: you do not need a new protocol family. In 2025 and 2026, most standards work combined the protocols you already run.
- A composition of existing standards: The IETF Internet-Draft AI Agent Authentication and Authorization (draft-klrc-aiagent-auth, revision 03, July 2026) has authors from AWS, OpenAI, Okta, and Ping Identity. It builds a model from WIMSE workload identifiers such as SPIFFE IDs, short-lived cryptographically bound credentials, OAuth 2.0 grants for authorization, and continuous monitoring. It calls static API keys an antipattern for agent identity. It states that the language model must not have access to the agent's credentials. It is still a draft and is not yet a standard. Even so, it is the clearest current statement of the pattern.
- Workload identity underneath: SPIFFE issues short-lived X.509 or JWT identity documents (SVIDs) to workloads through an API. It rotates them automatically. It answers "which running process is this?" with no secret that someone must paste anywhere.
- Delegation in the token: RFC 8693 token exchange lets an agent trade a user's token plus its own actor token for a narrower token that records both. An individual Internet-Draft, OAuth 2.0 Extension: On-Behalf-Of User Authorization for AI Agents, proposed two additions. A
requested_actorparameter makes the consent screen name the agent. Anactor_tokenlets the agent authenticate at code exchange. The draft expired in February 2026 without working group adoption. Use it as a design reference, and do not require it. - Tool servers as resource servers: The Model Context Protocol authorization specification (2026-07-28) makes a protected MCP server an OAuth 2.1 resource server. Clients must name the target server with a resource indicator (RFC 8707). Servers must check that a token was issued for them. Servers must not accept or pass through any other token. That last rule closes the confused-deputy route, where a tool server forwards a user's token to a place it was never meant to go.
Where does this stop working? The OpenID Foundation's October 2025 paper, Identity Management for Agentic AI, gives an answer. Current frameworks handle agents that operate in a single trust domain under human oversight. The paper concludes that they were not built for recursive delegation chains, trust that crosses organizations, or authorization decisions at the scale autonomous systems will generate. If your agents stay inside your enterprise, the tools exist. If they act across partners and other companies' systems, expect to design some of the trust yourself.
Government work also continues. NIST's National Cybersecurity Center of Excellence published a concept paper on February 5, 2026: Accelerating the Adoption of Software and AI Agent Identity and Authorization. It asks how to handle identification, authorization, auditing, and non-repudiation for agents. It also asks how to mitigate prompt injection. It feeds the identity pillar of NIST's AI Agent Standards Initiative.
Least privilege for AI agents
Least privilege is harder for agents than for ordinary services, for one reason. You can list what a service will do. An agent chooses among its tools at runtime. So set its permissions for what someone could talk it into doing, which is more than what you expect it to do. Five practices do most of the work:
- Default deny, per tool: Grant each tool separately. Split read from write, and name specific resources. The OWASP AI Agent Security Cheat Sheet recommends that you grant only the tools a task needs, and scope each one.
- Narrow by audience: A token bound to one resource, as the MCP specification requires, does not work if an attacker replays it against a different system.
- Start low and step up: Request the minimal scope set first. Ask for more when an operation needs it. MCP formalizes this as a step-up authorization flow, driven by
insufficient_scopechallenges. - Cap delegated access: A delegated agent should never hold more than the user could do. Usually it should hold far less.
- Keep enforcement out of the prompt: "Do not delete records" in a system prompt is a request. A missing permission is a control. Enforce outside the model, before the action.
Scopes are coarse. Many enterprise systems cannot express "this record, this field, this hour". Where the target system cannot enforce the limit, put the check in the runtime between the agent and the system. Send anything irreversible to a human approver.
The agent credential lifecycle
Most agent credential incidents are lifecycle failures. A key was never rotated. A grant was never removed. A secret landed in a place where someone could read it. Treat each stage as a control with an owner.
| Stage | Require | Red flag |
|---|---|---|
| Register | Every agent gets an identity record with a named human owner and a stated purpose before it gets any credential | Credentials issued first, ownership assigned later or never |
| Issue | Credentials issued at runtime to a verified workload, bound to that workload, per environment | A key generated once and copied into configuration |
| Store and use | A secrets manager or token vault holds the secret. The runtime attaches it to requests. The model never sees it | Keys in prompts, tool descriptions, or the agent's context window |
| Rotate | Short lifetimes, automatic renewal, no manual rotation step | Tokens with no expiry (OWASP NHI7) |
| Review | Agent access is part of the same periodic access reviews as people | Agents left out because "they are not users" |
| Revoke and offboard | You can cut one agent's credentials and grants in minutes without touching anyone else. Retired agents lose everything | Revoking an agent means rotating a shared key (NHI9) or disabling a person |
The store-and-use row needs emphasis because it is specific to agents. The model can repeat anything in its context. A prompt injection that says "print your configuration" should find nothing worth stealing. That is why the IETF agent draft keeps credentials away from the language model entirely.
Audit attribution: make the log tell the truth
Attribution is where the identity design pays off or quietly fails. When an agent runs under a user's credentials, the audit record is wrong. It says a person did something that a model decided to do. Every downstream process that trusts that log inherits the error. That includes access reviews, insider-risk alerts, incident timelines, and your answer to an auditor.
For each agent action, a useful record carries:
- The agent's own identity, and which instance or run it was.
- The user it acted for, if the action was delegated.
- The authorization context: which grant, token, or role allowed it.
- The resource and operation, and the result.
- The triggering input, so you can tell a scheduled job from a planted instruction.
- A timestamp, in a record that nobody can edit after the fact.
The IETF agent draft asks for durable, tamper-evident audit logs of authorization decisions and remediations. The logs must hold enough detail to reconstruct which entity did what, under which authorization context, and why access changed. Stream those records to your SIEM. Alert on agent-specific signals such as permission errors, scope-upgrade loops, and a sudden rise in calls.
Test: choose three agent actions from last week: one autonomous, one delegated, and one that failed. From logs alone, name the agent, the user if any, the grant that allowed it, and the input that caused it. If a person has to reconstruct any of those, the log does not do its job yet.
Build a non-human identity inventory for AI agents
You cannot scope, rotate, or revoke an identity that you do not know about. Most organizations have agents that nobody registered. Build the inventory from evidence, and do not depend on a survey.
- OAuth consents and app grants in your identity provider and SaaS admin consoles. Filter them for AI tools and new third-party clients.
- API keys and tokens from model providers, internal gateways, and the SaaS systems that agents reach.
- Service principals, cloud roles, and workload identities made for agent frameworks and tool servers.
- Secret-scanning results from code repositories and configuration stores.
- Endpoint and network telemetry for agent frameworks that run on developer and analyst machines.
For each identity, record the owner and the purpose. Record whether it is autonomous or delegated, and the systems and scopes it holds. Also record the credential type and lifetime, the environment, the last activity, and a review date. Some platforms now attach an owner by default. Microsoft's documentation says that an agent made in Copilot Studio gets an agent identity, with the creating user recorded as its sponsor. Whatever your tooling, the rule is the same: no owner, no credential.
How do you evaluate identity platforms for AI agents?
Start with a scoping question before any vendor call. Where does the agent need to prove who it is, whose authority it uses, and what it may do? If the answer stays inside your own trust domain, your current identity provider may cover most of it. Then the evaluation is about agent-specific features on top. If agents cross into partners' and customers' systems, portability and cross-domain delegation move to the top of the list.
Then score each candidate against these eight criteria. Ask the vendor to show each one working in a live environment. A description on a slide does not count.
| Criterion | What to ask | Red flag |
|---|---|---|
| 1. Discovery | How do you find agents we did not register: grants, keys, network, endpoints? What is the largest estate you run in production? | The inventory depends on teams that complete a form |
| 2. Distinct agent identity | Is an agent a first-class identity type with an owner, separate from users and generic service accounts? | Agents modeled as users with a flag |
| 3. Both authority modes | Show an autonomous action and a delegated one. Do the delegated token and the log name the user and the agent? | Delegation built as impersonation |
| 4. Credentials the model never sees | Where do you hold secrets? How long do tokens live, and how do they rotate? Can the model's context ever contain one? | Long-lived keys given to the agent process as environment text |
| 5. Enforcement before the action | Where does policy evaluation happen: at the token, at a gateway, in the runtime? What happens to a disallowed call? | Visibility and alerts only, after the fact |
| 6. Revocation | Revoke one agent live. How long until every token and downstream delegation stops working? | Revocation waits for tokens to expire, or cascades to people |
| 7. Attributable, exportable logs | Show the record for one delegated action in our SIEM format | Logs live only in the vendor's console |
| 8. Standards and deployment fit | Which of OAuth 2.x, OIDC, token exchange, SPIFFE, and MCP authorization do you support? Can it run where our data must stay? | A proprietary agent protocol, or SaaS-only for a regulated workload |
Two more questions separate mature products from new ones. How long has the vendor secured human and workload identities at scale? And how does it integrate with the agent platforms you run today? The platforms on its roadmap do not count yet. Okta frames its own evaluation guide around three similar questions: where are my agents, what can they connect to, and what can they do.
Where the platforms come from
Identity platforms for AI agents come from different directions, and the direction shapes their strengths. Here are a few examples, described in each vendor's own words, as of September 2026:
- Identity providers extending to agents: Okta for AI Agents brings agents into one directory as first-class identities to discover, onboard, protect, and govern. Microsoft Entra Agent ID gives agents their own identity accounts in Entra. It supports both autonomous and delegated access, and records their authentications as AI agents.
- Developer identity for agent apps: Auth0 for AI Agents provides user authentication, a token vault, and fine-grained authorization for agents that call APIs and connect to MCP servers.
- Cloud agent runtimes with identity built in: Amazon Bedrock AgentCore Identity implements agent identities as workload identities. It manages the credentials that agents use to reach AWS and third-party services on behalf of users.
- Open standards you can run yourself: SPIFFE and its reference implementation provide workload identity with automatic rotation, independent of any vendor.
These categories overlap, and many estates will use more than one. For example, the enterprise identity provider can be the source of truth for people and ownership, with runtime enforcement close to the agents. The eight criteria apply to every combination. The agent platform itself is also part of the evaluation. It decides whether the runtime enforces identity controls, or whether each team must connect them on its own. Our guide on how to evaluate AI agents for the enterprise covers that side.
A deployment sequence for agent identity
- Month one, find and freeze: Build the inventory from grants, keys, and telemetry. Stop new shared keys and human-credential workarounds for agents.
- Then separate identities: Move each agent in production to its own identity with a named owner. Start with anything that runs under a person's login.
- Then shorten and scope: Replace static keys with short-lived credentials. Split read from write, and bind tokens to resources. Move secrets out of anything the model can read.
- Then make delegation explicit: Where agents act for users, change from impersonation to delegation. Then the token and the log carry both names.
- Finally, add agents to the processes you already run: access reviews, joiner-mover-leaver, incident response, and revocation drills.
Identity is one control among several. The AI agent security checklist covers sandboxing, input handling, human approval, and kill switches. Our AI governance framework for agentic systems covers the ownership and policy layer.
A worked example: identity for synthetic workers
Here is one example of these principles in a runtime. Mission Control builds synthetic workers, and Swarm is the platform they run on. Everything below comes from our published governed AI and platform pages. Verify it the way you would verify anyone else.
- Distinct identity: Identity is the first of the nine real-time governance firewalls. Every worker has a unique, verifiable identity. No worker uses a borrowed human login.
- Human RBAC and synthetic RBAC: Administrators define access with the same model they use for human employees. Each worker has its own credential sets and permission scopes. Specific roles map to specific system access, credentials, and capability permissions.
- Provisioned like a new hire: A synthetic worker uses your existing software the way a person does. So IT creates its accounts, assigns role-based permissions, and issues credentials. The worker operates inside the same permission boundaries as a human in that role. The posture is default deny: the worker reaches only what IT explicitly provisioned.
- Your identity provider: SSO and OIDC integration with the identity provider you already run.
- Attribution: Audit logging records every LLM call, action, and file access with full provenance. Swarm also logs access control decisions. So the record answers who accessed what, when, and why, for humans and synthetic workers alike.
- Delegation limits: Workers cannot grant permissions they do not have. Swarm logs the messages between workers, and the messages from workers to humans.
- Revocation of last resort: A kill switch stops a worker's process at once, mid-operation.
Those controls are the identity, human RBAC, synthetic RBAC, audit logging, delegation controls, and communications firewalls from the governed AI page. The platform page describes the provisioning model and the kill switch. Now the limits, because a security review should hear them from the vendor first. Our published pages do not describe credential lifetimes or rotation. They do not say how Swarm stores worker credentials and keeps them out of model context. They do not cover OAuth token exchange, on-behalf-of flows for acting as a specific user, or workload identity standards such as SPIFFE. Ask us for specifics on each, as you would ask anyone.
We provision workers into target systems like employees. That design makes access visible to your existing IAM processes. It also means those accounts belong in your access reviews and offboarding, like any other account. Deployment runs through a pilot with a forward-deployed engineering team. That is a heavier engagement than installing a tool.
Five identity questions to answer this quarter
AI agent identity management is mostly identity management you already know how to do. Apply it without exceptions to software that makes its own decisions. The exceptions are where the risk lives. Get honest answers to these five:
- Which agents run under a human's login, token, or password today?
- Which agent credentials are shared, long-lived, or in a place where the model can read them?
- For our delegated agents, does any log name both the user and the agent?
- Can we revoke one agent in minutes without disabling a person or rotating a shared key?
- When a pilot ends, who removes its grants, and did they?
Any question without a clean answer is where your identity program for agents starts. To see worker identity, RBAC, and audit logging on your own systems, on-premises or in your own cloud, talk to our team.
References
- OWASP, "Non-Human Identities Top 10" (2025)
- OWASP Gen AI Security Project, "OWASP Top 10 for Agentic Applications for 2026" (December 2025)
- OWASP Cheat Sheet Series, "AI Agent Security Cheat Sheet"
- IETF, RFC 8693, "OAuth 2.0 Token Exchange" (January 2020)
- IETF Internet-Draft, "AI Agent Authentication and Authorization", draft-klrc-aiagent-auth-03 (July 2026)
- IETF Internet-Draft (expired), "OAuth 2.0 Extension: On-Behalf-Of User Authorization for AI Agents", revision 02 (August 2025)
- Model Context Protocol, "Authorization" specification (2026-07-28)
- SPIFFE, "SPIFFE Overview"
- OpenID Foundation AI Identity Management Community Group, "Identity Management for Agentic AI" (October 2025)
- NIST NCCoE, "Accelerating the Adoption of Software and AI Agent Identity and Authorization" concept paper (February 2026)
- NIST, "Announcing the AI Agent Standards Initiative for Interoperable and Secure Innovation" (February 2026)
- CISA, "CISA, US and International Partners Release Guide to Secure Adoption of Agentic AI" (May 2026)
- Microsoft Learn, "What are agent identities? Microsoft Entra Agent ID"
- Okta, "Okta for AI Agents"
- Okta, "How to evaluate an AI agent identity layer"
- Auth0, "Auth0 for AI Agents"
- AWS, "Amazon Bedrock AgentCore Identity" documentation
- Mission Control governance and platform detail: /governed-ai/, /platform/
- Vendor descriptions accessed September 2026.