The short answer
Agentic IAM is identity and access management for AI agents. Every agent gets its own identity, proves who it is without a shared key, holds short-lived credentials scoped to one job, and acts on authority you can trace back to the person who gave it. Then you can revoke it in one place.


Published

What is agentic IAM?
Identity and access management, IAM for short, is how a business decides who can get into what. It's the logins, the passwords, the permission groups and the person who turns an account off when someone leaves. Agentic IAM applies the same discipline to AI agents, the software that reads your inbox, updates records and drafts replies on its own.
Here's the short version I give owners. An agent is a new kind of user. It works fast, it never gets tired, and it can be talked into things by a sentence hidden in an email. So it needs its own account, only the access its job calls for, a way to prove who it is, and a clear line back to the person it's working for. That's agentic IAM, and none of it requires a security department.
Most of this is older than AI. What changed is who holds the access. When the user can be persuaded by what it reads, the identity rules around it have to assume it will be fooled sometimes, and the damage has to stay small when it is.

Why agentic IAM matters now
Agents need credentials to reach your tools, and those credentials pile up faster than anyone tracks them. The 2026 Identity Security Landscape (opens in a new tab) from Palo Alto Networks counts 109 machine identities for every human one. Each of those is a login that agentic IAM has to account for.
The cost shows up in breach data. In IBM's Cost of a Data Breach Report 2026 (opens in a new tab), among organizations that reported an AI-related breach, 92% lacked proper AI access controls, as IBM's analysts explain here (opens in a new tab). That's an agentic IAM problem before it's an AI problem.
The standards people are on it too. NIST's National Cybersecurity Center of Excellence published a concept paper in February 2026 on software and AI agent identity and authorization (opens in a new tab), and in September 2026 it reported feedback (opens in a new tab) from more than 600 commenters. The summary of those comments (opens in a new tab) lands where we did: most commenters favored building on the identity standards you already have over starting from scratch, and one put it as applying existing standards to agents rather than creating a parallel identity stack.
In the same study, 21% of breached organizations reported a security incident involving an AI model or application, up from 13% the year before, as IBM's analysts note (opens in a new tab).

Breached organizations is highest in 2026 report at 21%.
| Breached organizations | |
|---|---|
| Previous year | 13 |
| 2026 report | 21 |
The four parts of agentic IAM
When I lay out agentic IAM for an owner, it comes out as four parts. Get these four right and most of the scary scenarios turn into small, recoverable mistakes.
AI agent identity: one agent, one account
Every agent gets its own identity. It never borrows an employee's login, and two agents never share one key. The joint guidance from the US, UK, Australian, Canadian and New Zealand cyber agencies, Careful adoption of agentic AI services (opens in a new tab), says developers should construct each agent as a distinct principal with its own unique keys or certificates.
For an owner, this means that when something goes wrong you can see which agent did it, and you can switch that one off without breaking the other five. An identity for AI agents is also how you keep the agent's actions separate from the person's in the log, which is the first question anyone asks after a mistake.
Agent authentication without shared secrets
Agent authentication is how the agent proves who it is to each tool it calls. A static API key pasted into a config file is the weakest form of agentic IAM, because anyone who copies the file becomes the agent. The joint guidance names the risk plainly: attackers can steal secret keys or tokens when organizations keep them static, share them across multiple agents, or protect them poorly.
The better pattern is the one the MCP authorization spec (opens in a new tab) uses for agents talking to tools. A protected server acts as an OAuth 2.1 resource server, the client names the exact server it wants a token for, and the server checks that the token was issued for it. A token for the calendar tool doesn't open the file share.
Delegated authority: acting on behalf of a person
Most agents work for someone. The sales agent drafts follow-ups for one rep, and the office agent books meetings on the owner's calendar. That's delegated authority, and the record should show both names: the agent that acted and the person it acted for.
The identity world already has words for this. The OAuth token exchange standard, RFC 8693 (opens in a new tab), separates delegation from impersonation. With impersonation, the agent becomes the person and the log can't tell them apart. With delegation, the agent keeps its own identity and its actions are recorded as the agent representing the person. In agentic IAM, pick delegation every time. It's the difference between "Sarah sent this" and "the follow-up agent sent this for Sarah, and Sarah approved it."
Short-lived, scoped credentials
A credential that never expires keeps working for whoever holds it, long after the job it was made for is done. The joint guidance asks you to replace static, long-lived secrets with ephemeral credentials that expire when the job is complete, and to require just-in-time credentials for high-impact or privileged actions. Short-lived credentials mean a leaked token is worth very little by the time anyone finds it.
Scope matters as much as lifetime. The agent that summarizes your inbox needs to read it and nothing more. NIST's Cybersecurity Framework 2.0 (opens in a new tab) asks for exactly this in PR.AA-05: permissions defined in a policy, enforced, reviewed, and built on least privilege and separation of duties.
Agentic IAM for a 5 to 50 person business
You don't need an identity team to do agentic IAM well. You need a system where each agent's account, permissions and log come built in, plus one person who knows which agents exist and what each one is for. A business with an owner, an office manager and an outside IT provider can run this, because the decisions are made once, at setup, and the system enforces them after that.
One agent, one account
Every agent gets its own identity and never borrows an employee's login or shares a key.
Authentication without shared secrets
Each agent proves who it is with a token issued for the one tool it calls.
Delegated authority
The record shows both the agent that acted and the person it acted for.
Short-lived, scoped credentials
Credentials expire when the job is done and carry only the access the job needs.

