Calendar Icon White
November 15, 2026
Clock Icon
20
 min read

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: Who Each Agent Runs As and How to Revoke It
ChatGPT
Perplexity
Grok
Google AI
Claude
Summarize and analyze this article with:

TL;DR

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.

Strac AI agent identity patterns view showing the six patterns A through F with agent counts and attribution confidence for each
The six patterns for one tenant: 61 agents on delegated OAuth, 48 on app or bot identities, 23 on cloud workload identities, 31 on static keys, and the rest on browser sessions and shared logins that the provider cannot attribute on its own. The finding that matters: 12 agents on patterns E and F use shared human identities.

🧭 What AI agent identity governance has to resolve

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:

  1. Which principal does it run as? The identity the target system recognizes for authorization and audit: alice@acme.com, a Slack bot user, a Salesforce integration user, an AWS IAM role.
  2. Which credential does it use? An OAuth grant, a GitHub App installation, a PAT, a role session, a browser session cookie, a shared password.
  3. Who owns it? The human who answers for the agent when it misbehaves or when its credential needs to go.
  4. How confident is the attribution? When the audit log says "Alice exported a report," was it Alice, or an agent acting through Alice's identity?

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.

The six AI agent identity patterns, and how you revoke each one

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.

Pattern
What it is
Example
How you revoke it
Attribution confidence
A. Delegated OAuth
Agent acts on behalf of a human through an OAuth grant
Claude → OAuth grant → Alice → Google Drive
Revoke the user's tokens for that client_id (Google Admin SDK tokens.delete); one click in Strac
High when client_id and user are known
B. App, bot or service identity
Agent has its own non-human principal
Slack bot token, Salesforce integration user, GitHub App installation
Restrict or uninstall the Slack app; narrow or uninstall the GitHub App; deactivate the integration user via provider workflow
Usually high; owner often needs installation metadata
C. Cloud workload identity
Cloud-hosted agent runs as a workload principal
AgentCore runtime → IAM role or workload identity
Remove the policy statement, narrow the resource, or disable the runtime; Strac supplies the policy delta and console link
Very high with a dedicated role and CloudTrail session evidence; shared roles stay principal-attributed
D. API key, PAT or static secret
Agent authenticates with a long-lived credential
GitHub PAT, vendor API key, Slack token
Rotate or delete the token at the provider; endpoint secrets scan shows where copies live
Medium; ownership is weak until endpoint telemetry links the key to a person
E. Browser or session identity
Agent drives a browser session a human already logged into
Cowork or computer-use agent → Alice's open Salesforce tab
No credential of its own to revoke. Stop the agent process, block at the browser, or migrate to a dedicated identity
Correlated (low to medium); the provider sees only Alice
F. Shared or human login
Agent logs in with a human or shared account
Automation signs into the CRM with team credentials
Rotate the shared password and migrate to a dedicated identity; the login cannot be revoked without locking out the humans
Low unless another sensor correlates it

The 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.

✨ AI agents vs non-human identities: why NHI governance is not enough

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:

  • is_non_human_identity: the principal is not a person. Service account, bot user, app installation, IAM role, workload identity, shared account.
  • is_agent: evidence indicates AI or agent behavior. A Claude or OpenAI compliance-API session, a GitHub audit event with 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?"

Strac diagram comparing AI agents and non-human identities: 3,898 NHIs that are not agents, 214 agents on an NHI, and agents borrowing a human
The two flags split one tenant into three groups. NHI tools see the first two; the agents that borrow a human's session or shared login have no non-human identity for those tools to find.
Strac Identities view listing principals used by AI agents, with 4,112 non-human identities, 214 used by agents and 41 without an owner
Of 4,112 non-human identities in this tenant, 214 (5 percent) are used by AI agents. Each row carries its identity pattern, resolved owner and sensitive-data reach, so the 41 ownerless and 9 stale principals can be worked as a list.

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.

✨ Where non-human identity tools go blind: patterns E and F

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.

Strac correlated event showing Salesforce logging Alice's 2,310-row export while device evidence shows the Cowork agent controlled her browser tab
Salesforce's record and the device record of the same export, joined into one High finding. The three confidence factors are shown on the finding so a reviewer can say which one fails.

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.

✨ Ownership resolution: how Strac decides whose agent it is

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:

Strac ownership resolution flow mapping each kind of identity evidence to an inferred owner and confidence, ending in an owner request
Strong evidence such as a grant or install event names an owner with high confidence. Weak evidence never produces a guess from an email or team name; it produces an owner request instead.
Evidence
Owner inference
Confidence
Delegated OAuth grant (A)
The user who authorized the grant, from the Google token audit authorize event
High
App or bot installation (B)
The actor on the install event: Slack app_installed, the GitHub App installer, the Salesforce user who created the integration user
High if the audit log retains the install event; medium if only the current admin is known
Cloud workload identity (C)
The CloudTrail identity that created the runtime or role, plus owner tags
Medium to high, depending on tag hygiene
Static key or PAT (D)
The provider's token owner where exposed; otherwise the endpoint user whose machine holds the credential
Medium; low if the key is only seen in a shared secret store
Browser session (E)
The human whose session the agent controlled, plus the endpoint user running the agent process
Medium; usually the same person
Shared login (F)
The last human who used the credential interactively on an endpoint Strac can see; otherwise none
Low
Vendor session (Claude, ChatGPT, Cursor, Copilot)
The initiating user from the compliance or audit API
High

The 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.

✨ From identity to effective reach

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.

Strac agent detail graph tracing a Claude Code session through Alice's delegated OAuth grant and Drive permissions to 193 sensitive files
One agent, resolved end to end. The identity hop (Claude session → delegated OAuth grant → Alice) is where this page lives. The permission hop (drive.readonly, gmail.readonly) and the data hop (193 sensitive files: 42 financial, 8 with SSNs, 4 with secrets) are why identity resolution is worth doing at all.

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.

✨ How to revoke an AI agent's identity and enforce least privilege

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:

Strac revocation paths for the six AI agent identity patterns, from a one-click OAuth grant revoke to migrating shared logins
Only delegated OAuth revokes in one click. Cloud roles need a console policy change, keys need rotation, and browser-session and shared-login agents need a dedicated identity first.
  1. Revoke an OAuth grant by 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."
  2. Restrict or uninstall a Slack app. For pattern B, where Enterprise Admin APIs and the granted scopes allow it, Strac can restrict future installation or uninstall the app across the workspace. Otherwise it shows the requested scopes and resources with the admin link.
  3. Rotate a PAT or API key. For pattern D, Strac does not rotate the secret itself. It identifies the token, the principal it authenticates as, where copies exist on endpoints, and which agents depend on it, then hands you the provider link. Rotation without the dependency list breaks three automations to fix one.
  4. Migrate a shared login to a dedicated identity. For patterns E and F, the finding is "shared human credential used by an agent," and the remediation is a migration: create a service identity or bot user with the scopes the agent actually exercised, re-point the automation, then rotate the shared password. Strac's granted-versus-used data for the human session is the scope list for the new identity.

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.

Where identity governance fits in the program

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.

🌶️ Spicy FAQs on AI agent identity

What is AI agent identity?

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.

Is AI agent identity management the same as non-human identity management?

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.

How do you authenticate an AI agent?

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.

What does "agentic identity" mean in practice?

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.

Can you revoke an AI agent's access in one click?

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.

Does Strac replace my IdP or NHI platform for AI agent 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.

Customer story

“Don’t just alert on problems, fix them.”

Scott Roberts, Chief Information Security Officer, UiPath

  • UiPath
  • Crypto.com
  • Inmar Intelligence
  • thredUP
  • Paymentology
  • Enveda
  • Genesis Molecular AI
  • MeridianLink
More customer stories →
What is AI agent identity?
Is AI agent identity management the same as non-human identity management?
How do you authenticate an AI agent?
What does "agentic identity" mean in practice?
Can you revoke an AI agent's access in one click?
Discover & Protect Data on SaaS, AI, MCP, Endpoints & Cloud
Strac provides end-to-end data loss prevention for all SaaS and Cloud apps. Integrate in under 10 minutes and experience the benefits of live DLP scanning, live redaction, and a fortified SaaS environment.

Customers include

  • UiPath
  • Crypto.com
  • Inmar Intelligence
  • thredUP
  • Paymentology
  • Enveda
  • Genesis Molecular AI
  • MeridianLink
Trusted by enterprises
Data Security + Compliance Automation

Latest articles

Browse all

Get Your Datasheet

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Close Icon