Task Manager AI Workload Visibility: NPU Monitoring for IT Pros

A user calls the helpdesk: their Copilot+ PC feels sluggish. CPU is at 12%. Memory is fine. GPU is idle. But something is clearly working hard — the fan is spinning and the battery is draining fast. The culprit is the NPU, and until recently Task Manager gave you nothing to go on.

Windows 11 24H2 changes that. Task Manager now shows NPU utilisation per process, cumulative NPU time in App History, and a dedicated NPU panel in the Performance tab — the same depth you get for CPU and GPU, extended to the AI accelerator. This post is the complete reference: every tab, every column, every PowerShell counter, and every policy you can push via Intune or Group Policy.

Step 0 — Confirm the device qualifies

Before you spend time looking for an NPU tab that isn't there, run this one-liner to confirm the device has a qualifying NPU driver registered with Windows:

# Check if this device has an NPU registered via DirectX
Get-WmiObject -Class Win32_VideoController |
    Select-Object Name, DriverVersion, Status

# Also check for the NPU-specific PnP device
Get-PnpDevice | Where-Object { $_.FriendlyName -like "*NPU*" -or $_.FriendlyName -like "*Neural*" } |
    Select-Object FriendlyName, Status, InstanceId

On a qualifying device you will see an entry like Qualcomm(R) AI Stack Neural Processing SDK or Intel Neural Processing Unit with status OK. If this returns nothing, the device does not have an NPU Windows recognises — Task Manager will not show an NPU tab regardless of what Windows version is installed.

The Performance tab — NPU panel

Open Task Manager (Ctrl+Shift+Esc), switch to the Performance tab. On a qualifying device the left sidebar lists: CPU, Memory, Disk, Wi-Fi, Ethernet, GPU — and at the bottom, NPU. Click it.

The NPU panel shows four live counters updated every second:

• NPU utilisation % — aggregate across all NPU compute engines. This is the number to watch. Idle Copilot+ PC = 0–5%. Recall indexing spike = 60–80% for 5–15 seconds. Active Windows Studio Effects (background blur during a Teams call) = 8–15% continuous.
• Dedicated memory — NPU-local SRAM or eSRAM in MB. On Qualcomm X Elite this is typically 32–64 MB at rest, up to 512 MB when a large model is loaded.
• Shared memory — system RAM mapped into the NPU driver's address space. Grows when models are loaded that don't fit in dedicated memory. High shared memory with low dedicated memory = the NPU is borrowing system RAM, which will affect CPU memory bandwidth.
• Inferences/sec — throughput counter. Units depend on the loaded model — this is not directly comparable across different workloads, but it's useful for spotting when inference rate drops unexpectedly (a sign of thermal throttling or driver issue).

The Processes tab — NPU column

The Processes tab NPU column shows you which process is eating that 22% right now. Right-click any column header → select NPU from the list. The column appears on the right side of the table, showing each process's share of NPU utilisation as a percentage of total NPU capacity.

The key processes to know on a managed Copilot+ PC:

• AIXHost.exe — the Windows AI platform host. This is Recall's indexing engine and the runtime for other Windows AI Platform features. If this is the only high-NPU process, it's Recall doing a snapshot index pass. Normal and expected unless you've disabled Recall via policy.
• copilot.exe — the Copilot sidebar. Uses the NPU when generating a response. Should drop to 0% when the sidebar is idle.
• Taskhostw.exe or runtimebroker.exe with high NPU — usually a UWP app using WinML in the background. Check the App History tab to find the culprit app name.
• Any process you don't recognise at 20%+ NPU — investigate with the PowerShell PID query in the next section before assuming it's malicious. Most high-NPU processes are legitimate AI features, but the PID correlation query gives you the full process path.

The App History tab — cumulative NPU Time

The App History tab answers a different question: not "who is using the NPU right now" but "which apps have used the most NPU time over the past week". Right-click any column header and enable NPU time. The value shown is the cumulative wall-clock time the app spent running inference — formatted as hours:minutes.

This is the right tab for capacity planning and user behaviour analysis. An app showing 2:30 NPU time in a day is running inference almost constantly. Use this to identify which apps are driving fleet NPU load before you roll out a new app to all devices.

To reset the App History counter, go to Options > Hide History then re-enable it. This clears all cumulative counters including NPU time — useful before a clean measurement window.

PowerShell: real-time NPU counters via PDH

The NPU is exposed through the GPU Engine performance counter category — the same category that covers GPU compute engines. On Qualcomm Snapdragon X, the NPU engine type is engtype_Video. On Intel Core Ultra 200V it may appear as engtype_Compute depending on driver version. Use this script to discover what's available on a specific device:

