English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

When AI Agents Start Self-Replicating: Shadow IT's Exponential Explosion and an Open-Source Detector

Forum topic · ✨步子哥 · 2026-11-10

Summary

A Chinese tech forum post analyzes the November 2026 paper 'Detecting Shadow AI: Unsanctioned LLM Agents on Enterprise Endpoints' by Jérémy Canale and Fabien Soulis. The paper models how agentic artifacts—CLI coding agents, MCP servers, homemade scripts—self-replicate inside enterprises, proving that when reproduction rate exceeds removal rate, shadow IT grows exponentially. It introduces the 'behavioural twin' argument: any detector relying only on process trees and network behavior cannot distinguish agents from benign lookalikes like npm install. The authors release Agent Detector, an open-source Go-based Windows tool deployed via Microsoft Intune, which correlates DNS-cached LLM service identity, configuration fingerprints (API keys), execution history (Prefetch/BAM), and MCP patterns to achieve perfect precision/recall in a small benchmark. Key caveats: DNS cache windows last only minutes, intermittent agents evade scans, and the 184-endpoint catalog needs constant maintenance. The recommended governance philosophy is notify-and-acknowledge rather than blocking.

When AI Agents Start Self-Replicating: Shadow IT's Exponential Explosion and an Open-Source Detector

*English translation of a zhichai.net forum post discussing arXiv paper 2611.12377.*

A CISO's Nightmare

Imagine you're the CISO of a financial company. Last year you approved GitHub Copilot. Early this year, an engineer installed Claude Code on his Windows laptop—you didn't approve it, and you don't know about it.

Claude Code isn't just a chat box. It's an agent that can read/write files, execute commands, and call APIs. One afternoon, the engineer asked Claude Code to build a data-processing pipeline. Claude Code decided it needed three MCP servers to extend its capabilities, so it automatically npx-installed mcp-server-filesystem and mcp-server-git, and wrote a custom Python script to call OpenAI's API for data cleaning.

These three components stayed on his machine. The Python script itself is agentic—it decides at each run how many API calls to make and what commands to execute. He added it to Windows Task Scheduler, running hourly.

A month later, another engineer asked for a copy because it was useful. Two months later, the script had three modified versions, one of which auto-generates new sub-scripts for new data sources.

Your company approved one tool. Now it has nine unapproved agentic artifacts running, two of which self-replicate.

This isn't science fiction. It's the scenario depicted in the November 2026 paper "Detecting Shadow AI: Unsanctioned LLM Agents on Enterprise Endpoints" by Jérémy Canale and Fabien Soulis, who use a simple mathematical model to prove: when agentic artifacts reproduce faster than the organization removes them, shadow IT explodes exponentially.

Three Waves: Shadow IT → Shadow AI → Shadow Agents

Wave 1: Classic shadow IT. Employees install Dropbox on their own, email work files to personal accounts, turn Excel macros into a mini-ERP. Growth is slow—each tool requires a human to find, install, and configure it. It converges: adoption caps out and the stock caps out too.

Wave 2: Shadow AI (conversational). After ChatGPT, employees started pasting company code into web chat boxes. 2024 data is alarming: 75% of knowledge workers use generative AI at work, 78% of AI users bring their own AI tools, 44% admit violating company AI policy, 61% deliberately hide it. IBM reports one in five breached organizations reported shadow-AI-related breaches. But this wave is still controllable—conversational AI happens in the browser, visible at the network layer.

Wave 3: Shadow agents. The paper's core warning. Agents aren't chat boxes—they're software that works by itself: Claude Code, OpenAI Codex CLI, Cursor, homemade Python scripts. They run locally, execute commands with user privileges, and call remote LLM APIs. Crucially, agents make agents: they install MCP servers, generate automation scripts, and leave config files behind—artifacts that are themselves agentic and keep reproducing.

A Chilling Formula

Let \(A_t\) be employees using unapproved agents at month \(t\), \(S_t\) the stock of unapproved tools.

