An AI Laptop’s NPU Only Matters If Your Apps Can Use It

Consider one ordinary desk workflow: joining a Microsoft Teams call with background blur, generating a transcript, asking Copilot for a meeting summary, then using Ollama to rewrite the notes with a local language model. Advertisements may describe all four tasks as AI. They do not necessarily run on the same hardware, or even on the laptop.

On a compatible Windows PC, Windows Studio Effects can send camera features such as background blur, automatic framing and eye-contact correction to the neural processing unit, or NPU, a low-power chip designed to execute machine-learning operations. The Teams transcript and Copilot summary depend on Microsoft’s online services. Ollama generally runs supported models through the CPU or GPU rather than a generic Windows NPU.

The NPU earns its keep during the call because it can process the camera stream without keeping the more power-hungry graphics processor busy. It does little for the other steps. That distinction is more useful than the AI badge on the laptop lid.

TOPS is not a universal speed rating

Laptop specifications usually describe NPU performance in TOPS, meaning trillions of operations per second. Microsoft’s Copilot+ PC hardware requirements set a threshold of 40 TOPS for the NPU, alongside at least 16GB of memory and 256GB of storage. Intel, AMD, Qualcomm and Apple also publish machine-learning performance figures for their laptop processors.

TOPS can help compare chips inside a narrowly defined workload, but the number does not tell you how quickly a particular application will summarize a document, generate an image or remove video noise. Vendors may calculate it at different numerical precisions, and real models contain operations that the NPU may not support efficiently. Memory bandwidth, software drivers and the time spent moving data can matter as much as the arithmetic ceiling.

Most important, an application must target the NPU. The developer packages or converts a model for a supported runtime, which is the software layer that assigns operations to available processors. If the runtime cannot place part of the model on the NPU, it may send those operations to the CPU or GPU. Some applications instead ignore the NPU entirely because their existing GPU path works on more computers.

A 50 TOPS NPU therefore does not make every AI workload faster than a 40 TOPS one. If the note-rewriting application uses the GPU, both NPUs sit idle.

The features most likely to use an NPU

Today’s clearest consumer NPU workloads are bounded, continuous jobs that use relatively small models. Camera framing, background effects, gaze correction, microphone noise suppression and some accessibility features fit that pattern. They process a predictable stream of audio or video, and saving power matters because the feature may run throughout a call.

Microsoft documents Windows Studio Effects and supported Copilot+ experiences around compatible NPUs. Windows Live Captions can also translate supported audio on qualifying Copilot+ PCs, with processing performed locally. Availability still depends on the processor, language and Windows configuration, so seeing “AI PC” in a retailer listing is not enough.

Apple takes a less visible approach. Applications built with Core ML, Apple’s framework for running machine-learning models on its devices, can distribute work across the CPU, GPU and Neural Engine. The framework and operating system choose the execution path based on model compatibility and available hardware. A Mac application saying it uses Core ML does not guarantee that every layer of its model stays on the Neural Engine.

The common thread is integration. The operating system vendor controls the model, runtime and supported hardware, making it easier to produce a dependable NPU path. Third-party Windows applications face several processor families and software stacks, although Microsoft’s Windows ML and ONNX Runtime tooling is intended to reduce that fragmentation.

Return to the Teams call. Windows Studio Effects has a defined NPU route because Microsoft controls that part of the camera pipeline. Installing a laptop with a higher advertised TOPS figure will not force an unrelated transcription application onto the same route.

Many visible AI features still use the GPU or cloud

Generative applications often favor the GPU, whose parallel processors have mature support across tools and model frameworks. Local image generators, language-model interfaces and creative applications can use integrated graphics or a discrete GPU, provided the software supports that hardware and enough memory is available. A discrete GPU may finish demanding work faster, but it adds cost, heat and battery drain.

Ollama’s published hardware support focuses on CPU execution and GPU acceleration through platforms including NVIDIA CUDA, AMD support and Apple Metal. That makes it a poor reason, by itself, to pay extra for a stronger Windows NPU. The local rewrite at the end of the desk workflow will usually care more about the GPU, its supported backend and available memory.

Cloud features avoid those local constraints by uploading a prompt, file, transcript or compressed representation to remote servers. Microsoft Copilot, ChatGPT and many application-specific assistants work this way for at least some tasks. The laptop needs enough performance to run the interface, but the server performs the expensive inference, which is the step where a trained model generates an output.

Cloud execution can provide access to larger models without adding laptop heat or memory pressure. It also introduces network latency, service limits, subscription costs and a data-handling decision. An NPU does not remove those conditions. A cloud assistant remains a cloud assistant when opened on an AI PC.