# Step 1: Find all GPU Engine counter instances on this device
# On Copilot+ PCs you will see NPU engine types in the output
(Get-Counter -ListSet "GPU Engine").PathsWithInstances |
    Where-Object { $_ -like "*Utilization*" } |
    ForEach-Object { $_ -replace "\\.*?\GPU Engine(" , "" -replace ").*", "" } |
    Select-Object -Unique |
    Sort-Object

# Expected output on Qualcomm Snapdragon X Elite:
# pid_1234_luid_0x00000000_0x00012345_phys_0_eng_0_engtype_3D
# pid_1234_luid_0x00000000_0x00012345_phys_0_eng_1_engtype_Video   <-- NPU
# pid_1234_luid_0x00000000_0x00012345_phys_0_eng_2_engtype_VideoDecode

Once you've confirmed the engine type on the target device, use this script to sample live NPU utilisation and rank processes by usage:

# Sample NPU utilisation per process — run in an elevated PowerShell window
# Adjust engtype_Video to engtype_Compute for Intel NPUs if needed
$counterPath = "GPU Engine(*engtype_Video*)Utilization Percentage"

$sample = Get-Counter -Counter $counterPath -SampleInterval 1 -MaxSamples 5

$results = $sample.CounterSamples |
    Where-Object { $_.CookedValue -gt 0 } |
    Group-Object InstanceName |
    ForEach-Object {
        $avgUtil = ($_.Group | Measure-Object CookedValue -Average).Average
        $pidMatch = $_.Name -match 'pid_(d+)'
        $pid = if ($pidMatch) { [int]$Matches[1] } else { 0 }
        $procName = if ($pid -gt 0) {
            (Get-Process -Id $pid -ErrorAction SilentlyContinue).Name
        } else { 'unknown' }
        [PSCustomObject]@{
            Process  = $procName
            PID      = $pid
            NPU_Pct  = [math]::Round($avgUtil, 1)
            Instance = $_.Name
        }
    } |
    Sort-Object NPU_Pct -Descending

$results | Format-Table Process, PID, NPU_Pct -AutoSize

Expected output on a device with Recall running in the background:

Registry: showing the NPU tab on managed devices

On some enterprise builds — especially devices that received a fresh Windows image without running Windows Update post-deployment — the NPU tab may not appear even on qualifying hardware. This is because the Task Manager feature flag is controlled by a registry value that requires the NPU driver to write it during first-run setup. If imaging bypassed that setup, the value may be absent.

Check the current state on a device with:

$path = "HKLM:SOFTWAREMicrosoftWindows NTCurrentVersionTaskManager"
Get-ItemProperty -Path $path -ErrorAction SilentlyContinue |
    Select-Object ShowNpuInPerfTab, ShowNpuInProcesses

If the values are absent or set to 0, set them with:

Group Policy and CSP reference

The table below covers every AI-workload-related Task Manager and Windows AI policy available via Group Policy and Intune. The NPU visibility registry values do not yet have a native CSP — deploy them via Remediation script. The Windows AI policies (Recall, Studio Effects) do have CSP paths and can be set in the Intune Settings Catalog.

What to watch: baselines for a managed fleet

The goal is not zero NPU utilisation — these features are there for a reason. The goal is knowing what normal looks like on your fleet so you can spot the abnormal. Here are the baselines to establish before you have a problem:

• Idle desktop, Recall enabled, no video call: 0–5% NPU. If you consistently see 15%+ at idle, something is indexing more than expected — check the Recall snapshot schedule in Settings.
• Teams call with Studio Effects background blur: 8–15% sustained. This is expected and normal.
• Recall index pass after login: 60–80% for 10–15 seconds, then drops. Normal on first login of the day when Recall processes the overnight screenshot backlog.
• Copilot generating a response: 30–60% for the duration of the response (typically 5–30 seconds), then back to baseline.
• Sustained 90%+ NPU from an unknown process: investigate immediately using the PowerShell PID query. Get the full process path with (Get-Process -Id $pid).Path.

Run the PDH sampling script on a representative device for 30 minutes during a typical working session and export the output to CSV for your baseline record. When users report battery drain complaints on Copilot+ PCs, NPU utilisation data is now part of your standard diagnostic toolkit.

Official Microsoft documentation

• Task Manager features for visibility into AI workloads — Windows IT Pro Blog
• Policy CSP — WindowsAI (DisableAIDataAnalysis) — Microsoft Learn
• What is an NPU? — Windows AI documentation
• Get started with Windows Machine Learning (WinML) — Microsoft Learn