Classic shadow IT dynamics:

\[S_{t+1} = (1-\delta) S_t + \kappa A_t\]

where \(\kappa\) is the per-employee monthly introduction rate and \(\delta\) the monthly removal fraction. This converges to \(\kappa N / \delta\)—bounded growth, because tools don't make tools.

Agentic shadow IT dynamics:

\[X_{t+1} = (1 - \delta + \sigma\phi) X_t + \rho A_t\]

Two key changes:

  • \(\rho \gg \kappa\): agent users create artifacts far faster (agents make tools almost for free)
  • \(\sigma\phi\): a fraction \(\phi\) of the stock is agentic, reproducing at rate \(\sigma\)
  • Let \(g = 1 - \delta + \sigma\phi\). When \(\sigma\phi < \delta\), \(g < 1\) and the stock converges to \(\rho N / (\delta - \sigma\phi)\)—large but bounded. When \(\sigma\phi > \delta\), \(g > 1\) and the stock grows exponentially, \(X_t \sim g^t\), independent of headcount.

    Plain translation of the critical condition: when agentic artifacts reproduce faster than the organization removes them, shadow IT explodes exponentially.

    The paper stresses the model isn't for measurement—it doesn't claim to know true values of \(\sigma\) or \(\phi\). Its purpose is to show which quantities matter. And the most important insight: removal presupposes discovery. You can't remove what you don't know exists. Detection isn't sufficient for governance, but it is necessary.

    Behavioural Twins: Why Detecting Agents Is So Hard

    Say you deploy monitoring on every Windows laptop. You see:

  • a python.exe process
  • with a child process cmd.exe
  • making a TLS connection on port 443 to a remote address
  • held for several minutes
  • Is this an agent?

    Maybe. But it could also be npm install—also an interpreter process, also spawns subprocesses, also downloads over 443. Or a VS Code integrated terminal running a build script. Or an admin's automation.

    The paper proposes an elegant concept: the behavioural twin. For every agent, there exists a behaviorally identical program that isn't an agent—same process tree, same connection pattern, same shell calls—only the remote service is a normal API, not an LLM.

    The paper proves this mathematically. Let \(\beta(a)\) be agent \(a\)'s behavioral features and \(\iota(a)\) its identity features. A twin \(b\) satisfies \(\beta(a) = \beta(b)\) but \(\iota(a) \neq \iota(b)\). Any detector \(f\) depending only on \(\beta\) returns the same verdict for both—either missing \(a\) or false-positiving \(b\).

    The power of this argument is its triviality: it says not that some detector is inadequate, but that any behavior-only detector cannot in principle distinguish agents from non-agents.

    The experiments confirm it: two simple behavioral rules—"interpreter + 443 + shell" and "any process + 443 + shell"—false-positived on 4 of 9 benign workloads, including every behavioural twin and a plain npm install.

    Nine Agent Classes, Six Footprint Layers

    Nine agent classes (C1–C9):

    | Class | Examples | Characteristics | |---|---|---| | C1 CLI coding agents | Claude Code, Codex CLI, Aider | Native executables or Node/Python runtimes | | C2 Desktop agents | Claude Desktop, ChatGPT Desktop | Packaged apps (MSIX) | | C3 AI-native IDEs | Cursor, Windsurf | Electron apps | | C4 IDE extensions | GitHub Copilot, Cline, Continue | IDE extension hosts | | C5 Local LLM runtimes | Ollama, LM Studio, llama.cpp | Local ports, no external connections | | C6 Agent browsers | Perplexity Comet | Browser processes | | C7 Frameworks/SDKs | LangChain, CrewAI, AutoGen | Python/Node interpreters | | C8 Homemade agents | Short API-calling scripts | Generic interpreters, no stable identity | | C9 Agent infrastructure | MCP servers, self-built gateways | Serve other agents |

    These form a "productization" gradient: from fully signed packaged apps (C2) to a bare text file run by a generic interpreter (C8). The closer to C8, the fewer stable identifiers you can grab. A python.exe plus a 20-line script—no install record, no signature, no version. How do you detect that?

    Six endpoint footprint layers (L1–L6):

  • L1 Software identity: image names, install paths, version resources, Authenticode signatures
  • L2 Runtime structure: command lines, parent-child processes, loaded modules, environment variables
  • L3 Network: established connections, remote service identity, listening ports
  • L4 Installation: installed-program records, services, IDE/browser extensions
  • L5 Configuration: config folders, API key storage
  • L6 Execution history: Prefetch, BAM (Background Activity Moderator), recent files
  • Key insight: low-productization agents (C8) leave almost no trace on L1–L4 and are only visible at runtime on L2 and L3. You must catch them while they run.

    Agent Detector: An Open-Source Windows Detector

    Based on this analysis, the paper releases Agent Detector—an open-source Windows endpoint detector (GitHub: jeremy1392/IntuneAgentDetector), written in Go and deployed via Microsoft Intune.

    Core design principle: anchor behavior to identity.

    Behavior alone isn't enough, but correlating behavior + remote service identity + configuration + install history + execution records distinguishes an agent from its behavioural twin.

    Specifically: 1. Network attribution: correlate connections to specific LLM providers (Anthropic, OpenAI, etc.) via the Windows DNS cache. Maintains a catalog of 39 tool signatures + 184 LLM endpoints covering nine categories (direct APIs, aggregators, inference platforms, gateways, relays, etc.). 2. Configuration fingerprints: detect OPENAI_BASE_URL, ANTHROPIC_API_KEY and similar environment variables, plus AI tool configs in VS Code extension directories. 3. Execution history: Prefetch and BAM record recently run programs, even when nothing is currently running. 4. MCP identification: match command-line patterns like @modelcontextprotocol/ and mcp-server-*.

    Key design decision: notify, don't block. Agent Detector never kills, uninstalls, or blocks anything. It pops a window listing detected AI tools, asking the user to check "I have read and understood the AI usage policy" and click "I accept." It pops on every scan as long as unapproved tools remain. The window has no close button.

    This is clever: it turns governance from a cat-and-mouse game into informed consent. IT knows who's using what, users know they're being monitored, and nobody is prevented from working.

    The Numbers

    In a controlled benchmark (12 synthetic agents + 3 AI components + 9 benign workloads, 5 repetitions per machine):

    | Detector | TP | FN | FP | Precision | Recall | F1 | |---|---|---|---|---|---|---| | Signature detector D0 | 0 | 12 | 0 | N/A | 0.00 | N/A | | Behavioral rule D1 (interpreter+443+shell) | 9 | 3 | 4 | 0.69 | 0.75 | 0.72 | | Behavioral rule D2 (any process+443+shell) | 10 | 2 | 4 | 0.71 | 0.83 | 0.77 | | Agent Detector | 12 | 0 | 0 | 1.00 | 1.00 | 1.00 |

    The signature detector fails completely—the synthetic agents have no signatures. Both behavioral rules false-positived on all behavioural twins and npm install. Agent Detector achieved zero false positives and zero misses via identity correlation.

    But the paper honestly admits these numbers are "more flattering to Agent Detector than any other number in the paper," for three reasons: the benchmark is small, the behavioural twins are constructed worst cases, and the synthetic agents replicate the footprints the detector was built to observe rather than the full diversity of real agents.

    The Cage of Time

    Agent Detector's most interesting limitation is temporal.

    The DNS cache time window. Attributing connections to LLM providers via DNS cache only works while cache entries live. For providers behind CDNs (both OpenAI and Anthropic), entries live only 1–5 minutes. An agent holding one connection for an hour is attributable only during its first few minutes; hourly scans will likely miss it.

    Intermittent agents. A start-stop-start agent is caught by only about one-third of scans—it may simply not be running during the scan window.

    Scan cost. One scan takes ~154 ms and can run frequently. But continuous monitoring (e.g., ETW) costs more; the paper didn't adopt it.

    This temporal limitation reveals a deeper problem: agent detection is fundamentally a game of time. You're not detecting a static file—you're capturing a dynamic behavioral window. This is completely different from the traditional antivirus file-scan model: files are always there, but an agent's network footprint is visible only at certain moments.

    Engineering Takeaways

    1. Agent governance isn't about "allow or deny"—it's about "visible or invisible." You can write the strictest AI policy, but if you don't know who's running what, the policy is just paper. Detection is the prerequisite for governance.

    2. Behavioral detection has a principled ceiling. It's not that detectors aren't good enough—any detector looking only at process trees and connection patterns cannot distinguish an agent from its behavioural twin. Identity information (who is the remote service) is indispensable.

    3. MCP servers are the new attack surface. The paper classifies them as C9—agent infrastructure that may itself be agentic and appears on no inventory. A backdoored MCP server can influence every agent that calls it.

    4. Catalog maintenance is ongoing engineering. The 184-endpoint catalog needs monthly updates—vendors add IP ranges, change CDN configs, ship new products. The authors admit they found Anthropic's IPv6 ranges missing while writing the paper. Like antivirus signature databases, this requires sustained investment.

    5. Notification beats blocking. Blocking Claude Code just pushes engineers to run local models with Ollama—invisible even at the network layer. "Informed acknowledgment" is more realistic in enterprise settings.

    Personal Reflections

    This paper suggests a bigger picture: we're entering a world where agents self-replicate, while our governance tools remain stuck in the static-inventory era.

    The compounding model's core insight isn't "shadow IT will explode"—everyone has that intuition. It's that it gives the critical condition for explosion: \(\sigma\phi > \delta\). Governance thus has two levers: lower the agents' self-reproduction rate (\(\sigma\phi\)), or raise the removal rate (\(\delta\)). And the removal rate's ceiling is the detection rate—what you can't find, you can't remove.

    This closely mirrors biological invasion models: an invasive species explodes once its reproduction rate exceeds predation plus natural mortality. Likewise, once agentic artifacts reproduce faster than IT can clean them up, unapproved tools fill every available niche like invasive species.

    The behavioural twin argument recalls cryptography's indistinguishability: in a perfect cipher, ciphertext is indistinguishable from randomness; a perfect agent is behaviorally indistinguishable from a non-agent program. Detecting agents is, in principle, as hard as distinguishing encrypted traffic from random traffic—you need extra information (a key / identity) to do it.

    Finally, the paper's most practical contribution may be its redefinition of "detection." In the agent era, detection isn't a one-shot action (scan file signatures) but a continuous process (runtime behavior monitoring + identity correlation + time-window capture). This needs a new security infrastructure—not an upgraded antivirus, but something like an EDR for the agent era.

    Open-Source Code

  • Agent Detector: https://github.com/jeremy1392/IntuneAgentDetector
  • Written in Go, deployed via Microsoft Intune
  • Includes an open catalog of 39 tool signatures + 184 LLM endpoints
  • Supports Windows 10 22H2 / Windows 11, Pro/Business/Enterprise editions
  • Paper Links

  • arXiv: https://arxiv.org/abs/2611.12377
  • HTML version: https://arxiv.org/html/2611.12377v1
  • Authors: Jérémy Canale, Fabien Soulis
  • Published: 2026-11-09
---

*When agents start making agents, the battleground of governance shifts from "who is using what" to "what is self-replicating." This paper offers not answers but a framework: the compounding model tells you when to panic, the behavioural twin tells you why detection is hard, and Agent Detector shows what can at least be done on Windows endpoints. The rest is a question every CISO must answer themselves: is your organization's \(\sigma\phi\) greater than \(\delta\)?*

Tags

#ai-agents#shadow-it#cybersecurity#endpoint-detection#mcp#open-source#llm-governance#windows-security

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178637002