Tech12 min read

Windows 11 coding agent telemetry skips npm Codex while recording renamed cmd.exe

IkesanContents

TL;DR

What happens Windows 11 PCs with the CLICodingAgentUsage feature flag (ID 62580080) enabled and optional diagnostic data turned on record AI coding agent launches in MissionControlAggregator.dll (confirmed active on my Windows 11 Home 25H2, build 26200.9974).

What I found In the local aggregator file on disk, Windows recorded Claude Code, Antigravity CLI, and cmd.exe copied to codex.exe, whereas the official npm-installed codex.exe stayed unrecorded across three launch paths (codex exec, interactive mode, and running the native binary directly). Actual outbound uploads to Microsoft remain unconfirmed.

What to do Turn off Send optional diagnostic data under Settings > Privacy & security > Diagnostics & feedback to block uploads to Microsoft.


I run Claude Code, the official npm-installed Codex CLI, and Antigravity CLI (agy) daily on Windows 11 Home (25H2, build 26200.9974). When security researcher Xusheng Li published an analysis on November 16, 2026 showing that Windows 11 checks whether AI coding agents are used and includes that in optional diagnostic data—picked up by outlets like GIGAZINE the next day—I wanted to check whether the same mechanism was active on my machine.

Since the same DLL (Windows system library) and CLICodingAgentUsage feature flag (a switch controlling whether a feature is active) were enabled locally, I inspected the intermediate aggregator file on disk roughly every hour to see which agents got flagged. Here, “recorded” means flipping a slot flag inside the local disk file—which saves roughly every hour during a ~24-hour collection window before emitting a daily summary event to the DiagTrack upload queue—rather than confirming an actual upload to Microsoft. Claude Code and Antigravity CLI were both recorded in that file, while the real Codex (the official codex.exe installed via npm, Node.js’s package manager) stayed unrecorded across three launch paths. Copying cmd.exe to codex.exe and launching it as a filename-matching check, however, immediately recorded it as Codex.

Xusheng Li’s analysis

The report points to the Windows system file MissionControlAggregator.dll, which embeds executable names for AI coding agents and developer tools. When it detects a launch, it marks the corresponding category and emits a diagnostic event roughly once a day.

The original post lists three target categories, including 12 developer tool categories alongside AI agents.

CategoryMonitored executable names
CLI agents (4 slots)copilot.exe, claude.exe, codex.exe, agy.exe (same names without .exe under WSL, the Windows Subsystem for Linux)
Desktop agents (5 slots)github.exe, claude.exe, codex.exe, cursor.exe, antigravity.exe
Developer tools (12 types)node.exe, python.exe, dotnet.exe, gcc.exe, clang.exe, gdb.exe, javac.exe, devenv.exe, code.exe, and others

For some developer tools, the DLL also checks the executable’s digital publisher signature: node.exe expects “Node.js Foundation”, python.exe expects “Python Software Foundation”, and .NET’s dotnet.exe plus Visual Studio’s devenv.exe expect “Microsoft Corporation”. According to the original write-up, compilers and debuggers such as gcc.exe, clang.exe, and gdb.exe have no publisher check.

This tracking is gated by the CLICodingAgentUsage feature flag (ID 62580080). On the original author’s test VM, the flag had been enabled remotely by Microsoft as a service-side experiment without user action.

How detection works and what gets queued

MissionControlAggregator.dll does not poll the process list directly. Instead, it subscribes to three existing Windows diagnostic event streams and matches application names against its embedded list.
Events move through ETW (Event Tracing for Windows, the OS mechanism where Windows components emit internal event logs for other components to listen to). Both the inputs entering the DLL and the Segments.SubCohorts summary event emitted roughly once a day are ETW events. Once emitted, the report enters the upload queue of DiagTrack (Connected User Experiences and Telemetry, the Windows diagnostic upload service).

graph TD
    A["Process state summary<br/>KernelProcess.AppStateChangeSummary"] --> D["MissionControlAggregator.dll<br/>Match against target list"]
    B["Interactivity summary<br/>Win32kTraceLogging.AppInteractivitySummary"] --> D
    C["WSL command execution<br/>Lxss.Manager.Exec"] --> D
    D --> E["Mark matching slot and<br/>save state to disk"]
    E --> F["Emit Segments.SubCohorts<br/>roughly once a day"]
    F --> G["DiagTrack upload queue<br/>as optional diagnostic data"]

Standard Windows launches of codex.exe are also captured through the first path, KernelProcess.AppStateChangeSummary, meaning regular Windows executables—not only Linux binaries under WSL—are covered.
When the original author copied cmd.exe to codex.exe and launched it, Windows still recorded it as Codex, suggesting detection relied on executable filename matching. The emitted telemetry event looked like this:

