Most enterprises have already given AI agents access to their systems. Very few can say what those agents are doing with it.
Agents do not behave like human users. They plan their own steps, call the tools they choose, and use whatever access helps them finish a task. Identity controls built for people check who is logging in. They were never designed to check what happens after.
The data now shows where that gap leads. A 2026 1Password survey of 1,000 US employees found that at 41% of organizations, agents are touching data they were never approved to use, with actual access running at roughly twice the authorized rate. Jason Meller, VP and Security Strategist at 1Password, put it plainly: an agent that finds a useful credential will use it, "whether you told them to or not."
The agents in that survey were authenticated. Their identities checked out. The access was technically valid. That is the gap this post covers: why AI agent identity breaks the assumptions behind IAM, and what governs an agent after it is let in. For the broader picture, start with our overview of AI security risks for enterprises.
What Is AI Agent Identity?
AI agent identity is the distinct, verifiable identity assigned to an autonomous AI agent, separate from the human who launched it and the service accounts it calls. It determines what the agent can access, records what it did, and anchors accountability for every action it takes.
An agent is neither a user nor a service account. A user logs in, works, and logs out. A service account runs the same job on a schedule. An agent plans its own steps, chooses which tools to call, and carries context from one task into the next.
That gives agent identity three jobs:
- Authenticate: prove which agent is making the request.
- Authorize: decide what that agent may reach for the task in front of it.
- Attribute: record which agent acted, and on whose behalf.
Most identity programs handle the first two reasonably well for people. For agents, all three break in ways existing tooling was not designed to catch.
Why Do Human IAM and Service Accounts Break for AI Agents?
Identity and access management rests on two assumptions: identities behave predictably, and the software using a credential does what it was written to do. AI agents break both.
- Nondeterministic behavior: the same task can produce different actions on different runs, so a static role cannot anticipate the path an agent will take.
- Hybrid credentials: an agent can sign into one system through a human login flow and reach the next through a backend integration. A single task can draw on two kinds of credential.
- Opportunistic use: a key hardcoded in a script used to be a latent risk. On a machine running an agent, it is available to anything the agent decides it needs.
The result is a model where authentication succeeds and governance quietly fails.
How Big Is the AI Agent Identity Gap in 2026?
The 1Password AI Agent Governance survey puts numbers on how far agent adoption has run ahead of the controls meant to govern it:
- 65% vs 33%: 65% of developers are expected or encouraged to use AI agents. Only 33% say they have a secure way to do so.
- 41%: share of organizations where agents touch data they were never approved to use. Actual access runs roughly twice the authorized rate.
- 40%: share of developers granting agents persistent access to systems or credentials.
- 27%: share reporting a security incident or breach caused by an overprivileged non-human identity.
- 71%: share with gaps in visibility into which agents are using which credentials.
- 35% and 21%: 35% govern agents under existing IAM processes, and 21% have no formal approach at all.
The figure that matters most is the 41%. It does not describe attackers getting in. It describes access drifting inside identities that were valid all along, which is exactly the kind of failure an authentication check will never flag.
Why Do Authorized AI Agents Still Take Unsafe Actions?
Access granted is not action approved.
Identity answers one question: can this agent get in? It does not answer the question that matters once the agent is inside: should this action, on this data, happen right now?
The PocketOS incident shows the difference:
- A Cursor agent working on a staging task hit a credential mismatch.
- It scanned the codebase and found a Railway API token in an unrelated file. The token had been provisioned for custom domain management but carried blanket permissions across the infrastructure.
- One API call later, the production database and its volume-level backups were gone. It took nine seconds.
Every identity check passed. The token was real, and so was the access. Nothing evaluated the action itself.

Step Finance followed the same pattern at higher stakes. An overprivileged trading agent held wallet, oracle, and endpoint rights at the same time, and one device compromise cascaded into a $40 million loss. That incident is covered in our threat briefing on AI coding agent attack vectors.
The structural problem is timing. Authorization is evaluated once, at login or at provisioning. Actions happen continuously, often hundreds per session. Standards bodies have caught up to this: OWASP moved Excessive Agency to third in its 2026 LLM Top 10 and lists Identity and Privilege Abuse as ASI03 in its Agentic Top 10, both mapped in our OWASP LLM and Agentic Top 10 guide.
How Do You Attribute AI Agent Actions in Audit Trails?
After an incident, the first question is who did this. With agents, the audit log often gives the wrong answer.
An agent frequently authenticates with a person's credential. The log then records that person's name, even though they may have had no idea what the agent was doing. The 1Password survey found accountability is just as unclear in practice: 65% of respondents said someone other than the current owner should carry responsibility. Agents have no legal agency, so accountability has to be shared between the user and the security team that sets the guardrails. That only works if the evidence exists.
Every agent action needs a delegation chain that records three facts:
- Which agent acted: a distinct identity, not a borrowed one.
- On whose authority: the human or system that delegated the task.
- With which credential, against which data: the exact access used for that action.
Without that chain, incident review turns into reconstruction.
DAXA builds attribution into the enforcement path itself:
- Per-agent identity: each agent gets its own identity in place of a shared service account, so its actions are never logged under a person's name.
- Identity-aware data access: every data request is checked against the customer's IdP at query time, tying each access to the agent and the user it acts for.
- Logged inter-agent calls: MCP calls between agents are logged and inspected in-path, keeping the chain of authority intact across multi-agent workflows.
- Blast-radius visibility: security teams can see what each agent can reach before an incident, rather than reconstructing it afterwards.
How Do You Implement Least Privilege for AI Agents?
Least privilege for AI agents means scoping access to the task in front of the agent, not to its general purpose or to every task it might run in future. Five controls get you there:
- Give every agent its own identity: no shared service accounts and no borrowed human credentials. Shared identities make attribution impossible and widen the blast radius of every compromise.
- Issue just-in-time, task-scoped credentials: grant access when a task starts and revoke it when the task ends. Keep credentials out of the agent's context entirely, since an agent cannot misuse a secret it never sees. At PocketOS, the token that caused the damage was sitting in the codebase.
- Authorize data at query time and tool-call time: check permissions at the moment data is retrieved or a tool is invoked, against both the agent and the user it acts for. This is the control that closes the gap between approved and actual access.
- Put policy checkpoints at the action boundary: separate reads from writes and deletes, and require out-of-band human approval for anything irreversible. Rules written in a prompt are a request. PocketOS had those rules, and the agent broke them.
- Monitor behavior and contain at agent speed: watch agent behavior from outside the model, send deviations to the SIEM, and contain through SOAR in seconds, not after a ticket is triaged.
These controls apply to any agent, but they become the central design problem for homegrown AI agents running against production data and tools.
Where Do Identity Providers Stop and a Governance Layer Start?
The identity provider stays the source of truth. It knows who the agent is, who it acts for, and which groups and entitlements apply. What it was not built to do is evaluate every tool call, every retrieval, and every command an agent issues at runtime.
That job belongs to a governance layer in the path between the agent and the data and tools it reaches. The governance layer reads identity from the IdP and enforces policy on each action. It complements the IdP rather than replacing it, which is the same reason protocol-only solutions fall short. The IdP decides who the agent is. The governance layer decides what it may do next.
Conclusion
AI agent identity is necessary, but on its own it is not enough. Authentication confirms an agent is who it claims to be. It says nothing about whether the agent's next action, on the next piece of data, falls within what the enterprise intended.
The test for any security team is simple. Can you name every agent in your environment, what each one can reach right now, and who authorized its last action? If the answer depends on reading logs that record a person's name, the gap is already open.
See how DAXA governs homegrown AI agents and AI coding assistants at the action boundary.