Some products mix paths. They may remove microphone noise locally, upload the cleaned audio for transcription and then use another server model for the summary. Checking only whether the application “uses AI” hides the part of the workflow that determines privacy, offline behavior and performance.

Memory sets the practical limit for local models

Local model buyers should examine memory before TOPS. A model stores billions of parameters, the numerical values learned during training, and those weights must fit somewhere accessible to the processor. Quantization reduces each parameter’s precision so the model consumes less memory, usually with some risk of reduced output quality.

The weights are only the starting allocation. The application needs memory for its runtime, temporary calculations and the key-value cache, a working store that grows as a language model keeps more of the conversation in context. The operating system, browser and video-call software are competing for the same capacity.

On a laptop with integrated graphics, the GPU usually shares system memory rather than carrying a large dedicated pool. Apple silicon also uses a unified memory design, allowing processors to access one shared pool, but installed capacity remains a hard limit and cannot be upgraded later. A discrete GPU has its own video memory, which can help isolate model workloads, although a model that exceeds that capacity may spill work elsewhere or fail to load under the chosen application.

This is why Microsoft’s 16GB Copilot+ minimum should not be read as a broad recommendation for local language models. It qualifies a machine for Microsoft’s specified experiences. It does not promise that a large model, a browser full of tabs and the Teams call will coexist comfortably.

In the desk workflow, the NPU can keep the camera effect efficient while Ollama pressures shared memory through the GPU. If the local model no longer fits, the application may move more work to the CPU, run slowly, reject the model or require a smaller quantized version. The advertised NPU figure does not create additional RAM.

A compatibility-first way to buy

Start with the exact feature, not the processor label. Write down the application and action you expect to use, such as “Windows Studio Effects background blur during Teams calls” or “run a local model through Ollama.” “AI work” is too broad to produce a useful hardware choice.

Next, find the application vendor’s hardware documentation. Look for a named runtime or processor path: NPU, Neural Engine, CUDA, Metal, integrated GPU, discrete GPU or cloud. If the page mentions only “hardware acceleration,” check its supported-device table or release notes. Absence of a documented NPU path should count as no NPU support for the purchase decision, even if future support seems plausible.

Then identify the fallback. An NPU feature that moves cleanly to the GPU on an older laptop may still work, with a battery or performance penalty. A feature tied to Copilot+ hardware may be unavailable. A cloud feature may work on almost any recent laptop but stop when the connection disappears.

These are different buying risks.

Match memory to the workload after accounting for everything open beside it. For local models, use the model publisher’s file size and the application’s memory guidance rather than parameter count alone, then leave room for the operating system and context cache. Buyers choosing between more RAM and a modestly higher NPU rating should usually take the memory when local generation is the priority.

Finally, test the actual workflow during the return period. On Windows systems that expose it, Task Manager can show NPU, GPU, CPU and memory activity while the feature runs. The graph is not a benchmark, but it can reveal that the expensive NPU remains flat while the GPU fills its memory or the network carries the job away. Apple does not expose an equally direct consumer-facing Neural Engine utilization graph, so developer documentation matters more there.

For the desk case, the buying result is straightforward. A supported NPU is worthwhile for efficient camera effects and qualifying on-device Windows features. More RAM and a well-supported GPU matter more for Ollama. The Copilot meeting summary should be evaluated by service availability, privacy terms and subscription requirements, not laptop TOPS.

Questions people ask

Do all Copilot+ PC features run on the NPU?

No. Copilot+ identifies Windows PCs that meet Microsoft’s hardware requirements, including a qualifying NPU, but individual features can use the NPU, another local processor or Microsoft’s cloud. Check the documentation for the specific feature rather than treating the label as an execution guarantee.

Is a higher

TOPS number always better for AI applications?

Only when the application supports that NPU and can use the additional capacity. A higher figure will not accelerate a cloud request or an application routed through the GPU. Runtime support, memory bandwidth and model compatibility can prevent the advertised difference from appearing in daily use.

How much

RAM should a laptop have for local AI models?

There is no single requirement because model weights, quantization, context length and other open applications all consume memory. Start with the model and application vendor’s guidance, then allow headroom for the operating system. Treat 16GB as a platform minimum on qualifying Copilot+ PCs, not a guarantee for demanding local models.

Can

I verify that an application is using my laptop’s NPU?

On supported Windows hardware, run the feature and inspect the NPU graph in Task Manager alongside CPU, GPU, memory and network activity. Also check the application vendor’s supported-hardware documentation. A low NPU graph does not prove a fault; the application may be using another processor or sending the work to the cloud.