{
  "name": "Microsoft.Windows.MissionControlAggregator.Segments.SubCohorts",
  "ext": {
    "privacy": { "isRequired": false }
  },
  "data": {
    "Version": "0.1.5",
    "CliAgentSubCohorts": [4],
    "DesktopAgentSubCohorts": [0],
    "FlushedFromSave": true
  }
}

The report event does not carry the agent’s string name; it encodes whether each tool ran during the collection window as a bitmask (one bit per category). In CliAgentSubCohorts, 4 is 0100 in binary, where bit 2 (1 << 2, zero-indexed) corresponds to codex.exe:

CLI agent bitmask mapping:
  bit 0 (1): copilot.exe
  bit 1 (2): claude.exe
  bit 2 (4): codex.exe  <- value 4 = binary 0100 (only bit 2 set)
  bit 3 (8): agy.exe

Although the source ETW events contain runtime duration, foreground time, interaction counts, and resource usage, the DLL appears to discard those metrics and keep only the presence bits. Neither prompts nor source code appear in the report, though the original author notes that even revealing which agents or developer tools someone uses carries privacy implications.

Events enter the upload queue only when CLICodingAgentUsage is enabled and Windows is configured to send optional diagnostic data. The "isRequired": false field confirms this is treated as optional telemetry, and the original write-up verified the event sitting in DiagTrack’s queue under that setting.

In that test—performed on a US-region install of Windows 11 Home ARM64 from a current official ISO image—diagnostic data defaulted to “Send optional diagnostic data” before touching any privacy settings, setting AllowTelemetry to 3 in the registry (Windows’ configuration store). Neither the original post nor news coverage includes any statement from Microsoft or details on how the collected data is used, nor did the post verify whether Japanese locale installs share the same default. That prompted me to check what DLL version, flags, and AllowTelemetry settings were present on my Japanese Windows 11 Home (build 26200.9974) machine.

Checking the DLL and settings without admin rights

I started with non-elevated PowerShell and Python to inspect the local DLL, feature flag, and diagnostic settings.

DLL version and embedded strings

First I verified whether my system had the same DLL version from its file properties:

(Get-Item "$env:windir\System32\MissionControlAggregator.dll").VersionInfo.FileVersion

My machine had 10.0.26100.9818 (WinBuild.160101.0800), updated on November 11, 2026—the exact same version as the original test VM.
Next, I used Python to extract UTF-16 strings (the character encoding used internally by Windows) from the binary. It contained claude.exe, codex.exe, copilot.exe, agy.exe, cursor.exe, antigravity.exe, and github.exe, along with extensionless claude, codex, and copilot for WSL, plus the publisher strings “Node.js Foundation”, “Python Software Foundation”, and “Microsoft Corporation”.
Beyond the developer tools named in the original summary, the binary also listed cl.exe (Visual Studio’s C/C++ compiler), clangd.exe, clang-format.exe, clang-tidy.exe, g++.exe, armasm.exe, jar.exe, idea64.exe (IntelliJ IDEA), studio64.exe (Android Studio), eclipse.exe, and vcpkg.exe. String extraction alone does not reveal which tool maps to which of the 12 developer tool slots.

Feature flag 62580080 status

Next I checked feature flag 62580080. Rather than installing a third-party utility like ViVeTool, I called Windows’ built-in RtlQueryFeatureConfiguration function in ntdll.dll directly from PowerShell, which requires no administrator privileges because applications use it to query their own flags.

Add-Type -TypeDefinition @'
using System; using System.Runtime.InteropServices;
public static class Feat {
  [StructLayout(LayoutKind.Sequential)]
  public struct CFG { public uint FeatureId; public uint Bits; public uint VariantPayload; }
  [DllImport("ntdll.dll")]
  public static extern int RtlQueryFeatureConfiguration(uint id, int type, ref ulong stamp, out CFG cfg);
}
'@
$stamp = [uint64]0; $cfg = New-Object Feat+CFG
$st = [Feat]::RtlQueryFeatureConfiguration(62580080, 1, [ref]$stamp, [ref]$cfg)
"status=0x{0:X8} priority={1} enabled={2} experiment={3}" -f $st, ($cfg.Bits -band 0xF), (($cfg.Bits -shr 4) -band 3), (($cfg.Bits -shr 6) -band 1)

Querying 62580080 succeeded and returned Bits = 0x64 (01100100 in binary). Mapping the bitfields against phnt’s ntrtl.h, a community header collection for undocumented Windows APIs, breaks down as follows:

0x64 = binary 01100100
  bits 0-3: 0100 -> priority=4 (Service, pushed from Microsoft's service side)
  bits 4-5: 10   -> enabled=2  (Enabled)
  bit  6  : 1    -> experiment=1 (Experiment)

This differs from a user-configured override (priority 8, User) and matches the “enabled as a service-side experiment” state on the original test VM. As a sanity check, passing nonexistent IDs like 1 or 99999999 returned 0xC0000225 (STATUS_NOT_FOUND), confirming that only 62580080 held an active configuration.

Diagnostic data settings and how to stop uploads

With both the DLL and the feature flag active, I confirmed that the DiagTrack service was running with automatic startup and checked the AllowTelemetry value in the registry:

Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\DataCollection' | Select-Object AllowTelemetry, MaxTelemetryAllowed

AllowTelemetry was 3 (optional diagnostic data enabled), and the Group Policy override key (HKLM:\SOFTWARE\Policies\Microsoft\Windows\DataCollection, used for centralized admin policies) had no values set.
To stop data from being sent to Microsoft, turn off Send optional diagnostic data under Settings > Privacy & security > Diagnostics & feedback (the same applies if you declined optional diagnostic data during initial Windows setup). According to the original report, the event enters the upload queue only as optional telemetry. However, that setting covers uploads: whether turning it off also stops the DLL from writing local intermediate files is not stated in the original write-up.

Since every precondition was met, I tried opening the intermediate storage directory (C:\ProgramData\Microsoft\Diagnosis\AggregatorStorage) and the DiagTrack queue directory (C:\ProgramData\Microsoft\Diagnosis) without elevation, and also ran Get-EtwTraceProvider to inspect DiagTrack’s ETW subscriptions. All of them failed with access denied (error 0x5).

Inspecting the local aggregator file with admin rights

Switching to an elevated PowerShell session, I first checked which process loaded the DLL and inspected DiagTrack’s ETW subscriptions for the two GUIDs (Microsoft.Windows.MissionControlAggregator and KernelProcess):

tasklist /m MissionControlAggregator.dll
Get-EtwTraceProvider -SessionName Diagtrack-Listener -Guid '{00de11a2-ec06-58e5-1a2b-21bb21dbee4b}' | Format-List
Get-EtwTraceProvider -SessionName Diagtrack-Listener -Guid '{2839ff94-8f12-4e1b-82e3-af7af77a450f}' | Format-List

AggregatorHost.exe had loaded MissionControlAggregator.dll, and both providers were registered under DiagTrack’s Diagtrack-Listener session. Comparing MatchAnyKeyword (the event filter bitmask deciding which event types a listening session captures), my machine used 0x800000000000 for Microsoft.Windows.MissionControlAggregator versus 0xe00000000000 on the original VM; since the report event itself uses keyword 0x800000000000, my session still receives it. For KernelProcess (process state change summaries), my machine had the exact same 0x400000000002 filter as the original VM.

Next, I listed the contents of AggregatorStorage:

Get-ChildItem -Force 'C:\ProgramData\Microsoft\Diagnosis\AggregatorStorage'

Alongside other aggregator files like AdoptionHeartbeat$ and UpdateReboot$, there was a 64-byte file named MissionControlAggregator$. Dumping it with Format-Hex around 21:10 local time on November 18, 2026 showed the following bytes (hex offsets on the left, decoded ASCII text on the right, and raw binary fields after the MissionControlAggregatorV3 header):

0000 4D 69 73 73 69 6F 6E 43 6F 6E 74 72 6F 6C 41 67 MissionControlAg
0010 67 72 65 67 61 74 6F 72 56 33 0A 00 00 00 00 00 gregatorV3.
0020 00 00 02 00 00 00 00 47 6F 57 EE A1 01 00 00 C9
0030 5D 8E EE A1 01 00 00 00 02 00 00 00 00 00 00 00

While the file format is undocumented, the 64-byte size aligns with the function name ReportCohorts<12,4,5> from the original report (12 developer tool slots, 4 CLI agent slots, 5 desktop agent slots). Unlike the final JSON event that packs flags into a single bitmask, the local intermediate file appears to allocate one byte per slot, storing 0 when undetected and 2 when detected:

OffsetBytesInferred fieldObserved value
0x0026Format headerMissionControlAggregatorV3
0x1A1Unknown0x0A
0x1B1212 developer tool typesOnly index 7 (0-based) is 2
0x278Likely collection start timeNovember 18, 2026 20:07:49.959
0x2F8Likely last save timeNovember 18, 2026 21:07:49.961
0x374CLI agents[0, 2, 0, 0] (only index 1 is 2)
0x3B5Desktop agentsAll 0

Decoding the two 8-byte fields at 0x27 and 0x2F as 64-bit little-endian integers (where the bytes are stored in reverse order, least significant byte first) representing milliseconds since the 1970 Unix epoch produces 20:07 and 21:07. Because 0x2F matched the file’s last-modified timestamp at 21:10, 0x27 looked like the start of the collection window and 0x2F like the last save time.
Assuming the 4 CLI slots follow the original post’s order (copilot.exe, claude.exe, codex.exe, agy.exe), only slot 1 (claude.exe) was flagged here—consistent with Claude Code running as claude.exe all day. Slot 7 among the developer tools was also 2, though I could not tell which tool it corresponded to because both python.exe and node.exe had been running. From there, I launched the other agents one by one to see how the remaining CLI slots responded.

Which coding agents got recorded

After each launch, I waited for the next hourly save, checked that 0x2F had advanced past the launch timestamp, and re-dumped the file with Format-Hex (all timestamps below are local PC time). Across all subsequent saves, 0x27 stayed unchanged while only 0x2F moved forward, confirming 0x27 as the collection window start.

In practice, codex exec left the slots unchanged, and interactive codex did not trigger it either. Because the npm-installed codex command is a JavaScript wrapper where node.exe spawns a deeply nested native codex.exe child process, I tried bypassing node.exe and launching codex.exe directly from PowerShell (pwsh), which still had no effect. Even the background codex.exe server daemon that keeps running windowless after exiting interactive mode left the slot at 0 after several hours.
Once a slot flips from 0 to 2, it remains flagged for the rest of the collection window, so I saved the filename-matching test for last. Copying cmd.exe to codex.exe and launching it—the same test from the original report—immediately set slot 2 to 2, and launching agy afterward set slot 3 to 2. Having slots 2 and 3 match the original order also backs up interpreting slot 1 as claude.exe.

Launch timeBinary / commandHow it was launchedCLI 4 slots after next save
November 18 (pre-test)Claude Code (claude.exe)Directly from terminal[0, 2, 0, 0]
November 18 21:03codex execFrom Claude Code Bash (node.exe spawns codex.exe)[0, 2, 0, 0] (21:07, 23:07 saves)
November 18 23:31Interactive codexFrom terminal via node.exe[0, 2, 0, 0] (0:07 save)
November 19 0:21codex.exe inside npm packageDirectly from PowerShell (parent pwsh)[0, 2, 0, 0] (1:07 save)
November 19 1:23cmd.exe copied to codex.exeLaunched via Start-Process[0, 2, 2, 0] (2:07 save)
November 19 2:14Interactive agyFrom terminal cmd[0, 2, 2, 2] (13:17 save)

The renamed cmd.exe being flagged proves there is a code path that reacts to the filename codex.exe. To check whether missing version metadata, a different publisher signature, the node.exe wrapper, or the binary’s install path explained why the official npm codex.exe stayed unrecorded, I compared all four executables:

FileVersion info (Product / Company / Version)SignerRecorded
claude.exeClaude Code / Anthropic PBC / 2.1.327.0AnthropicYes
codex.exe (npm)NoneOpenAI OpCoNo
agy.exeNoneGoogle LLCYes
cmd.exe (renamed to codex.exe)Microsoft Windows Operating System / Microsoft Corporation / 10.0.26100.9949Microsoft WindowsYes

All four signatures were valid, and agy.exe was recorded despite lacking version metadata just like codex.exe, ruling out missing version info or an OpenAI-vs-Microsoft signature mismatch as the sole explanation. Direct launch from PowerShell also failed to register, so running under node.exe does not explain it either.
The remaining difference is where the binary lives: the npm codex.exe sits inside C:\Users\<username>\.local\node\node_modules\@openai\codex\node_modules\@openai\codex-win32-x64\vendor\x86_64-pc-windows-msvc\bin\, a much longer path than the other three. Because the renamed cmd.exe already occupied the Codex slot for the current collection window, testing whether path length causes the skip will have to wait until the window closes and the slot resets.

Save timing and Fast Startup

Throughout the table above, saves arrived consistently around minute 7 of every hour (21:07, 23:07, 0:07, 1:07, 2:07)—except after launching agy at 2:14, when the next save jumped to 13:17.

In between, the PC was powered off at 2:49 and booted back up at 12:59. Subtracting the roughly 42 minutes elapsed between 2:07 and 2:49 from 60 minutes leaves 18 minutes and 32 seconds; adding that to 12:59 gives 13:17:32, just 7 seconds off the actual save at 13:17:25.

Checking why powering off didn’t reset the hourly timer—and skipped the 10 offline hours—showed that Fast Startup (HiberbootEnabled = 1) was enabled on this PC. With Fast Startup, shutting down saves the Windows kernel and services to a hibernation state and resumes their runtime state on boot. Event logs confirmed this: the power-off entry (Kernel-Power 42) showed requested shutdown (6) resulting in hibernation (5), and the boot entry (Kernel-Boot 27) logged a Fast Startup resume (1). The last full cold boot was after installing updates on November 12.
Apparently the 1-hour save interval pauses while hibernated and only counts active Windows uptime. If the roughly 24-hour collection window also counts uptime rather than wall-clock time, machines that are powered off between sessions will take well over a full calendar day before flushing a report to the upload queue.