How to Detect Shadow AI: Shadow AI Detection for Tools and Agents (2026)
Shadow AI detection, step by step: the network, browser and endpoint layers, the signals that expose shadow AI agents, and what to do once you find them.
Shadow AI is any AI tool or AI agent used without IT's knowledge or approval, and you cannot govern what you cannot see. Shadow AI detection works at three layers, network, browser and endpoint, and the endpoint is the most complete because it also catches desktop clients, IDE plugins, CLI scripts and local agents. Agents add a fourth layer: provider control planes (OAuth grants, app installs, AgentCore runtimes, compliance APIs) joined with endpoint and browser sensors. Strac runs all of it from one platform, names the service, the app, the device, the user and the sensitive data involved, and never reads prompts or logs keystrokes.
Shadow AI is any AI tool used without IT's knowledge or approval, and you can't govern what you can't see. Two years ago that meant an employee pasting a customer list into ChatGPT. Today it also means a Claude Code session with an OAuth grant to Google Drive, a Zapier automation signing into HubSpot with a shared login, and a computer-use agent driving an already-open Salesforce tab. The tools got agents, and the agents act on their own.
This guide is the method for shadow AI detection: where shadow AI hides, the warning signs, the three detection layers and what each can and cannot see, a fourth layer for detecting shadow AI agents specifically, a worked example of attributing an action to an agent the provider never saw, and what to do with each thing you find. If you want a comparison of products instead, see shadow AI detection tools. If you want the full program around agents, start with AI agent security.
The short version:

Detection without triage just produces a long list. Strac pairs discovery with AI security posture management so the riskiest setups, such as an agent holding a production database credential, surface first.
Shadow AI detection is the practice of finding the AI tools your workforce uses without approval, mapping them to devices and users, and spotting when sensitive data comes near them. It is the first step of any shadow-AI program: you cannot write a usable AI policy, size the risk, or enforce anything until you can see what is actually happening across the fleet.
The challenge is that AI adoption is bottom-up. Employees sign up for ChatGPT, install a Copilot plugin, or paste a customer list into a niche summarizer long before IT hears about it. Detection turns that invisible sprawl into a live inventory you can act on.

Traditional shadow-IT discovery looked for unsanctioned SaaS logins and expense-report subscriptions. Shadow AI is harder for three reasons. First, it is everywhere: there are thousands of AI tools and new ones weekly, so domain blocklists are always out of date. Second, it is not just browser-based: desktop assistants, IDE plugins, and scripts calling AI APIs never touch a web login. Third, the risky action is a paste or a file pick that takes one second, so point-in-time audits miss it.
Agents add a fourth reason. An agent does not need to reach an AI domain from the device you are watching. It can run in a vendor's cloud, authenticate with an OAuth grant a user approved months ago, and read Drive files through Google's own API. Nothing on the network looks unusual, and the audit log attributes every read to the human who approved the grant.
Even without a dedicated tool, a few signals hint at shadow AI: a rise in outbound traffic to known AI domains, new AI extensions appearing in browsers, employees pasting large blocks of text into unfamiliar sites, unmanaged AI desktop apps showing up in software inventories, and the one that matters most: sensitive files being opened by AI applications. The problem is that these signals are scattered across tools; detection's job is to unify them.
For agents, the warning signs live in admin consoles rather than on the wire: a new third-party OAuth client with Drive or Gmail scopes, a Slack app whose scopes expanded last week, a GitHub App installed on all repositories, an IAM role with a name that ends in "-agent" and no owner tag, and a Salesforce integration user that is suddenly the busiest account in the org.
There are three places you can watch for AI use, and they see very different things. Understanding the trade-offs is the key to choosing an approach that actually covers your risk. Agents add a fourth layer, covered after the three methods below.

Only partly. Network and CASB tools inspect outbound traffic and flag connections to known AI domains. This is broad and agentless, which makes it easy to start with. But it is blind to anything that does not leave through the inspected network path, desktop clients on a home network, CLI scripts, and encrypted context, and it struggles to tie a connection to a specific user, app, or file. It tells you that an AI domain was reached, rarely who did it or what data was involved. For a side-by-side of what CASB, EDR, OAuth scanning and DLP each catch, see the detection comparison in our shadow AI guide.
A browser extension sees AI use inside the browser, including what was typed or pasted into a web AI tool, and can tie it to the signed-in user. That is valuable, but it only covers the browser. Every desktop assistant, IDE plugin, and script is invisible to it. For organizations where developers and power users drive AI adoption, that is a large blind spot.

On laptops and desktops, the endpoint is the most complete vantage point. An endpoint agent watches AI use from the device itself, so it covers the browser and desktop clients, plugins, and scripts. It ties each connection to the device and user, names managed versus unmanaged tools, and, critically, can tell when a sensitive file or piece of text came near an AI tool. This is why the endpoint is the recommended vantage point: it is the only one that sees every path and connects AI activity to real data.