How agentic IAM fails, step by step
The joint guidance walks through a procurement agent that was given broad access to finance, email and contracts, with permissions checked only once at setup. An attacker compromised a low-risk tool the agent relied on and used the agent's privileges to modify contracts and approve payments. Because everything ran under a trusted agent identity, the audit logs looked legitimate. Security people call that a confused deputy. Here's the same chain with the control that breaks each link.
- The agent holds more access than its job needs. The control: least privilege per agent and per task, reviewed on a schedule.
- A shared or static key gets copied. The control: one identity per agent, short-lived credentials, and keys that never sit in code or chat.
- A token issued for one tool gets replayed at another. The control: tokens bound to one audience, and servers that refuse anything else. The MCP spec says servers must not accept or transit any other tokens.
- The agent is talked into a payment or a contract change. The control: anything that moves money or leaves the business waits for a named person's approval.
- Nobody can tell afterwards who did what. The control: delegation recorded with both names, and a log the agent can't edit.
Too much access
Least privilege per agent and per task, reviewed on a schedule, keeps the agent's reach small.
Key gets copied
One identity per agent and short-lived credentials make a copied key worth little.
Token replayed elsewhere
Tokens bound to one audience are refused by every other server.
Agent talked into it
Anything that moves money or leaves the business waits for a named person's approval.
Nobody can tell
Delegation recorded with both names and a log the agent can't edit show who did what.

How agentic IAM maps to the standards
You don't have to invent a framework for this. Agentic IAM sits inside the ones you may already answer to, which is good news when an auditor or a customer's security questionnaire shows up.
NIST CSF 2.0 PR.AA
The Protect function's identity category covers users, services and hardware. PR.AA-01 says identities and credentials for authorized users, services and hardware are managed by the organization, and PR.AA-03 says they are authenticated. An AI agent is a service in that language, so it falls under the rules you already have.
OWASP ASI03 and the NHI list
OWASP's Top 10 for Agentic Applications for 2026 (opens in a new tab) lists Identity and Privilege Abuse as ASI03. OWASP's own first quarter round-up (opens in a new tab) tags several real incidents with it, including one where the central failure was privilege abuse through a service agent's identity. The OWASP Non-Human Identities Top 10 (opens in a new tab) covers the keys underneath: insecure authentication (NHI4), overprivileged identities (NHI5) and long-lived secrets (NHI7).
The MCP authorization spec
When agents reach tools through the Model Context Protocol, the authorization spec is the agentic IAM rulebook for that connection. Authorization is optional in the protocol, and when a server over HTTP uses it, the spec builds it on OAuth 2.1 and requires resource indicators under RFC 8707 so every token names the one server it's for, and least-privilege scope requests, with more scope asked for step by step when a task needs it.

