AI Agent Identity Governance: Who Each Agent Runs As and How to Revoke It
AI agent identity governance resolves which principal each agent runs as, who owns it, and how to revoke it. The six identity patterns, ownership and fixes.
AI agent identity governance resolves, for every AI agent, which principal it runs as, who is accountable for it, and how confidently its actions can be attributed to it, then applies ownership, sanctioning, least privilege, rotation and revocation to that identity. Agents use six identity patterns, and two of them (browser sessions and shared logins) are invisible to API-only identity tools. Strac resolves all six, keeps 'is an agent' separate from 'is a non-human identity', infers an owner from the last human touch, flags ownerless live agents as High, and offers identity-first remediation such as revoking an OAuth grant by client_id or migrating a shared login to a dedicated identity.
Ask three people in your company who the "Finance Research Agent" is and you will get three answers. The platform team says it is a Claude OAuth client. Google Workspace says it is Alice, because every Drive call arrives on her behalf. The finance lead who set it up left in March. Nobody can say which of those is the identity you would revoke if it started exporting payroll files at 2 a.m.
That gap is the whole problem of AI agent identity. An agent does not have one identity the way an employee does. It borrows one: a human's OAuth grant, a bot token, an IAM role, or a browser tab a person already logged into. Governing agent identity means resolving three things for every agent: which principal it runs as, who owns it, and how confidently you can attribute an action to it. Only then can you apply the controls everyone agrees on: an accountable owner, a sanctioning decision, least privilege, credential rotation and a revocation path that works.
This page is the identity spoke of our AI agent security guide: the six identity patterns agents use, why "is an agent" and "is a non-human identity" must be stored separately, where non-human identity tools go blind, how Strac resolves ownership when nobody wrote it down, and what identity-first remediation looks like per pattern.

Identity tells you who an agent is allowed to be. AI security posture management tells you what it can actually reach on the device, which is usually the wider of the two.
Traditional IAM assumes one person, one account, one set of entitlements. Non-human identity management extended that to service accounts and API keys. Agents break both models: an agent interprets an instruction, chooses actions, and authenticates through whatever credential is in reach. So the first job of AI agent identity management is resolution rather than provisioning. For every agent, bot or AI-enabled automation, the governance layer must answer:
Once those are resolved, the familiar controls apply: owner, sanctioning, least privilege, rotation, revocation. One rule we build to: never infer "did" from "can." Identity governance tells you which principal an agent can act as and what that principal may do. What the agent actually did comes from audit logs and Strac's own sensors, joined to the identity through evidence; the monitor AI agents page covers that side of the graph.
Every agent Strac discovers across Google Workspace, AWS Bedrock AgentCore, GitHub and Copilot, Slack, Salesforce and Agentforce, Claude, ChatGPT and Cursor fits one of six identity patterns. The pattern determines what matters most in agent IAM: how well you can attribute an action to the agent, and what you do to revoke it.
client_id (Google Admin SDK tokens.delete); one click in Stracclient_id and user are knownThe revocation column is not uniform. For pattern A the fix is a bounded admin API call Strac can make for you. For pattern C it is a policy diff you apply in the AWS console. For patterns E and F there is no agent credential to pull, because the agent never had one; the only durable fix is to give it an identity of its own. Any tool that promises one-click revocation across all six patterns is describing pattern A.
Patterns are per credential, not per agent. One Claude Code session can hold a delegated Google OAuth grant (A), a GitHub App grant (B) and an MCP server configured with a PAT (D) at once. Strac models the agent once and attaches each credential separately, so Alice's Claude Code session appears as one agent with three identities, each with its own revocation path and its own attribution label: provider-native, endpoint-correlated, correlated or low.
Here is the trap that swallows most non-human identity management programs when they extend to agents: they count every service account, CI bot, backup job and OAuth app as an "AI agent," and the real risk disappears into a list of 4,000 rows.
Strac stores two independent flags on every principal:
actor_is_agent=true, an AgentCore runtime, an MCP tool call seen by the Strac sensor, a Cowork process controlling a browser.Most NHIs are not agents. Every agent uses at least one NHI or borrows a human identity. Keeping the flags separate is what lets you answer "which of my 4,112 non-human identities need agent-grade controls?"


