Windows Telemetry Myths: Auditing What Your OS Leaks
Windows telemetry now tracks which coding agents and dev tools you run. We test 5 beliefs about ETW, opt-outs, and blocking what leaves your machine.

Last week a researcher disassembled MissionControlAggregator.dll and found hardcoded lists of executable names: codex.exe, claude.exe, cursor.exe, plus python.exe, gcc.exe, and code.exe. Windows 11's telemetry pipeline now keeps bitmaps of which coding agents and developer tools you've used, persists them to disk under C:\ProgramData\Microsoft\Diagnosis, and queues them for upload when optional diagnostic data is enabled — which it is by default on a US install. The predictable response online split into two camps: "this is fine, it's just ETW" and "the only fix is Linux." Both are wrong in instructive ways. I've spent years doing incident response and endpoint forensics, so let's test the five beliefs I keep hearing against what's actually verifiable on a live machine.
Myth 1: "Telemetry is anonymous, so there's nothing to worry about"
This is the first reflex in every telemetry thread, and it survives because people conflate two different claims: "the payload contains no document contents" and "the payload is harmless." The first is mostly true here. The researcher found no prompt text, no source code, no file paths of your projects in the report — just bitsets. Twelve slots for developer-tool categories, four for CLI coding agents, five for desktop agents. A set bit means "this class of tool was observed during the reporting window."
But a bitmap is not nothing. The combination of tools you run is a fingerprint of your profession, your employer's stack, and sometimes what you're building. A machine running cursor.exe, claude.exe, and gcc.exe tells a different story than one running devenv.exe and dotnet.exe. Aggregate that across millions of machines and you have a real-time market-share feed for every AI coding assistant — which happens to be exactly the market Microsoft competes in. That's a competitive-intelligence asset collected from your machine, on your electricity, under the banner of "diagnostics."
There's also a subtler point people miss: which tools you use is operational metadata about you as a developer, the same way which apps you open is metadata about you as a user. We covered a parallel case in our piece on fitness apps as surveillance tools — the lesson generalizes. Metadata about behavior is data about identity, and "we only send bitsets" deserves the same skepticism as "we only collect location." Verdict: busted. The absence of file contents doesn't make behavioral inventory harmless.
Myth 2: "You can't see what Windows actually sends"
This one is just empirically false, and the original investigation proves it. Everything about this feature was observable from a stock machine with admin rights. The component isn't a hidden kernel implant; it's a documented-by-omission pipeline built entirely on public machinery: ETW TraceLogging events, the DiagTrack service, and a local event store you can query.
Here's the audit trail you can reproduce yourself. First, confirm the pipeline is running:
Get-Service DiagTrack | Format-Table Name,Status,StartType -AutoSize
Get-Process AggregatorHost | Format-Table ProcessName,Id -AutoSize
tasklist /m MissionControlAggregator.dll
If AggregatorHost.exe shows up with the DLL loaded, the aggregator is live on your box. Next, look at who's subscribed to what. The Diagtrack-Listener ETW session subscribes to both the input providers (KernelProcess app-state summaries, WSL exec events) and the aggregator's own report provider:
Get-EtwTraceProvider -SessionName Diagtrack-Listener `
-Guid '{00de11a2-ec06-58e5-1a2b-21bb21dbee4b}'
And the upload queue itself is a SQLite database — DiagTrack's EventStore.db, with an AsimovEvents table holding compressed JSON batches. Decompress them and you can read the exact events staged for transmission, including the Segments.SubCohorts report with your agent bits and an isRequired: false privacy tag. The single most instructive experiment in the whole investigation: copy cmd.exe to a file named codex.exe, run it, and watch the Codex bit get set. The detection is name-matching, nothing more. That's both reassuring (no deep instrumentation of the binary) and a little embarrassing for a "diagnostic" feature.
For the network side, the tooling is unglamorous but sufficient: point the box at a proxy you control, or mirror the switch port and capture with Wireshark. DiagTrack traffic is TLS to Microsoft endpoints, so you won't read payloads without intercepting, but you don't need to — the EventStore gives you the plaintext before encryption. Traffic capture answers "when and how much leaves"; the event store answers "what." Verdict: busted. You can audit this end to end, and honestly, every security-conscious team should have done so before this made news.
Myth 3: "Turning off 'optional diagnostic data' makes you clean"
Now the uncomfortable one for people who think they've already handled this. Flipping the toggle under Settings → Privacy & security → Diagnostics & feedback does stop this specific report — the researcher verified the agent-usage event is classified as optional, so setting AllowTelemetry below 3 removes it from the upload queue. Credit where due: the classification is accurate and the off switch works for this path.
But read the mechanism again. The aggregator still runs. The matchers still match. The state is still persisted to AggregatorStorage\MissionControlAggregator$ and the ETW report is still emitted — it's the listener's upload step that's gated, not the collection. You've stopped the exfiltration, not the observation. That distinction matters for two reasons.
First, required-level telemetry still flows. Windows doesn't go silent at level 1; it sends a smaller set of events you have far less visibility into by default. Second — and this is the part I care about as someone who's been burned by config drift — a Settings toggle is a weak control. Feature flags like CLICodingAgentUsage (the experiment flag guarding these checks) get flipped by updates. Privacy settings get reset by feature upgrades; ask anyone who's audited a fleet after a version bump. On managed machines, enforce it through Group Policy or MDM (Computer Configuration → Administrative Templates → Windows Components → Data Collection), because policy is reapplied where toggles are not. Then verify by re-inspecting the EventStore, not by trusting the UI.
A privacy toggle tells you what the vendor intends to stop sending. Only your own capture tells you what actually stopped.
Verdict: mostly busted. The toggle is necessary, not sufficient. Treat it as one layer, and keep a verification habit — the same posture you'd apply to any third-party agent on your endpoints.
Myth 4: "Just firewall the endpoints and you're done"
The blocklist approach has a long, mostly failed history. Microsoft's telemetry endpoints share CDN infrastructure and IP ranges with services you actually need — Windows Update, certificate revocation checks, the Store, activation. Hard-blocking vortex.data.microsoft.com and friends at the perimeter works until an endpoint change, a CDN reshuffle, or an update that renames the pipe silently reopens it. I've watched organizations maintain telemetry blocklists for years; the lists rot within months and nobody notices because the failure mode is silence.
Worse, blunt blocking breaks diagnostics you might actually want. Crash reporting and update health signals ride the same channel. In an enterprise, you'd often rather keep required-level diagnostics flowing to your own compliance view than torch the whole pipeline. The precision moves, in order of preference:
- Set the telemetry level via policy (AllowTelemetry 0 on Enterprise/Education, 1 on Pro) instead of blocking traffic.
- Use the Windows diagnostic data processor / enterprise upload redirection where applicable, so events land in your tenant first.
- If you must filter at the network edge, allowlist rather than blocklist, and alert on new Microsoft-owned destinations rather than chasing a static deny list.
- Audit, don't assume: periodically decompress EventStore.db on a sample of machines and diff what's queued against what your policy says should be queued.
That last point is the real takeaway. The same discipline applies to developer tooling itself — we made a similar argument in Your API Client Is a Credential Vault: audit the thing on your machine instead of trusting its marketing page. Verdict: busted as a primary strategy. Network blocking is a blunt backstop, not a control.

Myth 5: "Switching to Linux is the only serious answer"
The top-voted reactions to this story were migration advice, and look — I'm sympathetic. If your work is a terminal, a browser, and a Docker daemon, a mainstream distro will serve you well and the adjustment is days, not months. But as an answer to telemetry, "just switch" commits two errors.
First, it overestimates what switching buys. As several commenters correctly pointed out, GPU driver utilities from the big three vendors collect executable names and paths unless you opt out, and they run on Linux too. Debian's popularity-contest reports package usage if you opted in at install time. Your IDE, your coding agents, and your browser each run their own telemetry pipelines independent of the OS. The operating system is one layer of the leak, not the leak. A Linux box running a default-configured commercial toolchain still phones home plenty.
Second, it abdicates the skill that actually protects you, which is platform-independent: knowing how to enumerate what's listening, capture what's leaving, and verify what's queued. ETW subscriptions, event stores, and service trees are Windows-flavored, but the method — static analysis for leads, dynamic traces for confirmation, queue inspection for proof of exfiltration — is the same whether you're auditing DiagTrack, a vendor's "anonymous usage stats" daemon, or an AI coding agent's permission model. We've argued before that AI coding agent privacy deserves the same myth-busting rigor, and that containment beats monitoring when you can't fully trust a process. The OS is just another agent you didn't hire.
Verdict: partially busted. Migrating is a legitimate choice and eliminates this particular pipeline, but it's neither necessary nor sufficient for the underlying problem. If you stay on Windows — for work, for games, for the corporate image you don't control — the audit workflow above gets you most of the practical benefit in an afternoon.
The actual fix: an audit habit, not a setting
Strip away the outrage cycle and this story is a gift: someone published a complete methodology, from strings in a DLL to a JSON blob in an upload queue, using nothing but a debugger, PowerShell, and patience. The right response isn't panic or dismissal — it's institutionalizing that workflow. Once a quarter, on a reference machine: check which services spawn telemetry hosts, list ETW session subscriptions, decompress the event store, and mirror a day's egress. Diff against last quarter. When a new flag like CLICodingAgentUsage appears, you'll know within weeks, not years.
The uncomfortable truth is that your toolchain inventory — which agents, which compilers, which editors — is commercially valuable data, and the default settings on the world's dominant desktop OS ship it to a company that sells competing products. That won't change because of a news cycle. What can change is whether you're the kind of engineer who finds out from a blog post, or the kind who already had a trace running.


