Shadow AI Is Already Running on Your Endpoints: An RMM Playbook to Find It Before Your CIO Does

MIT's GenAI Divide study on enterprise AI adoption put two numbers side by side, and only one of them made the headlines. About 40 percent of organizations had bought official LLM subscriptions. At more than 90 percent of those same organizations, employees were already using personal AI tools for work. And the stat everyone quoted — roughly 95 percent of formal pilots produced no measurable return — is honestly the footnote. The 90 percent is the story.

Translate that for anyone who runs endpoints for a living: there are AI applications installed and running on machines you manage right now that you have never seen, never inventoried, and never approved. Your users didn't wait for the architecture review. They didn't raise a ticket. They downloaded something that solved their problem and got on with their day.

The article calls it a verdict — every employee privately judged that the tool's value exceeded your process, and acted on it. You do not win that argument with a policy memo or a security awareness webinar. You win it with visibility. And endpoint visibility is an RMM problem, not an awareness problem.

What's Actually on Your Endpoints

Shadow AI comes in three tiers, and most IT teams can only see one of them.

Tier 1: Browser-based AI. ChatGPT, Claude, Gemini, Perplexity used in a tab. Invisible to virtually every software inventory on the market. You'll only find this through network visibility or by asking.

Tier 2: Desktop applications. ChatGPT Desktop, Claude Desktop, Gemini, various GPT wrappers. These show up in install inventories — if your inventory covers per-user installs (HKCU uninstall keys), which many SCCM configurations and legacy audit agents simply don't collect.

Tier 3: Local LLM runtimes. Ollama, LM Studio, GPT4All, Jan, KoboldCpp. This is the tier that hurts you operationally, not just on paper. A user downloads Ollama, pulls a couple of GGUF models, and suddenly you have:

• 20–80 GB of model files eating a 256 GB laptop SSD
• ollama.exe pinning the CPU at 100% and cooking the battery
• A helpdesk ticket that says "laptop is slow since last week"
• A tech who remote-sessions in, glances at Task Manager, doesn't recognize the process, closes the ticket with "rebooted the machine, asked user to monitor"

That ticket comes back. It always comes back. And now you're on your third remote session for a problem that a software inventory snapshot would have explained in ten seconds.

Why Your Current Tooling Never Saw It

Be honest about the stack. The typical mid-size IT shop is running some combination of:

• SCCM or a legacy inventory agent scanning weekly or monthly, often with user-scope installs excluded from the collection
• A standalone monitoring tool — PRTG, Zabbix, SolarWinds — watching disks, services, and ping, with zero software context
• A separate RMM — ConnectWise, Ninja, Datto — that can run scripts, but lives in its own console and its own database
• A helpdesk — ServiceNow, Jira, Freshservice, ConnectWise Manage — holding the "slow laptop" ticket with no idea what got installed on that machine four days ago

Four products, four databases, four timelines. Correlating "new software appeared" with "performance fell off a cliff" requires a human being to mentally join data across four tabs. At 4:45 on a Friday, that doesn't happen. It doesn't happen most days.

This is the siloed-architecture tax nobody puts on a budget line. The tools weren't designed together, the data doesn't flow between them, and so your software inventory is quietly a guess. The CIO's question — "who is using AI, and with what data?" — currently gets answered with a shrug and a two-week manual discovery project.

What It Costs You

The slow-laptop loop. Repeated remote sessions, repeated "rebooted and monitored" closures, a frustrated user, and a tech who looks like they don't know what they're doing — when the actual root cause was never in front of them.

The disk that fills silently. Forty gigs of GGUF files push the system drive past the backup staging area. Backup job fails. The disk alert threshold was set three years ago at 85% and fires at 2am — or doesn't fire at all because the drive filled between polling intervals.

The budget that's already spent. Sixty employees on personal ChatGPT Plus at $20/month is $14,400 a year off the books, discovered at renewal — while leadership separately debates a formal AI pilot that produced no measurable return. That's the 95% from the study, playing out on your P&L twice.

The SLA report you can't build. Governance, license compliance, and audit responses all start from inventory. If inventory lives in a quarterly SCCM export and your helpdesk data lives somewhere else entirely, every executive question becomes a manual data-joining exercise that makes your team look slower than it is.

How AlertMonitor Closes the Gap

AlertMonitor treats shadow AI discovery as what it actually is: a routine endpoint management task, not a forensic incident.

One agent, one console. Monitoring, RMM, helpdesk, and patch management run off the same agent and the same timeline. Software inventory is continuous, not a quarterly snapshot — and per-user installs are collected, because the platform was designed to see what users actually install.

Script push across device groups. Select "Workstations — All" or "Client A — Finance," run a discovery script across the whole group in one action, and the results land directly in each endpoint's timeline. No RDP-ing to 50 machines, no PowerShell Remoting babysitting.

Script output becomes monitoring data. This is the part fragmented stacks can't do. Define an alert condition on the script output — new match on a shadow-AI pattern, model directory over 10 GB, unknown local server process — and the next time a user installs Ollama on a Friday afternoon, a ticket is already in the service desk queue before the Monday "laptop is slow" complaint arrives.

Remote session straight from the alert. Click through from the detection to a live remote session on that endpoint. See the process. Talk to the user. Decide: approve it, replace it, or remove it — all without leaving the platform.

The approved path gets pushed the same way. Once leadership picks the sanctioned assistant — say, a company-licensed Copilot — you deploy it through the same software deployment and patch engine you use for browser updates. Make the compliant route the easy route. That is the only real answer to the "verdict" the article describes.

