{"article":{"slug":"windows-11-is-collecting-data-on-which-coding-agents-and-developer-tools-you-use","title":"Windows 11 Is Collecting Data on Which Coding Agents and Developer Tools You Use","subtitle":null,"summary":"Reverse-engineering MissionControlAggregator.dll shows Windows 11 records which coding agents (codex, claude, copilot, cursor) and developer tools you run, stores it locally and reports it via optional diagnostic data, which is on by default. Includes how to opt out.","content_type":"research","language":"en","canonical_url":"https://xusheng.dev/posts/windows-coding-agent-telemetry/","author":{"name":"Xusheng Li","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"xusheng.dev","url":"https://xusheng.dev/","listing_slug":null,"listing":null},"topics":[{"name":"privacy","slug":"privacy","url":"https://listedarticles.com/topics/privacy"},{"name":"reverse-engineering","slug":"reverse-engineering","url":"https://listedarticles.com/topics/reverse-engineering"},{"name":"ai-agents","slug":"ai-agents","url":"https://listedarticles.com/topics/ai-agents"}],"about_listings":[],"cover_image_url":null,"license":"all-rights-reserved","word_count":1527,"reading_minutes":7,"published_at":"2026-11-16T05:00:00.000Z","added_at":"2026-11-17T01:56:30.444Z","updated_at":"2026-11-17T01:56:30.444Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/windows-11-is-collecting-data-on-which-coding-agents-and-developer-tools-you-use","markdown_url":"https://listedarticles.com/articles/windows-11-is-collecting-data-on-which-coding-agents-and-developer-tools-you-use.md","example":false,"citation":"Xusheng Li, xusheng.dev. \"Windows 11 Is Collecting Data on Which Coding Agents and Developer Tools You Use.\" 16 Nov 2026. https://xusheng.dev/posts/windows-coding-agent-telemetry/ (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://xusheng.dev/posts/windows-coding-agent-telemetry/"},"body_markdown":"I recently asked AI to help me look through the latest Windows binaries for undocumented features and functionality. Among the leads it turned up, one list immediately caught my attention: coding agents such as `codex.exe`, `claude.exe`, `copilot.exe`, and `cursor.exe`, alongside familiar developer tools such as `python.exe`, `dotnet.exe`, `gcc.exe`, and `code.exe`.\n\nWhy would a Windows system DLL need a list of coding agents and developer tools?\n\nThe names were in `MissionControlAggregator.dll`. I asked the agent to follow the references and dig into what the DLL actually does. That led from a handful of string comparisons to a running Windows component that records which coding agents and developer tools have been used, saves that information locally, and reports it to Windows Diagnostics. And unless you have opted out of the “optional” diagnostic data (which is enabled by default), the data is uploaded to Microsoft.\n\nI [shared the initial finding on X](https://x.com/CrackmesOne/status/2122147747390468384). This post includes more details about the investigation behind it.\n\n## Following the names\n\nOpening the DLL in [Binary Ninja](https://binary.ninja/) made the first lead easy to see. These were explicit executable names embedded in a Windows component:\n\n![Binary Ninja showing coding-agent executable names embedded in MissionControlAggregator.dll](https://xusheng.dev/posts/windows-coding-agent-telemetry/agent-names.jpeg)\n\nFollowing the references showed that the names were used in comparisons. There are four CLI-agent slots checking `copilot.exe`, `claude.exe`, `codex.exe`, and `agy.exe`, with extensionless equivalents on the WSL route. Five desktop-agent slots check `github.exe`, `claude.exe`, `codex.exe`, `cursor.exe`, and `antigravity.exe`.\n\nHere is one of the comparisons against `codex.exe`:\n\n![Binary Ninja showing an exact comparison with codex.exe inside a matcher](https://xusheng.dev/posts/windows-coding-agent-telemetry/codex-matcher.jpeg)\n\nThe compiler-generated C++ names are unwieldy, so I will call these functions **executable-name matchers**. For reference, one related matcher is `std::_Func_impl_no_alloc<<lambda_340dfe7e962ab225b6ac33bc664bd54f>, bool, std::basic_string_view<wchar_t, std::char_traits<wchar_t>> const&, Microsoft::Diagnostics::MissionControlAggregator::Utils::AppType>::_Do_call`. The screenshot shows another lambda instantiation performing the same kind of name comparison.\n\nThe feature guarding the new agent checks has a particularly direct name: `CLICodingAgentUsage`, feature ID `62580080`.\n\nAnd the list extends beyond AI agents. The same component checks for `node.exe`, `python.exe`, `dotnet.exe`, `gcc.exe`, `clang.exe`, `gdb.exe`, `javac.exe`, `devenv.exe`, and `code.exe`, among others. Those checks feed broader developer-tool categories. Some of these checks also verify the publisher: the Node.js slot expects `Node.js Foundation`, Python expects `Python Software Foundation`, and the .NET and Visual Studio slots expect `Microsoft Corporation`. The compiler/debugger group containing GCC and Clang has no additional publisher check in this path.\n\n## Where does the DLL get this information?\n\nThe next question was whether the component scans running processes itself. Following `Aggregator::OnLoad` revealed that it subscribes to existing Windows events instead.\n\nFor Windows programs, it consumes `KernelProcess.AppStateChangeSummary` and `Win32kTraceLogging.AppInteractivitySummary`. These provide application identities that its handlers parse and pass to the matchers. For WSL, it consumes `Microsoft.Windows.Lxss.Manager.Exec` and `ExecCritical`, using the `imageName` field. A regular Windows `codex.exe` can therefore reach the CLI-agent checks through the app-state summary route; this is not limited to Linux programs running inside WSL.\n\nThe relevant flow looks like this:\n\n```\nAggregator::OnLoad\n├─ WSL Exec / ExecCritical\n│  └─ ProcessWslExecEvent → CLI agent matchers\n├─ KernelProcess.AppStateChangeSummary\n│  └─ ProcessAppStateChangeSummaryEvent → CLI agent matchers\n└─ Win32kTraceLogging.AppInteractivitySummary\n   └─ ProcessAppInteractivitySummaryEvent → desktop agent matchers\n\nAggregator::OnRelativeTimerExpire\n└─ MissionControlAggregatorLogging::ReportCohorts<12,4,5>\n   └─ Segments.SubCohorts ETW report\n\nAggregator::OnUnload / intermediate timer\n└─ PersistentState::SaveToDisk\n```\n\nA successful match sets a slot in the aggregator’s state. Later, `ReportCohorts<12,4,5>` turns those slots into bitsets and emits a report named `Segments.SubCohorts`. The numbers correspond to twelve broader tool categories, four CLI agents, and five desktop agents.\n\n[ETW (Event Tracing for Windows)](https://learn.microsoft.com/en-us/windows/win32/etw/event-tracing-portal) is the mechanism carrying that report. In this case, it is a self-describing TraceLogging event. Rather than writing the executable names into every report, the component assigns each category a bit. A set Codex bit means the matching tool was observed during the reporting window.\n\nThe source events also include runtime, time in focus, interaction counters, and resource usage. This component appears to discard those details and record only a bitmap of which agents were observed. The report’s timestamps describe the collection window, not how long each agent was used.\n\nAlthough I found no prompt text or source code in this report, collecting which agents and developer tools someone uses already has significant privacy implications.\n\n## Is it actually running on a normal machine?\n\nStrings and code are a useful lead, but I wanted to see the component running. I checked my Parallels Windows 11 ARM64 VM, build `26200.9974`. Its `MissionControlAggregator.dll` was version `10.0.26100.9818`, and `CLICodingAgentUsage` was already enabled as a service experiment. I had not manually enabled the feature.\n\nDiagTrack, the **Connected User Experiences and Telemetry** service, was also already running with its startup type set to `Automatic`. It starts a separate `AggregatorHost.exe` process, and that process loads the DLL. The following administrative PowerShell commands show the service, its child process, and the loaded module:\n\n```\nPS> Get-Service DiagTrack | Format-Table Name,Status,StartType -AutoSize\n\nName       Status StartType\n----       ------ ---------\nDiagTrack Running Automatic\n\nPS> Get-Process AggregatorHost | Format-Table ProcessName,Id -AutoSize\n\nProcessName      Id\n-----------      --\nAggregatorHost 1500\n\nPS> Get-CimInstance Win32_Service -Filter \"Name='DiagTrack'\" |\n       Format-List Name,State,StartMode,ProcessId\n\nName      : DiagTrack\nState     : Running\nStartMode : Auto\nProcessId : 10148\n\nPS> Get-CimInstance Win32_Process -Filter \"Name='AggregatorHost.exe'\" |\n       Format-List ProcessId,ParentProcessId\n\nProcessId       : 1500\nParentProcessId : 10148\n\nPS> tasklist /m MissionControlAggregator.dll\n\nImage Name                     PID Modules\n========================= ======== ============================================\nAggregatorHost.exe            1500 MissionControlAggregator.dll\n```\n\nThe process IDs connect the pieces: DiagTrack runs in process `10148`, which is the parent of `AggregatorHost.exe`, process `1500`; the module listing places `MissionControlAggregator.dll` inside that child.\n\nThe public ISO’s baseline VM had the coding-agent feature disabled by image default, so the evidence does not support saying that it is active on every Windows installation. On my ARM64 VM, however, the relevant feature and service were active before the test.\n\n## Testing it in practice\n\nTo test the finding in practice, I copied `cmd.exe` to a file named `codex.exe` and ran it in the interactive Windows session. The name alone was enough for the component to recognize it as Codex.\n\nI captured an `AppStateChangeSummary` for the running process from the `KernelProcess` provider (`{2839ff94-8f12-4e1b-82e3-af7af77a450f}`), with `LaunchCount=1` and `TerminateCount=0`. The aggregator’s saved state contained the value `2` in CLI slot 2, the Codex slot. A separate run without an additional ETW trace also set that slot, confirming that detection worked through Windows’ existing diagnostic collection.\n\nThat state is persisted in:\n\n```\nC:\\ProgramData\\Microsoft\\Diagnosis\\AggregatorStorage\\MissionControlAggregator$\n```\n\nThe report normally follows a roughly daily boundary. To capture it immediately, I temporarily moved the saved reporting-window start 25 hours into the past and restarted DiagTrack with a trace listening for the aggregator. The resulting `Segments.SubCohorts` event contained:\n\n```\nProvider: Microsoft.Windows.MissionControlAggregator\nTime:     2026-11-16T12:34:29.125116Z\nVersion:  0.1.5\n\nCliAgentSubCohorts:     4\nDesktopAgentSubCohorts: 0\nFlushedFromSave:       true\n```\n\nThe value `4` is `1 << 2`: the Codex CLI bit. The name had made it through the input summary, the matcher, the persisted state, and the emitted report.\n\nI also tested the developer-tool path separately, using a copy of `cmd.exe` named `gcc.exe`. It set developer-tool slot 3. With optional diagnostic data allowed, I found the resulting `Segments.SubCohorts` event in DiagTrack’s upload queue with `SubCohorts: [8]` (`1 << 3`). This is the compiler/debugger category shared by GCC, Clang, and related tools, rather than a separate bit for each executable.\n\n## Following the report toward Microsoft\n\nAn ETW event by itself would not establish that anything leaves the machine. ETW is used for plenty of local diagnostics. The more revealing question was who was listening to this particular report.\n\nThe VM already had a `Diagtrack-Listener` session subscribed to both ends of the path. These PowerShell queries showed its subscriptions:\n\n```\nGet-EtwTraceProvider -SessionName Diagtrack-Listener `\n  -Guid '{2839ff94-8f12-4e1b-82e3-af7af77a450f}'\n\nGet-EtwTraceProvider -SessionName Diagtrack-Listener `\n  -Guid '{00de11a2-ec06-58e5-1a2b-21bb21dbee4b}'\n```\n\nThe first subscription, for `KernelProcess`, had `MatchAnyKeyword=0x400000000002`, which includes the summary’s `0x400000000000` keyword. The second, for `Microsoft.Windows.MissionControlAggregator`, had `MatchAnyKeyword=0xe00000000000`, which includes the report’s `0x800000000000` keyword. Both had level `255`.\n\nThe subscription showed where the report could go. To check whether Windows actually queued it for transmission, I inspected DiagTrack’s `EventStore.db` and decompressed the JSON batches in its `AsimovEvents` table. This revealed an important condition: the agent-usage report is treated as **optional diagnostic data**.\n\n**When optional diagnostic data is allowed (enabled by default in the US setup I tested), Windows queues the coding-agent usage report for upload to Microsoft.** I verified this by finding the agent event itself in DiagTrack’s upload queue:\n\n```\n{\n  \"name\": \"Microsoft.Windows.MissionControlAggregator.Segments.SubCohorts\",\n  \"ext\": {\n    \"privacy\": { \"isRequired\": false }\n  },\n  \"data\": {\n    \"Version\": \"0.1.5\",\n    \"CliAgentSubCohorts\": [4],\n    \"DesktopAgentSubCohorts\": [0],\n    \"FlushedFromSave\": true\n  }\n}\n```\n\nI checked this with a clean installation of Windows 11 Home ARM64 using the latest official ISO, with the region set to the United States. Before changing any privacy settings, the **Diagnostic data** toggle was already enabled and labeled **Include Optional**. After completing setup with those defaults, `AllowTelemetry` was `3`, confirming that optional diagnostic data was enabled.\n\n![Windows setup with United States region: Diagnostic data defaults to Include Optional](https://xusheng.dev/posts/windows-coding-agent-telemetry/us-optional-diagnostics-default.png)\n\nOptional diagnostic data is therefore enabled by default, at least in the US setup I tested. If you did not opt out of it during installation or disable optional diagnostic data later, it is still enabled and your coding agent usage data is being uploaded. You can decline optional diagnostics during setup or turn off **Send optional diagnostic data** later under **Settings → Privacy & security → Diagnostics & feedback**. Microsoft’s [diagnostics and privacy guide](https://support.microsoft.com/en-us/windows/privacy/diagnostics-feedback-and-privacy-in-windows) explains how to change it.\n\n\n*Originally published at xusheng.dev under CC BY-NC 4.0.*\n","body_html":"<p>I recently asked AI to help me look through the latest Windows binaries for undocumented features and functionality. Among the leads it turned up, one list immediately caught my attention: coding agents such as <code>codex.exe</code>, <code>claude.exe</code>, <code>copilot.exe</code>, and <code>cursor.exe</code>, alongside familiar developer tools such as <code>python.exe</code>, <code>dotnet.exe</code>, <code>gcc.exe</code>, and <code>code.exe</code>.</p>\n<p>Why would a Windows system DLL need a list of coding agents and developer tools?</p>\n<p>The names were in <code>MissionControlAggregator.dll</code>. I asked the agent to follow the references and dig into what the DLL actually does. That led from a handful of string comparisons to a running Windows component that records which coding agents and developer tools have been used, saves that information locally, and reports it to Windows Diagnostics. And unless you have opted out of the “optional” diagnostic data (which is enabled by default), the data is uploaded to Microsoft.</p>\n<p>I <a href=\"https://x.com/CrackmesOne/status/2122147747390468384\" rel=\"nofollow ugc noopener\">shared the initial finding on X</a>. This post includes more details about the investigation behind it.</p>\n<h2 id=\"following-the-names\">Following the names</h2>\n<p>Opening the DLL in <a href=\"https://binary.ninja/\" rel=\"nofollow ugc noopener\">Binary Ninja</a> made the first lead easy to see. These were explicit executable names embedded in a Windows component:</p>\n<figure><img src=\"https://xusheng.dev/posts/windows-coding-agent-telemetry/agent-names.jpeg\" alt=\"Binary Ninja showing coding-agent executable names embedded in MissionControlAggregator.dll\" loading=\"lazy\" decoding=\"async\" referrerpolicy=\"no-referrer\" /></figure>\n<p>Following the references showed that the names were used in comparisons. There are four CLI-agent slots checking <code>copilot.exe</code>, <code>claude.exe</code>, <code>codex.exe</code>, and <code>agy.exe</code>, with extensionless equivalents on the WSL route. Five desktop-agent slots check <code>github.exe</code>, <code>claude.exe</code>, <code>codex.exe</code>, <code>cursor.exe</code>, and <code>antigravity.exe</code>.</p>\n<p>Here is one of the comparisons against <code>codex.exe</code>:</p>\n<figure><img src=\"https://xusheng.dev/posts/windows-coding-agent-telemetry/codex-matcher.jpeg\" alt=\"Binary Ninja showing an exact comparison with codex.exe inside a matcher\" loading=\"lazy\" decoding=\"async\" referrerpolicy=\"no-referrer\" /></figure>\n<p>The compiler-generated C++ names are unwieldy, so I will call these functions <strong>executable-name matchers</strong>. For reference, one related matcher is <code>std::_Func_impl_no_alloc&lt;&lt;lambda_340dfe7e962ab225b6ac33bc664bd54f&gt;, bool, std::basic_string_view&lt;wchar_t, std::char_traits&lt;wchar_t&gt;&gt; const&amp;, Microsoft::Diagnostics::MissionControlAggregator::Utils::AppType&gt;::_Do_call</code>. The screenshot shows another lambda instantiation performing the same kind of name comparison.</p>\n<p>The feature guarding the new agent checks has a particularly direct name: <code>CLICodingAgentUsage</code>, feature ID <code>62580080</code>.</p>\n<p>And the list extends beyond AI agents. The same component checks for <code>node.exe</code>, <code>python.exe</code>, <code>dotnet.exe</code>, <code>gcc.exe</code>, <code>clang.exe</code>, <code>gdb.exe</code>, <code>javac.exe</code>, <code>devenv.exe</code>, and <code>code.exe</code>, among others. Those checks feed broader developer-tool categories. Some of these checks also verify the publisher: the Node.js slot expects <code>Node.js Foundation</code>, Python expects <code>Python Software Foundation</code>, and the .NET and Visual Studio slots expect <code>Microsoft Corporation</code>. The compiler/debugger group containing GCC and Clang has no additional publisher check in this path.</p>\n<h2 id=\"where-does-the-dll-get-this-information\">Where does the DLL get this information?</h2>\n<p>The next question was whether the component scans running processes itself. Following <code>Aggregator::OnLoad</code> revealed that it subscribes to existing Windows events instead.</p>\n<p>For Windows programs, it consumes <code>KernelProcess.AppStateChangeSummary</code> and <code>Win32kTraceLogging.AppInteractivitySummary</code>. These provide application identities that its handlers parse and pass to the matchers. For WSL, it consumes <code>Microsoft.Windows.Lxss.Manager.Exec</code> and <code>ExecCritical</code>, using the <code>imageName</code> field. A regular Windows <code>codex.exe</code> can therefore reach the CLI-agent checks through the app-state summary route; this is not limited to Linux programs running inside WSL.</p>\n<p>The relevant flow looks like this:</p>\n<pre><code>Aggregator::OnLoad\n├─ WSL Exec / ExecCritical\n│  └─ ProcessWslExecEvent → CLI agent matchers\n├─ KernelProcess.AppStateChangeSummary\n│  └─ ProcessAppStateChangeSummaryEvent → CLI agent matchers\n└─ Win32kTraceLogging.AppInteractivitySummary\n   └─ ProcessAppInteractivitySummaryEvent → desktop agent matchers\n\nAggregator::OnRelativeTimerExpire\n└─ MissionControlAggregatorLogging::ReportCohorts&lt;12,4,5&gt;\n   └─ Segments.SubCohorts ETW report\n\nAggregator::OnUnload / intermediate timer\n└─ PersistentState::SaveToDisk</code></pre>\n<p>A successful match sets a slot in the aggregator’s state. Later, <code>ReportCohorts&lt;12,4,5&gt;</code> turns those slots into bitsets and emits a report named <code>Segments.SubCohorts</code>. The numbers correspond to twelve broader tool categories, four CLI agents, and five desktop agents.</p>\n<p><a href=\"https://learn.microsoft.com/en-us/windows/win32/etw/event-tracing-portal\" rel=\"nofollow ugc noopener\">ETW (Event Tracing for Windows)</a> is the mechanism carrying that report. In this case, it is a self-describing TraceLogging event. Rather than writing the executable names into every report, the component assigns each category a bit. A set Codex bit means the matching tool was observed during the reporting window.</p>\n<p>The source events also include runtime, time in focus, interaction counters, and resource usage. This component appears to discard those details and record only a bitmap of which agents were observed. The report’s timestamps describe the collection window, not how long each agent was used.</p>\n<p>Although I found no prompt text or source code in this report, collecting which agents and developer tools someone uses already has significant privacy implications.</p>\n<h2 id=\"is-it-actually-running-on-a-normal-machine\">Is it actually running on a normal machine?</h2>\n<p>Strings and code are a useful lead, but I wanted to see the component running. I checked my Parallels Windows 11 ARM64 VM, build <code>26200.9974</code>. Its <code>MissionControlAggregator.dll</code> was version <code>10.0.26100.9818</code>, and <code>CLICodingAgentUsage</code> was already enabled as a service experiment. I had not manually enabled the feature.</p>\n<p>DiagTrack, the <strong>Connected User Experiences and Telemetry</strong> service, was also already running with its startup type set to <code>Automatic</code>. It starts a separate <code>AggregatorHost.exe</code> process, and that process loads the DLL. The following administrative PowerShell commands show the service, its child process, and the loaded module:</p>\n<pre><code>PS&gt; Get-Service DiagTrack | Format-Table Name,Status,StartType -AutoSize\n\nName       Status StartType\n----       ------ ---------\nDiagTrack Running Automatic\n\nPS&gt; Get-Process AggregatorHost | Format-Table ProcessName,Id -AutoSize\n\nProcessName      Id\n-----------      --\nAggregatorHost 1500\n\nPS&gt; Get-CimInstance Win32_Service -Filter &quot;Name=&#39;DiagTrack&#39;&quot; |\n       Format-List Name,State,StartMode,ProcessId\n\nName      : DiagTrack\nState     : Running\nStartMode : Auto\nProcessId : 10148\n\nPS&gt; Get-CimInstance Win32_Process -Filter &quot;Name=&#39;AggregatorHost.exe&#39;&quot; |\n       Format-List ProcessId,ParentProcessId\n\nProcessId       : 1500\nParentProcessId : 10148\n\nPS&gt; tasklist /m MissionControlAggregator.dll\n\nImage Name                     PID Modules\n========================= ======== ============================================\nAggregatorHost.exe            1500 MissionControlAggregator.dll</code></pre>\n<p>The process IDs connect the pieces: DiagTrack runs in process <code>10148</code>, which is the parent of <code>AggregatorHost.exe</code>, process <code>1500</code>; the module listing places <code>MissionControlAggregator.dll</code> inside that child.</p>\n<p>The public ISO’s baseline VM had the coding-agent feature disabled by image default, so the evidence does not support saying that it is active on every Windows installation. On my ARM64 VM, however, the relevant feature and service were active before the test.</p>\n<h2 id=\"testing-it-in-practice\">Testing it in practice</h2>\n<p>To test the finding in practice, I copied <code>cmd.exe</code> to a file named <code>codex.exe</code> and ran it in the interactive Windows session. The name alone was enough for the component to recognize it as Codex.</p>\n<p>I captured an <code>AppStateChangeSummary</code> for the running process from the <code>KernelProcess</code> provider (<code>{2839ff94-8f12-4e1b-82e3-af7af77a450f}</code>), with <code>LaunchCount=1</code> and <code>TerminateCount=0</code>. The aggregator’s saved state contained the value <code>2</code> in CLI slot 2, the Codex slot. A separate run without an additional ETW trace also set that slot, confirming that detection worked through Windows’ existing diagnostic collection.</p>\n<p>That state is persisted in:</p>\n<pre><code>C:\\ProgramData\\Microsoft\\Diagnosis\\AggregatorStorage\\MissionControlAggregator$</code></pre>\n<p>The report normally follows a roughly daily boundary. To capture it immediately, I temporarily moved the saved reporting-window start 25 hours into the past and restarted DiagTrack with a trace listening for the aggregator. The resulting <code>Segments.SubCohorts</code> event contained:</p>\n<pre><code>Provider: Microsoft.Windows.MissionControlAggregator\nTime:     2026-11-16T12:34:29.125116Z\nVersion:  0.1.5\n\nCliAgentSubCohorts:     4\nDesktopAgentSubCohorts: 0\nFlushedFromSave:       true</code></pre>\n<p>The value <code>4</code> is <code>1 &lt;&lt; 2</code>: the Codex CLI bit. The name had made it through the input summary, the matcher, the persisted state, and the emitted report.</p>\n<p>I also tested the developer-tool path separately, using a copy of <code>cmd.exe</code> named <code>gcc.exe</code>. It set developer-tool slot 3. With optional diagnostic data allowed, I found the resulting <code>Segments.SubCohorts</code> event in DiagTrack’s upload queue with <code>SubCohorts: [8]</code> (<code>1 &lt;&lt; 3</code>). This is the compiler/debugger category shared by GCC, Clang, and related tools, rather than a separate bit for each executable.</p>\n<h2 id=\"following-the-report-toward-microsoft\">Following the report toward Microsoft</h2>\n<p>An ETW event by itself would not establish that anything leaves the machine. ETW is used for plenty of local diagnostics. The more revealing question was who was listening to this particular report.</p>\n<p>The VM already had a <code>Diagtrack-Listener</code> session subscribed to both ends of the path. These PowerShell queries showed its subscriptions:</p>\n<pre><code>Get-EtwTraceProvider -SessionName Diagtrack-Listener `\n  -Guid &#39;{2839ff94-8f12-4e1b-82e3-af7af77a450f}&#39;\n\nGet-EtwTraceProvider -SessionName Diagtrack-Listener `\n  -Guid &#39;{00de11a2-ec06-58e5-1a2b-21bb21dbee4b}&#39;</code></pre>\n<p>The first subscription, for <code>KernelProcess</code>, had <code>MatchAnyKeyword=0x400000000002</code>, which includes the summary’s <code>0x400000000000</code> keyword. The second, for <code>Microsoft.Windows.MissionControlAggregator</code>, had <code>MatchAnyKeyword=0xe00000000000</code>, which includes the report’s <code>0x800000000000</code> keyword. Both had level <code>255</code>.</p>\n<p>The subscription showed where the report could go. To check whether Windows actually queued it for transmission, I inspected DiagTrack’s <code>EventStore.db</code> and decompressed the JSON batches in its <code>AsimovEvents</code> table. This revealed an important condition: the agent-usage report is treated as <strong>optional diagnostic data</strong>.</p>\n<p><strong>When optional diagnostic data is allowed (enabled by default in the US setup I tested), Windows queues the coding-agent usage report for upload to Microsoft.</strong> I verified this by finding the agent event itself in DiagTrack’s upload queue:</p>\n<pre><code>{\n  &quot;name&quot;: &quot;Microsoft.Windows.MissionControlAggregator.Segments.SubCohorts&quot;,\n  &quot;ext&quot;: {\n    &quot;privacy&quot;: { &quot;isRequired&quot;: false }\n  },\n  &quot;data&quot;: {\n    &quot;Version&quot;: &quot;0.1.5&quot;,\n    &quot;CliAgentSubCohorts&quot;: [4],\n    &quot;DesktopAgentSubCohorts&quot;: [0],\n    &quot;FlushedFromSave&quot;: true\n  }\n}</code></pre>\n<p>I checked this with a clean installation of Windows 11 Home ARM64 using the latest official ISO, with the region set to the United States. Before changing any privacy settings, the <strong>Diagnostic data</strong> toggle was already enabled and labeled <strong>Include Optional</strong>. After completing setup with those defaults, <code>AllowTelemetry</code> was <code>3</code>, confirming that optional diagnostic data was enabled.</p>\n<figure><img src=\"https://xusheng.dev/posts/windows-coding-agent-telemetry/us-optional-diagnostics-default.png\" alt=\"Windows setup with United States region: Diagnostic data defaults to Include Optional\" loading=\"lazy\" decoding=\"async\" referrerpolicy=\"no-referrer\" /></figure>\n<p>Optional diagnostic data is therefore enabled by default, at least in the US setup I tested. If you did not opt out of it during installation or disable optional diagnostic data later, it is still enabled and your coding agent usage data is being uploaded. You can decline optional diagnostics during setup or turn off <strong>Send optional diagnostic data</strong> later under <strong>Settings → Privacy &amp; security → Diagnostics &amp; feedback</strong>. Microsoft’s <a href=\"https://support.microsoft.com/en-us/windows/privacy/diagnostics-feedback-and-privacy-in-windows\" rel=\"nofollow ugc noopener\">diagnostics and privacy guide</a> explains how to change it.</p>\n<p><em>Originally published at xusheng.dev under CC BY-NC 4.0.</em></p>","headings":[{"level":2,"text":"Following the names","id":"following-the-names"},{"level":2,"text":"Where does the DLL get this information?","id":"where-does-the-dll-get-this-information"},{"level":2,"text":"Is it actually running on a normal machine?","id":"is-it-actually-running-on-a-normal-machine"},{"level":2,"text":"Testing it in practice","id":"testing-it-in-practice"},{"level":2,"text":"Following the report toward Microsoft","id":"following-the-report-toward-microsoft"}]}}