The three layers above detect AI tools: a person, a device, a destination. Shadow AI agents break that model, because an agent is software that chooses its own next action and borrows an identity to do it. The question changes from "which AI service did this device reach" to "what is acting, which identity does it run as, what can that identity do, and what did it do." That is the four-question frame from AI agent security, and detection is the first of the four.
Agents leave evidence in two places, and most agents show up in only one of them.
The first is the provider control plane: the admin API and audit log of the system the agent connects to. Google's Admin SDK lists every third-party OAuth token per user by client_id and scope, and its token audit shows which client called which API on whose behalf. Slack's admin APIs list apps, scopes and channel grants, and its audit log records installs and scope expansions. GitHub exposes App installations with repository selection, and its enterprise audit log tags Copilot agent actions with actor_is_agent=true and an agent_session_id. AWS AgentCore returns each runtime's roleArn and workload identity, which CloudTrail then attributes actions to. Salesforce Event Monitoring now carries ConnectedAppID, BotId, BotSessionId and ServiceName on API events, and MCP servers can appear as agentic-api-service. The Anthropic Compliance API covers Claude Enterprise, Cowork and local Claude Code sessions (but not Claude via Bedrock or Vertex). OpenAI's Compliance Logs cover ChatGPT conversations, auth and every connected-app call, with 30-day source retention. Cursor's admin API gives members and audit events, with no prompts or generated code.
The second is the sensor: the endpoint, browser or MCP client where the agent actually runs. The endpoint sees local claude, codex and cursor processes, the shell and tool commands they run, and the files and domains they touch. A scan of ~/.cursor/mcp.json and claude_desktop_config.json lists every local MCP server a developer has wired up, with its command and environment; Strac's MCP DLP sensor then records the live tool calls. An endpoint secrets scan finds the API keys, PATs and tokens in shell profiles and .env files that agents authenticate with (identity pattern D). And the browser sensor records when a computer-use agent takes control of a tab the human was already logged into, what it clicked and what it downloaded.
client_idactor_is_agent, agent_session_id)ApiEventTwo rules keep this table honest. First, do not call every service account, bot or OAuth app an AI agent; keep "is an agent" and "is a non-human identity" as separate flags, or the real risk drowns in CI bots and backup accounts. Second, never present weak attribution as fact. The UI must say whether a link is provider-attributed, Strac-correlated or inferred, so a reviewer can disagree with it. The deeper treatment of these patterns is in discover AI agents.
Here is the case that defeats every API-only shadow AI detection approach.
Alice is logged into Salesforce in Chrome. Salesforce Event Monitoring records a ReportExport by Alice: 2,310 rows, no connected app, no bot ID, no MCP service name. From the provider's point of view, a human exported a report. There is nothing to detect.
The endpoint and browser sensors on Alice's laptop saw something else in the same 43 seconds. A Cowork process took control of the Chrome tab that had Salesforce open. The agent issued a tool call, browser.click("Export"). A CSV landed in Downloads. The agent process then read that file and sent a request to api.anthropic.com.

Three things to notice. The attribution is deliberately marked correlated, not provider-native, because Salesforce never said an agent did it. The confidence factors are shown rather than folded into a score, so an analyst can argue with them. And the finding is High, because the export contains customer records and the destination is an external AI endpoint, which is a sensitive-data touch regardless of who or what pressed the button.
This is identity pattern E, the browser or session identity, and it is growing fastest because computer-use agents are the easiest kind to deploy. Pattern F, an automation signing in with a shared username and password, looks the same from the provider's side. Both are invisible to any tool that only reads admin APIs. The browser and endpoint sensors that already power the three detection layers above are what close the gap.
Detection without a decision is a spreadsheet. Every newly discovered agent should move through the same short workflow.
client_id). Disable the runtime or restrict the app where that is the provider-supported path. Anything else gets a review ticket with a deep link to the console.Every decision is reversible or clearly labeled when it is not, and discovery stays read-only until you opt into write access per provider. The policy side of this, owner requirements, staleness windows and what "sanctioned" means, is covered in AI agent governance. Keeping the sanctioned ones honest over time is monitoring AI agents.
Knowing that ChatGPT was reached is useful; knowing that a file with 42 SSNs was opened by an AI app, or that a customer export was picked into an upload to an unmanaged tool, is what turns detection into risk management. Strac correlates AI activity with content classification, so a shadow-AI event carries the data classes involved, PII, PHI, PCI, secrets, source code, without ever capturing the prompt.
For agents, the same join runs on permissions as well as activity. An OAuth grant with drive.readonly is a capability; the files Alice can actually read, and which of them contain SSNs, is the exposure. Strac resolves both, so a shadow agent shows up with "can reach 193 sensitive files" before it has read a single one, and "did read payroll.xlsx" the moment it does.
There is a bright line between detecting AI usage and surveilling employees. Good detection records the service, the app, the device, the user, and whether sensitive data was involved. It does not record what people type or see. Strac holds that line explicitly: no keystroke logs and no screenshots anywhere in the product. That is what makes a detection program deployable without a fight from employees or works councils.
The same principle applies to agents. Strac does not collect prompts or content by default when metadata answers the question. A finding needs the principal, the permission, the resource, the action and the classification, not the conversation.
Watch how Strac surfaces AI activity and the sensitive data that comes near it, in real time, from the endpoint:
Strac redacting sensitive data in AI and MCP traffic. The agent inventory, identity resolution and activity attribution described above sit on top of this data layer.
Detection is not a one-time audit. The playbook below sets up the sensors and connectors once, baselines for two weeks, and then runs continuously, so a new tool or agent is reviewed in days rather than at the next annual survey.