One timeline for the audit. Detection, script output, the uninstall, the approved deployment, and the helpdesk ticket — all linked on one record per endpoint. When the CIO asks who's using AI, the answer is a filtered view, not a two-week project.

Old way vs. AlertMonitor way

Old way: User complains → ticket in helpdesk → RDP in → manual Task Manager spelunking → email the inventory team → wait two days for an SCCM report → close ticket with no root cause. 45+ minutes per incident, zero artifacts, and it repeats.

AlertMonitor way: Scheduled sweep or automated alert → endpoint timeline shows the install and the script output → remote session from the same screen → uninstall or deploy the approved tool → ticket auto-updated with evidence. About 10 minutes, full audit trail, and it doesn't repeat.

For a 500-endpoint discovery sweep, that's the difference between "open a change request and wait" and fifteen minutes including coffee.

Practical Steps: Find It This Week

1. Sweep installed applications across every Windows endpoint

Save this as a script in AlertMonitor, target your workstation device groups, and review the output per endpoint in the timeline:

$AiAppPatterns = 'ChatGPT|Claude|Copilot|Gemini|Perplexity|Ollama|LM Studio|GPT4All|AnythingLLM|Jan'

$paths = @(
  'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
  'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*',
  'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*'
)

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
  Where-Object { $_.DisplayName -match $AiAppPatterns } |
  Select-Object @{n = 'Computer'; e = { $env:COMPUTERNAME } },
                 DisplayName, DisplayVersion, Publisher, InstallDate, UninstallString |
  Sort-Object DisplayName

Note the HKCU hive — that's where most per-user AI installs hide, and it's exactly what legacy inventory collection skips.

2. Hunt down local LLM servers and their model stores

# Local LLM runtimes and the disk they're eating
$hits = @()

$procs = Get-Process | Where-Object { $_.ProcessName -match 'ollama|llama|lmstudio|jan|gpt4all|koboldcpp|llamafile' }
foreach ($p in $procs) {
  $ram = [math]::Round($p.WorkingSet64 / 1MB)
  $hits += [pscustomobject]@{ Type = 'Process'; Detail = "$($p.ProcessName) PID $($p.Id) - $ram MB RAM" }
}

$modelDirs = Get-ChildItem 'C:\Users\*\.ollama\models',
                            'C:\Users\*\AppData\Local\lm-studio',
                            'C:\Users\*\AppData\Local\Programs\GPT4All' -Directory -ErrorAction SilentlyContinue
foreach ($d in $modelDirs) {
  $sizeGB = [math]::Round((Get-ChildItem $d.FullName -Recurse -File -ErrorAction SilentlyContinue | Measure-Object Length -Sum).Sum / 1GB, 1)
  $hits += [pscustomobject]@{ Type = 'ModelStore'; Detail = "$($d.FullName) - $sizeGB GB" }
}

$hits | Format-Table -AutoSize

Anything over ~10 GB of models on a laptop SSD is a future "my disk is full" ticket. Find it now, on your schedule — not at 2am.

3. Decide: approve, replace, or remove

Not everything gets deleted. Some power users are doing genuinely valuable work with local models — that's the "verdict" from the article, and smart IT teams channel it instead of fighting it. When removal is the call:

# Stop a shadow local LLM server and reclaim the disk (get sign-off first)
Get-Process -Name ollama* -ErrorAction SilentlyContinue | Stop-Process -Force
Start-Sleep -Seconds 2

$modelPath = "$env:USERPROFILE\.ollama\models"
if (Test-Path $modelPath) {
  $sizeGB = [math]::Round((Get-ChildItem $modelPath -Recurse -File | Measure-Object Length -Sum).Sum / 1GB, 1)
  Remove-Item $modelPath -Recurse -Force -Confirm:$false
  Write-Output "Removed $modelPath - $sizeGB GB reclaimed on $env:COMPUTERNAME"
}

Run it from AlertMonitor, and the output — including the GB reclaimed — is on the endpoint's timeline next to the original detection and the helpdesk ticket. That's your audit trail, assembled automatically.

4. Don't forget the Linux and Mac fleet

# Sweep a Linux or macOS endpoint for AI tooling
ps aux | grep -Ei 'ollama|llama|lmstudio|gpt4all|jan' | grep -v grep

ls -d ~/.ollama/models 2>/dev/null && du -sh ~/.ollama/models pip list 2>/dev/null | grep -Ei 'openai|anthropic|langchain|llama-cpp' find ~ -maxdepth 3 -name '*.gguf' -exec du -sh {} ; 2>/dev/null

Developers and data scientists are your highest-probability Tier 3 users, and they are not on Windows.

5. Make it continuous, not a one-off

The sweep you run once is a project. The sweep AlertMonitor runs weekly is monitoring. Schedule the discovery script on a recurrence, set an alert condition on new detections so they auto-create a helpdesk ticket, and push the sanctioned AI tooling through the same deployment pipeline. New installs surface themselves; your team triages instead of hunting.

The Real Fix: Make the Approved Path the Easy Path

The CIOs slowing AI down aren't anti-AI. They're anti-flying-blind — and the study's numbers show the flight already left. More than 90 percent of their people adopted AI without them. You can't retroactively approve what you can't see, and you can't govern what isn't in your inventory.

That's why this lands in the RMM bucket, not the security newsletter. Discovery, decision, deployment, documentation — it's all endpoint management, and it all happens in one platform instead of five tabs. Run the sweep this week. You will find something. Then decide whether it's a removal, a license, or the first line of your AI governance policy — backed by endpoint data instead of a guess.

Related Resources

AlertMonitor RMM & Remote Management AlertMonitor Platform Overview Book a Demo RMM & Remote Management Resources