What we've learned running agentic IAM ourselves
We run Kief Studio on LTFI, so these aren't hypotheticals for us. My wife and partner Amelia handles how agents get added and retired on the operations side, and I handle what each one can touch. A few things we'd tell anyone.
- Name every agent after its job. "Follow-up agent for sales" tells you what access it should have, and "the AI" tells you nothing.
- Delegation beats impersonation every time. The first time you need to answer a customer's question about an email, you'll want both names on the record.
- Permission creep often starts at setup, when someone grants broad access to get a demo working and nobody narrows it afterwards. Review agent access thirty days in.
- The approval step does more for agentic IAM than any clever detection does. A fooled agent that can't send, pay or delete without a person's yes can waste some time, and it can't do lasting harm.

How LTFI handles agentic IAM
LTFI is the agentic business operating system Kief Studio makes and runs. These are the identity and access controls it ships with today.
- Each AI teammate owns one job, and you talk to one chief of staff, which hands out the work.
- Anything that sends, posts, publishes or spends waits for the person who owns it.
- Rules, permissions, credentials, deleting and money stay with people. An AI teammate can't change them.
- Standing approvals are given for one kind of work and taken back at any time.
- The activity log records every action by the staff and the team, newest first, with who approved it.
- Your company runs on its own dedicated server, and your AI runs on keys you own, with spend caps you set.


What to do about agentic IAM this month
Two lists: one for the person who owns the business, one for whoever runs its systems.
If you own the business
- List every AI tool or agent that can log in to company email, files, the CRM or the bank, and write down whose behalf each one works on.
- Make sure no agent uses a person's login. If one does, that's the first thing to fix.
- Decide which actions need your yes: sending, paying, deleting and changing permissions are a good start.
- Ask any AI vendor to show you its agentic IAM on screen, including how to switch off one agent without affecting the others.
If you run the systems
- Give every agent its own service identity, and retire shared keys and borrowed user accounts.
- Issue short-lived, audience-bound tokens scoped to the task, with just-in-time elevation for privileged actions.
- Use delegation, never impersonation, so logs record the agent and the person it acts for.
- Require resource indicators and audience checks on MCP servers, and refuse token passthrough.
- Review agent permissions on a schedule and after every change to the agent's job.
Key takeaways
- Agentic IAM is ordinary identity discipline applied to a user that can be talked into things.
- Every agent needs its own identity, its own way to authenticate, and credentials that expire.
- Delegated authority should name both the agent and the person, so accountability never blurs.
- Least privilege plus a person's approval on high-impact actions keeps a fooled agent's mistake small.
Where this lines up with the standards
The frameworks and rules this page maps to, with the exact item and what it asks of you.
| Framework | Item | What it asks |
|---|---|---|
| OWASP Top 10 for Agentic Applications | ASI03 Identity and Privilege Abuse (opens in a new tab) | Prevent identity and privilege abuse by giving each agent narrow, separate identity and privileges. |
| OWASP Non-Human Identities Top 10 | NHI4 Insecure Authentication; NHI5 Overprivileged NHI; NHI7 Long-Lived Secrets; NHI10 Human Use of NHI (opens in a new tab) | Use strong authentication, cut overprivilege, replace long-lived secrets, and keep people off machine identities. |
| NIST CSF 2.0 | PR.AA-01, PR.AA-03, PR.AA-05 (opens in a new tab) | Manage and authenticate identities for services, and enforce least privilege and separation of duties. |
| MCP authorization spec | OAuth 2.1, RFC 8707, token handling (opens in a new tab) | Bind each token to one server, request least-privilege scopes, and refuse token passthrough. |
| Joint agency guidance | Careful adoption of agentic AI services (opens in a new tab) | Make each agent a distinct principal, use ephemeral credentials, and limit permissions to the task. |
| Massachusetts | 201 CMR 17.00 (opens in a new tab) | Control user IDs, assign unique identifications, and restrict access to personal information to those who need it. |







