Join our Newsletter — 33% off our NHI Course
Home› Guides› AI Agent Identity Management vs Traditional IAM: What…
Guide Agent Identity & Access

AI Agent Identity Management vs Traditional IAM: What Breaks and What Carries Over

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 14 November 2026 17 min read
On this page

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

CapabilityTraditional IAM (workforce)AI agent identity managementVerdict
Identity sourceHR system creates the joiner recordDeployment pipeline, agent platform or registry creates the agentBreaks: new authoritative source needed
AccountabilityThe person themselves, plus a line managerA named human sponsor and a technical ownerExtend: make sponsor mandatory
AuthenticationPassword, passkey or MFA at an interactive loginWorkload credential: certificate, signed assertion, federated tokenCarries over from NHI practice
SessionBrowser or desktop session with idle and absolute timeoutsTasks lasting seconds to days, often with no interactive sessionBreaks: bound tokens to the task
Acting for othersRare; admin impersonation or delegated mailbox accessThe normal case: the agent acts for a user or another agentBreaks: delegation chains required
Authorisation timingMostly at login and at application entryAt each tool call, with context about task and userExtend: runtime policy checks
BehaviourHuman intent, broadly predictable within a roleChosen from model output, can be steered by injected contentBreaks: permissions are the real limit
Access reviewQuarterly or annual manager certificationPurpose-based recertification, plus event-triggered review on model or tool changeExtend: new triggers and reviewers
LeaverHR termination disables the accountRetirement of the agent, removal of grants, revocation of stored user tokensBreaks: no HR event will fire
Audit trailUser name, time, resource, actionAgent instance, delegating user, task, tool, prior actors in the chainExtend: 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

PatternWho the target system seesAudit resultWhen it fits
Agent uses its own client credentialsThe agent only"The agent did it"; the requesting user is lost unless logged separatelyBackground tasks with no user context, narrow and deterministic
Agent impersonates the userThe user onlyActions attributed to a person who did not perform themAvoid for agents; masks autonomous actions as human ones
Delegated token with actor claim (RFC 8693)User as subject, agent as actorBoth identities recorded on every callUser-facing agents acting within the user's own permissions
Platform agent token carrying both identitiesWorkload identity and user identity togetherBoth recorded, format defined by the platformManaged agent platforms; AgentCore describes an agent access token created through token exchange
User-consented OAuth grant to a third-party APIThe agent's OAuth client acting for the consenting userConsent record at the provider plus your own logsAgents 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.

  1. 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.
  2. Authentication: the agent authenticates to the authorisation server with a short-lived workload credential, not a client secret in configuration.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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

SituationRecommended approachWhy
A handful of deterministic automations with a model in the pipelineExisting NHI controls in traditional IAMThe workload does not choose its actions; standard service identity governance is enough
User-facing agents acting in the user's own systemsExtend IAM with delegated tokens and runtime policyThe user's permissions are the right ceiling; delegation must be recorded
Agents created dynamically or in large numbersAgent platform directory or registry feeding IGAHR-driven lifecycle cannot keep pace; per-instance identities are needed
Multi-agent chains or cross-organisation agentsAgent identity management with delegation chain and attenuation rulesRecursive delegation is the area existing frameworks were not designed for
Small organisation, one agent platformUse the platform's native agent identity, mandatory sponsor and a simple registry spreadsheet linked to IGAKeeps one control plane without building a registry product
Large organisation, several agent platformsCentral registry, common token exchange service, consistent policy attributes across platformsPrevents parallel silos and inconsistent rules

How to implement

  1. Inventory first: find agents already running on application registrations, service accounts and personal tokens. Tag each with a provisional owner.
  2. 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.
  3. 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.
  4. Replace static credentials: move agents to short-lived workload credentials and federated tokens; vault anything that cannot be removed.
  5. Introduce delegated tokens: stand up token exchange for user-facing agents, enforce audience and scope reduction, and block impersonation patterns.
  6. 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.
  7. Wire up kill switches: confirm sponsors and the SOC can disable an agent identity and revoke its tokens within minutes; test it.
  8. 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

FrameworkReferenceWhat changes for agents
NIST SP 800-53 Rev. 5AC-2 Account Management, AC-2(3) Disable AccountsAccount lifecycle driven by agent purpose and deployment, with sponsor-led disablement
NIST SP 800-53 Rev. 5AC-3 Access Enforcement, AC-6 Least PrivilegeEnforcement at each tool call; scopes reduced per task and per delegation
NIST SP 800-53 Rev. 5IA-4 Identifier Management, IA-5 Authenticator Management, IA-9 Service Identification and AuthenticationUnique per-agent identifiers, short-lived workload authenticators
NIST SP 800-53 Rev. 5AU-3 Content of Audit RecordsRecords include actor, delegating user and task
NIST CSF 2.0PR.AA-01, PR.AA-05Identities for services managed; permissions defined, enforced and reviewed for agents
IETFRFC 8693, RFC 8707Delegation 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

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

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 14 November 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.