
Most identity teams have spent years bringing service accounts, API keys, and tokens under control, and now they're extending that work to AI agents. A non-human identity is the credential software uses to authenticate and act: a service account, API key, OAuth grant, workload identity, or personal access token.
The model fit its era. Workloads were deterministic, so scoping access at provisioning time was the right call for the systems of the day. A backup job does the same thing each night, and its permissions can be written down once and reviewed on a schedule.
Even then, the hygiene was hard. The OWASP Non-Human Identities Top 10 lists improper offboarding, overprivileged NHIs, long-lived secrets, NHI reuse, and human use of NHIs among its top risks. The list focuses on service accounts and keys and doesn't specifically address AI agents.
Agents surface a requirement those programs weren't designed to meet. They interpret a goal, choose tools, and chain steps, and two similar requests can send them down different paths. The access they'll need isn't fully knowable at provisioning, because a backup job has a runbook while an agent has an objective.
Scale raises the stakes. Gartner predicts an average global Fortune 500 enterprise will have over 150,000 agents in use by 2028, up from fewer than 15 in 2025. At that volume, reviewing each agent's permissions by hand stops being a realistic control.
NHI programs did their job for software with a fixed task, and that work still matters. When a reporting agent pulls finance data at midnight, the log shows a valid token, and nobody can yet say whose request it served. Agent identity now has to answer a question service accounts rarely raised: which actor used this credential, and for whom?
Most teams' first agents didn't arrive through an identity workflow or a provisioning ticket. They showed up in browser tabs, sidebars, terminals, and desktop apps, already working with the access of the person at the keyboard.
In our view, the agents with the most reach are often the ones with no credential of their own. They borrow one, and the patterns tend to look like this:
A sales leader asks a browser assistant to tidy up the pipeline before a forecast call, and it edits dozens of opportunities in the CRM. Afterward, the record history shows each change under the sales leader's name, with nothing to mark which edits the assistant made.
In each case, the identity provider (IdP) and the application log record a legitimate user or service account. The record is accurate about who authenticated and silent about who acted.
The audit log isn't wrong. It's answering a question nobody asked.
Borrowed credentials also travel well beyond the session where they were granted, and reporting from BleepingComputer describes a clear example. Between August 8 and August 18, 2025, attackers used OAuth and refresh tokens stolen from the Salesloft Drift chat-agent integration to steal Salesforce data.
That incident involved an integration rather than a human session, but the lesson carries over. Our reading is the tokens were valid, so to the receiving systems the activity likely looked like the integration doing its job. The credential itself carried no signal about who was actually behind it.
This is why we treat identity for AI agents as an attribution problem first. "Who logged in" was the right question for people at keyboards; for agents, the useful question is who acted, for whom, and doing what.
When an incident review asks "who did this," you need several answers at once, and a credential supplies only one of them. Building the fuller answer starts with what mainstream guidance already gets right.
Distinct agent identities matter, and Gartner's steps for managing agent sprawl include defining an agent identity, permissions, and lifecycle model. NIST's National Cybersecurity Center of Excellence is also weighing in with a February 2026 concept paper for a potential project, not formal guidance. Among its open questions is a telling one: "How do we bind agent identity with human identity to support 'human-in-the-loop' authorizations?"
A distinct credential tells you which identity authenticated. It can't tell you whether the agent was working inside a person's session, which tool call it made, or what data it touched. To be accountable, each agent action should carry four things:
Together, those four fields turn a log line into an answer an auditor can use. If any one is missing, the review falls back on guesswork about intent and ownership.
This also changes what you measure. Instead of counting agents in an inventory, track the share of agent-initiated actions you can tie to both a specific agent and a specific human. For agents working inside human sessions, we'd expect that share to be low in many environments, and tighter credential hygiene alone won't raise it.
Least privilege shifts too, because it gets set per action rather than per identity. A person can hold full rights to a mailbox while the agent working in that same session gets read-only. In this model, identity for AI agents is a record created at the moment of action, with the credential as one input among several.
The uncomfortable moment in many agent reviews comes when someone opens a local MCP configuration file and finds a long-lived token sitting in plain text. Whatever identity the agent claims, the credential it carries can outlive the task, the session, and sometimes the employee.
MCP made tool access easy, and credential handling hasn't kept pace. In one academic study of 1,899 open-source MCP servers, 7.2% contained general vulnerabilities and 5.5% exhibited MCP-specific tool poisoning. A separate measurement of internet-exposed remote MCP servers found 40.55% expose tool interfaces without authentication.
The broker pattern takes the credential out of the agent's hands. The agent authenticates to a gateway, and the gateway holds the credential and authenticates onward. Access is scoped to one task and expires when the session ends.
Revocation then becomes "block the agent at the gateway" instead of rotating a shared key and breaking everything else that depends on it. Policy can also get more precise, since the gateway sees each tool call as it happens.
Island Enterprise AI applies this pattern through the Island MCP Gateway, so the raw key never reaches the agent. Agents get just-in-time access scoped to the task, and you can cut one off at the gateway without rotating anything.
Limits apply per tool, per action, and per actor, such as read-only for the agent while the person keeps full rights. Each tool call ties back to the identity used and, wherever possible, to the responsible human.
Inside the browser, the Island Enterprise Browser binds each agent action to the user's enterprise identity and labels user versus agent on audit entries. Either way, the identity question gets answered at the moment the agent acts.
Most NHI inventories are built by pulling from identity providers, cloud consoles, and vaults. That's the right place to find credentials and a poor place to find agents, which can't carry an accountable identity until someone knows they exist.
An inventory sourced from the IdP counts keys rather than actors. One key can serve three agents, one agent can use five keys, and a session-borne agent may have no key at all. The count in the inventory and the number of agents at work can drift far apart without anyone noticing.
Discovery has to start where agents run, on the endpoint and in the session, and cover:
Each of those items can give an agent reach no directory knows about. A local configuration file holding a token is, for practical purposes, an identity grant nobody approved.
A quarterly census rarely keeps up with this. Users install, configure, and reconfigure agents on their own schedule, so an MCP server added on Tuesday is invisible to a review run on Monday. A continuous feed works better, linking each agent to the person whose session or credentials it uses so later actions trace to both.
Ownership is the other half of the work. OWASP ranks improper offboarding first in its NHI Top 10. Agents without a named human owner are on track to become the next generation of orphaned identities.
Unregistered agents are shadow AI with permissions. Each one needs an accountable owner before its identity means anything in an incident review.
The temptation is to begin with the agent platform IT already approved, which is also the agent you can already see. The bigger payoff sits with the agent nobody provisioned and nobody gave an identity of its own.
Picture an assistant inside a sales leader's browser session, or a coding agent running on an engineer's cloud credentials. Attribution is weakest there and reach is widest, so it's where the first fix pays off most. A first project can stay small and still prove the model:
Expect the first pass to surface gaps rather than confirm a clean record. You'll likely find agent actions logged only under the person's name, or a token no one can tie to a specific task. Treat that as a finding to bring to the business, because it shows in one familiar workflow exactly where attribution stops today.
Success looks like answering "who acted, for whom, doing what" for that one workflow with evidence instead of inference. Once you can, extending AI agent governance to the next agent becomes a repeatable project rather than a research effort.
Agents will keep arriving through sessions, grants, and shared keys, so identity has to be established where they act. Who logged in got the industry this far; who acted is what holds up in the next audit.
If you want to pressure-test this model against your environment, we're happy to walk through what we've built. Request a demo.
A non-human identity is a credential software uses to authenticate, such as a service account, API key, OAuth grant, or workload identity. It matters because agents put those credentials to work on goals they interpret themselves, so the credential alone no longer explains what happened.
An agent is better understood as an actor that uses non-human identities, and sometimes a person's identity, rather than as a credential itself. Keeping the actor and the credential separate is what lets security teams trace an action back to both.
A service account runs predefined steps under fixed permissions, while an agent picks its tools based on a goal. That makes provisioning-time scoping a starting point, with runtime policy covering the route the agent actually takes.
Traditional IAM answers who authenticated, which suits people and predictable workloads well. An agent working inside someone's session inherits that person's login, so the record of what the agent did has to be captured when it acts.
An MCP gateway sits between agents and the tools they call, holding credentials and issuing task-scoped, time-limited access. Because each tool call passes through it, the gateway becomes a natural place to record which agent acted, under which identity, and for whom.