GUIDE, read 12 Nov 2026
Shadow AI detection works by combining five endpoint signals, because each one sees a different slice and misses the rest
Detection is a data-fusion problem, because no single signal is complete
Finding unsanctioned AI on laptops is a detection task, and like any detection task it starts from signals. A signal is a record that exists whether or not you are looking: a process table, an extension list, a DNS query, a config file, a consent record. The signals below are the ones that exist on or near the endpoint for AI tools. Each is described by what it sees, what it misses and what it costs to collect.
This guide covers the signals. It does not explain why shadow AI happens or how to write the policy that defines it. Both belong in other guides. The reader is assumed to have an EDR or MDM already and wants to know which of its data answers the question.
All product-specific facts come from vendor documentation read on 12 Nov 2026. No vendor evidence files for AI endpoint products were available when this guide was written, so no vendor's detection claim is repeated here.
Process and binary inventory finds installed apps and agents that run
The most direct signal is what runs. A process inventory records executable names, paths, signing identity, parent process and command line. Desktop AI apps appear as signed applications. Command-line agents appear as processes started from a terminal, often a Node, Python or native binary that the user installed with a package manager. Local MCP servers appear as child processes of an AI client.
On macOS the system source for process and file events is Apple's Endpoint Security framework (Apple developer documentation, read 12 Nov 2026), which security sensors consume. On Windows the equivalent comes from event tracing and driver-level sensors. Your EDR already uses these sources.
What the signal sees well: a binary exists and runs, who ran it, when, and what it launched. What it misses: an AI tool that runs in a browser tab leaves no new process. A portable binary renamed by the user defeats name matching, so match on signing identity, hash and parent chain as well. And a process record does not say what data the tool touched unless file and network events are linked to it.
Cost: low if your EDR keeps process history, with a catch. Retention is often short, and AI tools are installed once and used for months. Query installed software and application directories as well as running processes, so a tool run weekly is not missed.
- Match on: signing identity, bundle ID or install path, not file name alone.
- Pair with: a list of known AI client apps and agent CLIs that you update monthly.
- Watch for: unsigned or user-writable-path binaries with network connections to model provider domains.
Browser extension inventory finds add-ons that read pages
Every installed extension has an ID, a version, a publisher and a set of permissions. Chrome and Edge both report these to administrators when the browsers are managed. Microsoft's Edge reference describes the ExtensionSettings policy, which controls the update URL and blocked permissions per extension (Microsoft Learn, Edge extension management reference). Google documents the same policy for Chrome (Google, Configure ExtensionSettings policy).
What the signal sees well: which AI extensions are installed, which profiles hold them, what permissions they request and when they changed. A new extension with access to all URLs is a high-value alert, and Google's permission-warnings documentation explains why: that access covers every site the user opens (Chrome for Developers, permission warnings page).
What it misses: browsers and profiles outside management, extensions in a second browser you do not collect from, and AI features built into a browser rather than installed as an add-on. It also does not show whether the extension was used, only that it exists.
Cost: low for managed browsers through cloud management or policy reporting. Higher for unmanaged profiles, where you need a collector on the machine.
- Match on: extension ID against a maintained list, plus keyword match on name and description for new entries.
- Alert on: a host permission change, an update-URL change or a publisher change for an allowed extension.
- Cross-check: the inventory against your allowlist to find installs that policy should have blocked.
Network and DNS records find use of AI services, with weak attribution
DNS queries and network connections to model provider domains show that something on a machine talked to an AI service. A resolver or proxy log is the cheapest place to see this at scale, because it covers every device on the network and needs no endpoint software.
Microsoft's approach illustrates the idea at the browser level: Purview documents that AI apps can be detected through browser activity and categorized as Generative AI in the Defender for Cloud Apps catalog (Microsoft Learn, Purview and generative AI apps page). A categorized domain list is the building block, whoever supplies it.
What the signal sees well: that a device resolved or connected to an AI domain, how often, and at what volume of bytes. It also finds tools you did not know to look for, because a new domain shows up in the categorization even when no process match exists.
What it misses is a long list. It does not show prompts, files or tool calls. It does not name the process, unless the log comes from an endpoint sensor that records the process with each connection. Encrypted DNS and VPNs hide it from network-side logs. Traffic off the corporate network, on a home connection, never reaches your resolver. And many AI features sit behind domains shared with general services, so a domain match gives a false positive or a false negative.
Cost: low at the resolver or proxy, medium on the endpoint. For attribution, collect connection records with process name and user on the device itself.
- Use for: breadth and discovery of new services.
- Do not use for: proof of data exposure or of a specific user action.
- Improve with: process-linked connection records and a domain list that you review monthly.
Agent and MCP config files find what an AI tool is set up to do
Config files describe intent. They are on disk before the tool runs and stay after it stops. For MCP, each client keeps its server list in a defined place: Claude Desktop in claude_desktop_config.json under the user's application support or APPDATA folder (modelcontextprotocol.io, connect local servers page), Cursor in .cursor/mcp.json and ~/.cursor/mcp.json (Cursor docs), and Claude Code in .mcp.json and ~/.claude.json (Anthropic, Claude Code MCP page). The sibling guide on local MCP servers lists the paths in a table.
What the signal sees well: which servers a user configured, the command each runs, the arguments, and which environment variable names are set. It finds tools that are installed and dormant. It also finds project-level definitions that arrived with a cloned repository.
What it misses: it shows configuration, not use. A server may be defined and never launched. A tool whose config lives in a location you do not know to scan is invisible. Cloud-hosted agents have configs on a server, not on the laptop. And a config file is easy to edit, so file-integrity monitoring matters more than a one-time scan.
Cost: low to medium. You need a script or sensor that can read files in every user profile, extract fields and exclude secret values.
- Collect: path, hash, modified time, server names, command and args, env variable names (not values).
- Alert on: a new server, a changed command, or a server defined with a package runner such as npx.
- Update: the path list as clients ship new versions.
OAuth grants find AI apps connected to corporate data, whatever device they run on
When a user signs in to an AI app with a work account, or authorizes an app to read mail or files, the identity provider records the consent. Microsoft documents how to review the permissions granted to applications in a Microsoft Entra tenant, covering applications added through user or admin consent, and the roles needed to do it (Microsoft Learn, manage application permissions page).
What the signal sees well: which AI apps hold access to corporate data, which scopes they hold, which users consented, and when. It works for apps on unmanaged devices and phones, because the grant lives in the tenant. That makes it the best signal for the cases where nothing runs on a managed laptop.
What it misses: tools that never touch your identity provider. A personal account on a consumer AI service, an API key pasted into a command-line agent, and a local model need no OAuth grant. It also shows the app, not the activity: a grant says the app can read mail, not that it did.
Cost: low. It is an administrative query, and it can run daily.
- Review: grants with write or full-mailbox scopes first.
- Alert on: a new AI app consented by multiple users in one week.
- Revoke: grants for apps outside your approved list, after notifying users.
The five signals side by side
The table compares what each signal can establish. 'Presence' means the tool exists on a device or in a tenant. 'Use' means evidence it ran. 'Data' means evidence of what content it handled.
| Signal | Presence | Use | Data | Main blind spot |
|---|---|---|---|---|
| Process and binary inventory | Yes | Yes | Only if linked to file and network events | Browser-only AI tools |
| Extension inventory | Yes | Not shown | No | Unmanaged browsers and profiles |
| Network and DNS | Indirect | Yes, by domain | No | Prompts, files, and traffic off the network |
| Config files | Yes, including dormant tools | Not shown | No | Unknown paths and cloud-hosted agents |
| OAuth grants | Yes, for tenant-connected apps | Partial | Scopes only | Personal accounts and API keys |
Combine signals into one finding per tool and test the pipeline with a known app
Raw signals produce noise. The useful unit is one finding per tool per user: this person has this AI tool, found by these signals, last seen on this date. A finding supported by two separate signals, such as a process and a DNS record, is more reliable than either alone. A finding supported by a config file alone is a possibility, not a confirmed use.
Test the pipeline before you trust it. Install a tool you know, such as an AI extension on a test profile, a command-line agent in a terminal and a local MCP server in a config file. Check which signals fired, how long each took to appear and whether they merged into one finding. Remove the tool and check that the finding ages out. If a tool you installed on purpose does not appear, you have measured your blind spot cheaply.
When you evaluate a product that claims shadow AI discovery, ask which of the five signals it collects, from which component, and how it joins them. A product that lists one signal has told you its blind spot. The scorecard on this site treats a claim without a confirming source as a vendor claim, capped at 7 of 10.
Where this sits in the index
- Agent Surface MapWhich of six agent surfaces each of 16 tools sees
- Action Control MatrixWhich of six agent actions each tool can stop
- The ranked index16 tools on seven published criteria
Related guides
Sources
- Apple: Endpoint Security framework, read 12 Nov 2026
- Microsoft Learn: Edge extension management reference, read 12 Nov 2026
- Google: Chrome Enterprise Help, ExtensionSettings policy, read 12 Nov 2026
- Google: Chrome extension permission warnings, read 12 Nov 2026
- Microsoft Learn: Purview and generative AI apps, read 12 Nov 2026
- modelcontextprotocol.io: connect to local servers, read 12 Nov 2026
- Cursor: MCP docs, read 12 Nov 2026
- Anthropic: Claude Code MCP, read 12 Nov 2026
- Microsoft Learn: manage application permissions, read 12 Nov 2026
Last reviewed 12 Nov 2026.