Detection tells you shadow AI is happening. DLP is what stops the leak. The moment sensitive data heads to an AI tool, pasted into a browser prompt, dragged into an upload, opened by a desktop AI app, or overshared in a file an agent can reach, Strac's content-aware DLP remediates it in real time. This is why so many teams run Strac for web GenAI DLP: it is the remediation layer that turns "we found shadow AI" into "the data never left."
Strac gives you the right response for each surface, set per data type:




Because detection and DLP live in the same platform, you see the shadow AI and remediate the data with one policy and one audit trail, across SaaS, browser, endpoint, GenAI, and MCP.
Strac is an AI agent security platform built on the sensors that already run shadow AI detection. The browser extension, the endpoint agent and the MCP sensor see the tools and the agents; the provider connectors for Google Workspace, AWS and Bedrock AgentCore, GitHub and Copilot, Slack, Salesforce and Agentforce, Claude, ChatGPT and Cursor see the grants, apps, runtimes and sessions. Strac joins all of it into one graph: Agent → Principal → Permissions → Resources → Sensitive data.
That graph answers the four questions for every agent you find. Identity: what is acting and which credential it uses, resolved across all six patterns with a stated confidence. Authorization: what that credential can do, directly and through delegation. Activity: what it did, from provider audit logs, the Anthropic and OpenAI compliance APIs, and Strac's own sensors. Data: which sensitive resources it can reach and which it touched, from the classified inventory Strac already maintains for DLP. Identity tools stop at "can." Guardrail tools stop at the model. The sensors are what let Strac see the agents in patterns E and F that API-only discovery cannot attribute at all.
Detection is step one; the same Strac agent lets you govern and control what you find. Explore the Shadow AI hub, learn to prevent shadow AI without banning AI, compare shadow AI detection tools, and see the broader endpoint DLP agent and GenAI DLP.
Much shadow AI runs on the device itself, so detection has to reach the endpoint. Strac's endpoint agent discovers AI usage and local agents on Mac and Windows without keystroke logging or screenshots.

Want to block or govern a tool? See how to block ChatGPT at work and AI usage monitoring.
👉 Book a demo and we will run shadow AI and agent discovery read-only against your Google Workspace or Slack tenant on the call, including the OAuth grants and local MCP servers nobody registered.
Shadow AI detection is the practice of finding the AI tools and AI agents your workforce uses without approval, mapping them to the devices, users and identities behind them, and spotting when sensitive data comes near them. It covers three layers for tools (network, browser, endpoint) and a fourth for agents: the provider control planes where OAuth grants, app installs and agent runtimes live. It is the first step of any shadow AI program, because you cannot write policy or enforce anything for what you cannot see.
Watch which AI services each device reaches, in the browser and from desktop clients, plugins, and scripts, name the unmanaged ones, and flag when sensitive data comes near them. Strac does this on the endpoint without reading prompts or logging keystrokes.
Pull the provider control planes first: OAuth tokens by client_id in Google Workspace, app inventories in Slack and GitHub, AgentCore runtimes in AWS, connected apps and bot fields in Salesforce, and the Anthropic and OpenAI compliance APIs. Then add sensors for what those APIs cannot see: local agent processes, MCP config files, secrets in the execution environment, and browser sessions driven by computer-use agents. Join the two and label every attribution with its confidence.
Yes. Detection should record the AI service, the app, the device, and whether sensitive data was involved, never the content people type. Strac captures no prompts, keystrokes, or screenshots, and for agents it records metadata (principal, permission, resource, action) rather than conversation content.
No. Network and CASB tools miss desktop AI clients, IDE plugins, and scripts calling AI APIs, and they can't cleanly tie a connection to a user and a file. They also miss every agent that acts through a provider's own API with a legitimate OAuth grant, because that traffic never looks unusual. An endpoint agent plus the provider control planes cover those paths.
With an endpoint agent it's near real-time: the moment a device reaches an AI service it's recorded. Provider-side agent discovery is close behind; a small inventory of OAuth grants, apps and runtimes comes back within the first session, and audit feeds are polled every few minutes after that. Survey-based inventories, by contrast, are stale the day they're finished.
.avif)
.avif)
.avif)
.avif)
.avif)

.gif)