Two rules follow from the split. Do not label an app "AI" from a display-name keyword. "Copilot" in a Slack app's name is a hint; Strac uses verified client identifiers, native agent metadata or runtime signals, and records the confidence of the classification itself. And an agent is not a run. One Claude OAuth client can serve many users and sessions, so Strac instantiates a specific agent or session only when vendor, runtime or sensor evidence supports it.
If your NHI tool already has the 4,112, Strac is the layer that picks out the 214 and joins them to the data they can reach. If you do not have an NHI inventory, Strac's discovery produces both flags from the same provider APIs; the discover AI agents page walks through that provider by provider.
Identity-security and SaaS-security products work by reading the provider's admin and audit APIs. That is the right starting point and Strac does it too. The limitation is structural: those APIs can only describe principals the provider knows about, and the two fastest-growing patterns involve principals it does not.
Pattern E, browser session. Alice is logged into Salesforce in Chrome. A Cowork or computer-use agent takes control of that tab and clicks Export on a report. Salesforce Event Monitoring records, correctly, that Alice exported 2,310 rows. No OAuth grant was created, no connected app appears, no service account exists. An NHI platform, an SSPM tool and the Salesforce admin console all report the same thing: a human did it.
Pattern F, shared login. An automation signs into the CRM with team credentials four people also use. The audit log sees the shared account. It cannot separate the agent from the people, and it has no concept that an agent is involved.
The only way to attribute either action is evidence from where the agent actually ran. Strac's browser and endpoint sensors, already deployed for data loss prevention, see the agent process, the tab it controlled, the tool call (browser.click("Export")), the CSV that landed on disk, the agent reading that file and the request to the model provider. Joined with the provider's audit record under Alice's identity, that becomes a High finding with attribution marked correlated and its confidence factors visible: a 43-second overlap, the same tab, and file lineage from download to upload.

The same sensors see what no admin API exposes. Local Claude Code, Codex and Cursor processes, MCP configuration files, and the API keys and PATs sitting in the execution environment, which is where pattern D credentials get an owner, because the endpoint knows whose machine the key is on. Every MCP invocation, normalized to server, tool, requesting session, downstream principal, action and resource, which is the link between a Claude session and the GitHub or Drive principal it acted through; see MCP DLP and shadow MCP. And the 17 agents in a typical first inventory found only by endpoint or browser evidence, which have no identity record anywhere else and are shadow AI with an action surface.
These sensors are optional evidence adapters into the same graph. The inventory works from provider APIs alone for patterns A through D. Deploy the sensors wherever computer-use agents and shared-login automations run.
Every control on this page depends on one field: owner. You cannot ask for a sanctioning decision, approve an exception, or confirm a credential can be rotated without a human to ask. And almost nobody records the owner of an agent when they create it.
Strac resolves ownership from the last human touch in the evidence, in a fixed order of preference, and records which rule produced the answer:

app_installed, the GitHub App installer, the Salesforce user who created the integration userThe inferred owner is a candidate until confirmed. The agent's row shows the owner with the rule that produced it, and the owner can accept, reassign or decline. A declined or unresolvable owner triggers an owner request to the team that owns the provider. A typical first policy preview shows around 41 owner requests, which is also the number of unmanaged agents in the same inventory. An agent with no owner is almost always an agent nobody is managing.
Why "no owner" is a High finding. An agent or credential with no accountable owner, combined with recent activity or a valid credential, is High every time, regardless of reach. Every other finding on that agent is unworkable until someone can answer for it: you cannot revoke it safely because you do not know what breaks, cannot sanction it because nobody will vouch for it, and cannot scope it because nobody knows what it needs. Resolve the owner first and the rest of the queue becomes conversations instead of guesses.
Owners leave. When Alice leaves, her delegated OAuth grants die with her account and every pattern A agent that depended on them stops. The PAT she created, the shared login she set up and the Slack app she installed all keep working with no owner. Offboarding a person should trigger an ownership review of every agent that resolved to them, and in Strac it does, because the owner edge is a query rather than a spreadsheet. One guardrail on that edge: Strac never joins identities across tenants, AWS accounts or Slack workspaces by email alone; it uses provider-native stable IDs, so an email is an alias hint rather than proof.
Resolving which principal an agent runs as is the first hop in the graph. It matters because of the next two: what that principal may do, and what sensitive data sits behind the permission.

Two identity-specific points from that screenshot.
An OAuth scope is a capability, not a reach. drive.readonly says the Claude client may call the Drive API on Alice's behalf. Which files are reachable depends on Alice's own access: her direct permissions, her Finance group membership, folder inheritance. Strac joins the scope to the user's effective access and to its existing Drive classifications, which is how 8,214 reachable files becomes 193 sensitive ones. An identity tool that stops at the scope will tell you the agent "can read Drive." True, and useless.
Granted versus used is measured per identity, over a window. The grant exercised drive.readonly in the last 30 days and never touched gmail.readonly, which reaches 61 files with PII. That makes gmail.readonly a review candidate with a stated window and telemetry coverage rather than a proven dead scope, because seasonal tasks and unlogged actions exist. The protect AI agents page covers how those reductions become policy.
Most agent findings resolve at the identity layer, because the identity is the thing you can actually change. Strac keeps discovery credentials (read) separate from remediation credentials (write), so every action below is opt-in per provider and per action, and the inventory works read-only from day one. Four identity remediations cover most of the queue:

client_id. For pattern A on Google Workspace, Strac calls the Admin SDK to delete the user's tokens for that client. It is one click, and the user can re-consent if the agent turns out to be needed. One caution: Google revocation removes the user's grant for that client entirely, never one selected scope, so Strac labels it "revoke the Claude grant for Alice" rather than "remove one unused permission."For pattern C, AWS, the posture is deliberately manual. Strac generates the exact policy statement to remove, the resource to narrow, or the runtime to disable, and deep-links to the console. Autonomous IAM mutation is a decision we are not making for you.
Every remediation plan re-reads the exact target before executing, rejects a stale plan if the grant changed, shows the blast radius when a shared grant affects multiple workflows, and verifies the result with a provider resync; a revocation still propagating stays pending rather than closed. Less exciting than a kill switch, and defensible when the owner asks what you just did.
The same identity rules then run continuously as policy: owner required for every agent, regulated-data agents must be sanctioned, no secrets-plus-execute on one principal, unused write or admin capability flagged after 30 days, stale credentials revoked at 45 days, no shared human identities. Each rule previews its effect against the inventory before it is enabled, and each exception carries an expiry.
Identity is one of the four questions an agent security platform must answer, and it unlocks the other three. Without a resolved principal there is no permission to map, no activity to attribute and no data reach to compute. With it, the rest of the AI agent governance program falls into sequence: discover the agent, resolve and own its identity, scope it, watch it, and redact what it should not see at the boundary. Claude Code, Cowork and Claude Enterprise sessions arrive as first-party signals through the Compliance API; the Claude DLP page covers what Strac does with the content once the session's identity is resolved.
If your identity team already runs an NHI or SSPM tool, keep it. Strac reads the same provider APIs, adds the agent flag, the owner inference, the sensor evidence for patterns E and F and the join to sensitive data, and hands back findings those tools cannot produce.
👉 Book a demo and we will connect read-only to your Google Workspace or Slack tenant on the call and show you every AI agent identity in it, who owns each one, and which ones have no owner at all.
AI agent identity is the principal and credential an AI agent uses to act in a target system, plus the human accountable for it. Agents rarely have an identity of their own; they run as a delegated OAuth grant, a bot or service account, a cloud workload role, a static API key, a human's browser session or a shared login. Governing agent identity means resolving which of those applies, who owns it and how confidently an action can be attributed to the agent.
They overlap, and conflating them is the most common mistake. NHI management inventories every service account, API key, bot and app, most of which are not agents. Agent identity management covers the subset an AI agent uses, plus the human identities agents borrow through browser sessions and shared logins, which NHI tools do not see. In a typical tenant about 5 percent of NHIs are used by agents.
The same way you authenticate anything, which is the problem: whatever credential the agent can reach will work. The governance question is whether the agent has a dedicated identity with scoped permissions (patterns A through D) or is riding a human identity (patterns E and F). The target state is a dedicated principal per agent, scoped to what it uses, with an owner on record and a rotation window, so the audit trail names the agent rather than whoever happened to be logged in.
Agentic identity is identity designed for software that chooses its own actions. It departs from standard IAM in three ways: the principal and the agent are modeled separately, because one agent can hold several credentials; attribution carries an explicit confidence, because the provider often cannot tell an agent from its human; and least privilege is measured against observed use over a window, because an agent's blast radius is the union of every permission behind every credential it holds.
Only for some patterns. Google lets Strac revoke a user's tokens for a specific client in one bounded API call, and Slack lets it restrict or uninstall an app where admin APIs allow. AWS roles need a policy change you apply in the console, and static keys need rotation at the provider. Browser-session and shared-login agents have no credential of their own to revoke; the fix is to migrate them to a dedicated identity.
No. Your IdP remains the authority on human identities and group membership, and an NHI platform remains a fine inventory of service accounts. Strac reads the same provider APIs, adds the agent classification, infers ownership, attributes the browser-session and shared-login patterns with its own sensors, and joins every identity to the sensitive data it can reach. The output is findings with proof and identity-first remediation, which neither tool was built to produce.
.avif)
.avif)
.avif)
.avif)
.avif)

.gif)

