Traditional IAM was built around a person who logs in, holds a session and is accountable for what happens during it, while an AI agent acts autonomously, often for someone else, across many systems and long after any login. Most IAM programmes can already authenticate an agent: give it a service principal or an OAuth client and it gets tokens. The problems start one layer up, in the processes that assume a human: joiner, mover and leaver events, access reviews, session-based policy, MFA and audit trails that end at a single user name. This guide walks through the IAM programme capability by capability and states, for each, what carries over unchanged, what needs extending and what breaks. It is written for IAM leads, identity architects and auditors deciding whether their current stack and processes can govern agents or need agent-specific identity management alongside them. The workload versus agent distinction is covered in NHI vs AI Agent Identity and the credential model in AI Agent Identity vs Service Account; this page does not repeat them.
Key takeaways
- The directory, the token service and the policy engine carry over. Agents can be registered, authenticated and authorised with the same OAuth 2.0, OpenID Connect and policy infrastructure you already run.
- Human-shaped processes are what break. HR-driven lifecycle, login-time MFA, session timeouts and quarterly manager reviews all assume a person with a start date, a manager and a session. Agents have none of these by default.
- Delegation is the biggest gap. A traditional token says who logged in. An agent token must say which agent is acting, for whom, and with what reduced authority, which needs RFC 8693 style actor claims rather than impersonation.
- Authorisation moves from login to every action. A role granted at sign-in describes what an agent could do over hours of autonomous activity. Per-task scopes, audience-bound tokens and policy checks at the tool are what limit what it actually does.
- Ownership must be mandatory, not optional. Every agent needs a named human sponsor with the power to suspend it, and a review cycle that follows the agent's purpose, not a person's employment.
The short answer
Traditional IAM can manage AI agents at the protocol level and cannot manage them at the process level. Keep your identity provider, authorisation server, secrets platform and policy engine. Add four things that a human-centred programme does not provide: a registry of agents with mandatory sponsors, a lifecycle driven by the agent's purpose and deployment events instead of HR, delegated tokens that carry both the agent and the user, and authorisation evaluated at each tool call rather than once at login.
The standards community has reached a similar position. The OpenID Foundation's October 2025 whitepaper, Identity Management for Agentic AI, from its AI Identity Management Community Group, says current frameworks serve simple agents in a single trust domain but were not designed for recursive delegation chains or cross-domain trust, and recommends treating agents as first-class identities with lifecycle management, governance and accountability. NIST's National Cybersecurity Center of Excellence runs a project on software and AI agent identity and authorisation; as of November 2026 its concept paper is open for comment on a rolling basis.
Traditional IAM and agent identity management side by side
| Capability | Traditional IAM (workforce) | AI agent identity management | Verdict |
|---|---|---|---|
| Identity source | HR system creates the joiner record | Deployment pipeline, agent platform or registry creates the agent | Breaks: new authoritative source needed |
| Accountability | The person themselves, plus a line manager | A named human sponsor and a technical owner | Extend: make sponsor mandatory |
| Authentication | Password, passkey or MFA at an interactive login | Workload credential: certificate, signed assertion, federated token | Carries over from NHI practice |
| Session | Browser or desktop session with idle and absolute timeouts | Tasks lasting seconds to days, often with no interactive session | Breaks: bound tokens to the task |
| Acting for others | Rare; admin impersonation or delegated mailbox access | The normal case: the agent acts for a user or another agent | Breaks: delegation chains required |
| Authorisation timing | Mostly at login and at application entry | At each tool call, with context about task and user | Extend: runtime policy checks |
| Behaviour | Human intent, broadly predictable within a role | Chosen from model output, can be steered by injected content | Breaks: permissions are the real limit |
| Access review | Quarterly or annual manager certification | Purpose-based recertification, plus event-triggered review on model or tool change | Extend: new triggers and reviewers |
| Leaver | HR termination disables the account | Retirement of the agent, removal of grants, revocation of stored user tokens | Breaks: no HR event will fire |
| Audit trail | User name, time, resource, action | Agent instance, delegating user, task, tool, prior actors in the chain | Extend: richer record content |
What carries over unchanged
Much of the investment in a modern IAM stack transfers directly. Treat the following as reusable infrastructure, not as a gap.
- Directory and identifiers: agents need unique, never-reused identifiers (NIST SP 800-53 Rev. 5 IA-4 Identifier Management). The major clouds now model agents as a distinct principal type inside their existing directories: Microsoft Entra Agent ID, Google Cloud Agent Identity and Amazon Bedrock AgentCore Identity (listed alphabetically by provider; see Cloud Agent Identity Services Compared).
- Token infrastructure: OAuth 2.0 authorisation servers, OpenID Connect discovery and JWT validation all apply. The Model Context Protocol authorisation specification (version 2026-07-28, current as of November 2026) builds on the OAuth 2.1 draft, RFC 8414, RFC 9728 and RFC 8707 rather than inventing a new protocol.
- Workload authentication patterns: short-lived certificates, federated workload tokens and private key JWT client authentication, already used for NHIs, are the right way to authenticate agents. Google Cloud, for example, issues each agent an X.509 certificate valid for 24 hours and binds access tokens to it.
- Secrets management: vaults, dynamic credentials and rotation policies apply as they do for any workload. The agent-specific concern is keeping secrets out of prompts and context. See the Credential Vaulting for AI Agents Guide.
- Policy engines: attribute-based and policy-as-code engines already evaluate requests with context. They need new attributes (agent, delegating user, task) but not a new engine.
- Least privilege and separation of duties: AC-6 Least Privilege and AC-5 Separation of Duties apply with more force, because an agent's behaviour is less predictable than a person's.
What breaks: five assumptions traditional IAM makes
1. Every identity has an HR record
Workforce identity governance hangs off the HR system: start date, manager, cost centre, department and termination date. Agents are created by developers, deployment pipelines and low-code platforms, sometimes many times a day. If the IGA platform only knows identities that HR creates, agents either never appear or appear as orphaned application accounts. The fix is a second authoritative source: an agent registry or the agent platform's own directory feeding the IGA platform. See the AI agent registry.
2. The actor is the accountable party
In workforce IAM the person who logs in is the person accountable. An agent cannot be accountable, so accountability must be assigned. Microsoft Entra Agent ID makes this explicit: at least one sponsor is required for each agent identity and blueprint, sponsors make lifecycle decisions (renewal, extension or removal) and can disable an agent during an incident, while owners handle technical administration such as credentials. Microsoft's documentation adds that sponsorship should be maintained for succession when a sponsor moves or leaves; it does not describe automatic reassignment, so build that into your mover and leaver process for humans.
3. Authority is established once, at login
Traditional access control front-loads the decision: authenticate strongly, evaluate conditional access, issue a session, then trust it until it expires. An agent session may span hundreds of tool calls, each chosen from model output that can be influenced by untrusted content. A role granted at the start describes the agent's ceiling, not its intended behaviour. Authorisation has to be evaluated per action, with the task and the delegating user as inputs. See Prompt Guardrails vs Policy Engines for AI Agent Actions.
4. Acting for someone else is an exception
Workforce IAM treats delegation as an edge case: shared mailboxes, executive assistants, admin impersonation. For agents it is the main pattern. RFC 8693 OAuth 2.0 Token Exchange separates the two models that matter. In impersonation the actor is indistinguishable from the subject. In delegation the actor keeps its own identity, and the issued token can carry an act claim naming the current actor, with nested act objects recording prior actors in a chain. RFC 8693 states that access decisions should consider the top-level claims and the current actor, with prior actors informational only. That last point matters for agents: if you need to enforce rules about earlier links in the chain, the authorisation server has to enforce attenuation when it issues each token. See Delegation Chains and Attenuated Authority for AI Agents.
5. Revocation follows a person leaving
Leaver processes revoke a person's accounts and sessions. An agent's retirement is a different event: the model is replaced, the use case ends or the sponsor withdraws approval. Google Cloud's documentation warns that deleting an agent does not remove IAM bindings that reference it; they remain as inactive grants to be removed manually, and a replacement agent gets a new principal. Stored user tokens are another residue: a platform token vault may hold OAuth refresh tokens obtained on users' behalf, which must be revoked when the agent retires. AWS describes the AgentCore token vault as restricting access to the specific agent and user combination that obtained each credential.
Delegation and on-behalf-of: the core design change
| Pattern | Who the target system sees | Audit result | When it fits |
|---|---|---|---|
| Agent uses its own client credentials | The agent only | "The agent did it"; the requesting user is lost unless logged separately | Background tasks with no user context, narrow and deterministic |
| Agent impersonates the user | The user only | Actions attributed to a person who did not perform them | Avoid for agents; masks autonomous actions as human ones |
| Delegated token with actor claim (RFC 8693) | User as subject, agent as actor | Both identities recorded on every call | User-facing agents acting within the user's own permissions |
| Platform agent token carrying both identities | Workload identity and user identity together | Both recorded, format defined by the platform | Managed agent platforms; AgentCore describes an agent access token created through token exchange |
| User-consented OAuth grant to a third-party API | The agent's OAuth client acting for the consenting user | Consent record at the provider plus your own logs | Agents reaching SaaS data such as calendars or CRM records |
For MCP-based tools the specification is strict about token handling: MCP servers must validate that access tokens were issued specifically for them as the audience, clients must send the resource parameter (RFC 8707) in authorisation and token requests, and an MCP server that calls upstream APIs must not pass through the token it received. Traditional IAM rarely enforced audience on internal APIs; agent architectures need it everywhere. See the MCP Authorisation Specification Guide and OAuth Token Exchange vs Token Passthrough.
Threat model: what each approach leaves exposed
Agents managed with traditional IAM only
- Orphaned agents: created outside HR, so no leaver event ever fires; credentials and grants outlive the project.
- Shared application identity: many agents behind one client registration, so one compromised instance forces revocation of all and the audit trail cannot separate them.
- Standing broad scopes: roles sized for every task the agent might perform, available to any prompt that steers it.
- Impersonation by default: the agent uses the user's token or session, so autonomous actions are logged as the person's.
- Review blindness: managers asked to certify an application account cannot judge what an agent does with it.
Agent identity management bolted on without IAM foundations
- Parallel identity silos: an agent platform with its own directory that the IGA, SIEM and PAM teams cannot see.
- Weak workload authentication: agent registries that still hand out static API keys because the platform does not federate with your identity provider.
- Delegation without attenuation: tokens that name both parties but give the agent the user's full scope set.
The Salesloft Drift incident shows the integration-token side of this risk: attackers used stolen OAuth tokens belonging to an AI chat integration to export Salesforce data from many organisations. The customer-side lessons, an inventory of connected apps and their scopes, reduced permissions and fast revocation, are exactly the controls traditional IAM tends to skip for non-human integrations. See the Salesloft Drift Breach 2025.
Worked scenario: extending a workforce IAM programme to an HR assistant agent
A company deploys an internal assistant that answers employee questions and can update personal details and book leave in the HR system on the employee's behalf. The IAM team starts from its workforce model and adapts it.
- Registration: the agent is created through the deployment pipeline, which writes a registry entry with purpose ("employee self-service for HR records"), sponsor (Head of HR Operations), technical owner (platform team) and allowed tools. The IGA platform ingests the registry as an authoritative source.
- Authentication: the agent authenticates to the authorisation server with a short-lived workload credential, not a client secret in configuration.
- Delegation: when an employee asks to book leave, the agent exchanges the employee's token for a delegated token with the agent as actor, scoped to the leave API and with the HR system as audience.
- Runtime authorisation: the HR API's policy allows a delegated write only to the subject's own record. A request to change another employee's bank details is denied even if a crafted message persuades the agent to try.
- Approval: changing bank details requires the employee to confirm in the HR system's own interface. See the Human-in-the-Loop for AI Agents Guide.
- Review: the sponsor recertifies the agent every six months and whenever the model, the system prompt or the tool list changes; a sponsor leaving triggers reassignment before removal.
- Retirement: when the assistant is replaced, the pipeline disables the identity, removes role bindings, revokes stored refresh tokens and closes the registry entry.
Decision guidance: extend IAM or add agent identity management
| Situation | Recommended approach | Why |
|---|---|---|
| A handful of deterministic automations with a model in the pipeline | Existing NHI controls in traditional IAM | The workload does not choose its actions; standard service identity governance is enough |
| User-facing agents acting in the user's own systems | Extend IAM with delegated tokens and runtime policy | The user's permissions are the right ceiling; delegation must be recorded |
| Agents created dynamically or in large numbers | Agent platform directory or registry feeding IGA | HR-driven lifecycle cannot keep pace; per-instance identities are needed |
| Multi-agent chains or cross-organisation agents | Agent identity management with delegation chain and attenuation rules | Recursive delegation is the area existing frameworks were not designed for |
| Small organisation, one agent platform | Use the platform's native agent identity, mandatory sponsor and a simple registry spreadsheet linked to IGA | Keeps one control plane without building a registry product |
| Large organisation, several agent platforms | Central registry, common token exchange service, consistent policy attributes across platforms | Prevents parallel silos and inconsistent rules |
How to implement
- Inventory first: find agents already running on application registrations, service accounts and personal tokens. Tag each with a provisional owner.
- Define the agent identity record: unique identifier, purpose, sponsor, technical owner, platform, tools, data classes, delegation model and review date. Make sponsor mandatory at creation.
- Connect the authoritative source: feed the registry or platform directory into IGA so agents appear in reviews, reports and joiner, mover and leaver workflows for their sponsors.
- Replace static credentials: move agents to short-lived workload credentials and federated tokens; vault anything that cannot be removed.
- Introduce delegated tokens: stand up token exchange for user-facing agents, enforce audience and scope reduction, and block impersonation patterns.
- Add runtime policy in audit mode: log policy decisions at tool boundaries for a pilot group of agents, compare with actual behaviour, then switch to enforce.
- Wire up kill switches: confirm sponsors and the SOC can disable an agent identity and revoke its tokens within minutes; test it.
- Roll back safely: keep previous grants recorded for each change so a broken agent can be restored quickly without reverting to shared accounts.
Detection and measurement
- Log content: every agent action record should carry agent identifier, instance, delegating user, task or request identifier, tool and target (AU-3 Content of Audit Records). Log token exchange events at the authorisation server.
- Alerts: agent credentials used from unexpected networks, tokens presented to the wrong audience, sudden growth in tool calls or data volume, and agents acting with no delegating user where one is expected.
- Signals: where supported, use the OpenID Shared Signals Framework and its Continuous Access Evaluation Profile, which defines events such as Session Revoked, Token Claims Change and Credential Change, so a user's revocation reaches the agents acting for them.
Metrics that show the programme is working:
- Percentage of agents with a named, current sponsor (target 100%).
- Percentage of agent actions on user data made with delegated tokens rather than impersonation or shared credentials.
- Number of agents still using long-lived static secrets.
- Median time from retirement decision to full revocation of grants and stored tokens.
- Recertification completion rate for agents within the review window.
- Policy denials per thousand tool calls, tracked per agent to spot steering attempts and over-scoped roles.
Framework mapping
| Framework | Reference | What changes for agents |
|---|---|---|
| NIST SP 800-53 Rev. 5 | AC-2 Account Management, AC-2(3) Disable Accounts | Account lifecycle driven by agent purpose and deployment, with sponsor-led disablement |
| NIST SP 800-53 Rev. 5 | AC-3 Access Enforcement, AC-6 Least Privilege | Enforcement at each tool call; scopes reduced per task and per delegation |
| NIST SP 800-53 Rev. 5 | IA-4 Identifier Management, IA-5 Authenticator Management, IA-9 Service Identification and Authentication | Unique per-agent identifiers, short-lived workload authenticators |
| NIST SP 800-53 Rev. 5 | AU-3 Content of Audit Records | Records include actor, delegating user and task |
| NIST CSF 2.0 | PR.AA-01, PR.AA-05 | Identities for services managed; permissions defined, enforced and reviewed for agents |
| IETF | RFC 8693, RFC 8707 | Delegation with actor claims; audience-restricted tokens |
Common failure patterns
- Treating the agent as a user: creating a licensed user account for an agent so it fits existing workflows, which gives it a mailbox, group memberships and human-scale access.
- Owner field as decoration: recording a sponsor who has no authority to disable the agent and no trigger to review it.
- Login-time trust: evaluating conditional access once and letting a long-running agent act for hours on the resulting session.
- Token passthrough: forwarding the user's token through an agent or MCP server to downstream APIs, so audience checks and attribution both fail.
- Retirement without cleanup: deleting the agent but leaving role bindings, OAuth grants and vaulted refresh tokens in place.
Practitioner checklist
- Inventory agents running on application registrations, service accounts and personal tokens.
- Make a named human sponsor mandatory at agent creation, with defined powers to disable.
- Feed an agent registry or platform directory into IGA as an authoritative source.
- Authenticate agents with short-lived workload credentials, never shared secrets.
- Use delegated tokens with actor claims for user-facing agents; prohibit impersonation.
- Enforce token audience at every API and MCP server; forbid token passthrough.
- Evaluate authorisation at each tool call with agent, user and task as inputs.
- Recertify agents on a schedule and on model, prompt or tool changes. See Agent Identity Recertification.
- Retire agents with a checklist covering grants, OAuth consents and stored tokens.
- Measure sponsor coverage, delegated-token share and time to revoke.
Standards and references
- IETF: RFC 8693 OAuth 2.0 Token Exchange
- Model Context Protocol: Authorization specification
- OpenID Foundation: Continuous Access Evaluation Profile 1.0
- OpenID Foundation: Identity Management for Agentic AI whitepaper
- NIST NCCoE: Software and AI Agent Identity and Authorization
- Microsoft Learn: Owners, sponsors and managers for agent identities
- AWS: Amazon Bedrock AgentCore Identity terminology
- Google Cloud: Agent Identity overview
Related NHI Mgmt Group resources: Agent Identity and Access Guide · PAM vs IGA vs NHI Management · AI Agent Service Accounts vs On-Behalf-Of Access · IAM vs PAM