Run Local AI on a Copilot+ PC (NPU)

If you're new to the category, start with our explainers on what a Copilot+ PC is and what an NPU is; this guide picks up where those leave off and focuses on the practical question of running AI models yourself.

What a Copilot+ PC is

A Copilot+ PC is Microsoft's label for a class of Windows 11 machines that meet a hardware bar for on-device AI. To qualify, Microsoft requires a compatible processor with an NPU capable of 40+ TOPS (trillions of operations per second), along with a minimum of 16 GB of RAM and a 256 GB SSD, running a recent build of Windows 11. Qualifying silicon spans Qualcomm's Arm-based Snapdragon X series and x86 parts from AMD (Ryzen AI) and Intel (Core Ultra), though what matters for the badge is the specific model's NPU rating — as vendor figures, roughly 45 TOPS for Qualcomm's Snapdragon X Elite and X Plus, up to about 50 TOPS for AMD's Ryzen AI 300 series, and about 47–48 TOPS for Intel's Core Ultra 200V (Lunar Lake). Microsoft's Copilot+ PCs developer guide defines the class the same way — Windows 11 hardware with an NPU able to run at 40+ TOPS — and lists Snapdragon, AMD Ryzen AI 300 series and Intel Core Ultra 200V series among the qualifying silicon.

The point of that spec is to run certain AI features locally rather than in the cloud, which tends to make them faster to respond, more private and gentler on the battery. That's the promise. The rest of this guide is about what it means in practice when you want to run a model, not just use a built-in feature.

What the NPU can and can't run locally

The NPU is designed for efficient, sustained on-device AI. On a Copilot+ PC it powers Windows's built-in features — Windows Studio Effects for camera and microphone during calls, live caption translation, and other on-device capabilities — plus small models that developers can tap through Microsoft's platform. These are exactly the workloads an NPU is built for: modest in size, run often, and valuable precisely because they sip power.

What the NPU is not currently the path to is running large language models at high speed through the tools most enthusiasts reach for. The NPU excels at small, optimised models packaged for it; it is not a drop-in accelerator that any local chatbot app will automatically use. So "the NPU can run local AI" is true for built-in and purpose-built features, and misleading if you picture it powering a large local ChatGPT-style assistant on day one.

Running LLMs on these machines: the reality

Here's the part worth being candid about. As of 2026, the mainstream local-LLM runtimes — Ollama, llama.cpp and LM Studio — do not route their work to the NPU. They run on the integrated GPU or the CPU. So when you install one of these on a Copilot+ PC and load a model, the NPU generally sits idle while the GPU or CPU does the job.

That leads to the second reality: memory bandwidth. A thin Copilot+ laptop shares one pool of system memory across the CPU, GPU and NPU. A discrete desktop graphics card, by contrast, has its own dedicated VRAM with several times the bandwidth. Because generating each token of text streams the model's weights through memory, that bandwidth difference translates fairly directly into a speed difference. Reports of running a small model on an Arm Copilot+ PC via CPU put throughput in the region of a handful of tokens per second, whereas a desktop with a strong discrete GPU can be many times faster on the same model. A Copilot+ PC is efficient and perfectly usable for smaller models, but it isn't going to match a high-bandwidth GPU rig on large ones.

The practical upshot: favour smaller, quantized models on these machines. A 4-bit model in the 7–8B range is a sensible target for a responsive local assistant. For how memory maps to model size, see our guide on how much VRAM you need for local AI, and for the underlying chip trade-offs, GPU vs NPU for AI.

Tools that support NPUs

NPU acceleration for models is real — it just lives, for now, mostly in Microsoft's own platform and in vendor toolkits rather than in the general chat apps. The main routes worth knowing:

• Windows AI features and Foundry Local. Microsoft's Windows AI Foundry, including its Foundry Local runtime, is built on ONNX Runtime and can automatically target the best available hardware — the NPU where a supported chip and model line up, otherwise the GPU or CPU. The Foundry Local architecture overview spells this out: ONNX Runtime is the inference engine, the runtime automatically identifies available hardware and picks the best execution provider, and the CPU provider is always available as a fallback. This is the sanctioned path to on-device models that can use the NPU.
• Built-in Windows AI APIs. Microsoft ships small models, such as its Phi Silica family, that developers can call through Windows AI APIs, running on-device on supported hardware.
• Chip-vendor toolkits and model hubs. Silicon vendors publish NPU-optimised model collections and SDKs validated for their platforms, so an app built against those can use the NPU on that specific chip.

The common thread is that NPU acceleration currently requires software written to target a particular chip's NPU, usually via ONNX Runtime and the right execution provider. The general-purpose "download and chat" tools most people try first don't do that yet — which is why, on those, the GPU or CPU does the work.

Getting started, step by step

1. Confirm your hardware. Check your processor under Settings > System > About, and confirm the NPU appears in Task Manager > Performance. If an NPU entry is listed, Windows sees a supported one — Microsoft notes that for devices with NPUs, Task Manager can be used to view NPU resource usage.
2. Choose the right tool for the job. For NPU-accelerated on-device capability, lean on built-in Windows AI features and Microsoft's Foundry Local. For a general local chatbot, install a runtime such as Ollama or LM Studio — just understand it will use the GPU or CPU, not the NPU.
3. Pick a model that fits your memory. On a thin-and-light Copilot+ PC, favour a small quantized model — a 4-bit 7–8B model is a good responsive choice — rather than trying to squeeze in something large.
4. Set realistic expectations. Expect excellent efficiency on built-in features and modest local-LLM speeds versus a discrete GPU, because everything shares one memory pool and text generation is bound by memory bandwidth.

Our companion walkthrough on running local AI LLMs on Windows covers the general installation flow that applies to Copilot+ PCs as much as any other machine.

Arm vs x86 notes

Copilot+ PCs come in two flavours, and the difference is mostly about software compatibility rather than AI capability per se.

• Arm-based (Snapdragon). These run most modern apps well, some via Windows' emulation for x86 software. A handful of tools, drivers and low-level utilities still assume x86, so it's worth checking that the AI software you want has a native Arm64 build for best performance and compatibility.
• x86 (AMD, Intel). These run legacy x86 software natively without emulation, which can smooth out compatibility for older or niche tools.

For NPU acceleration specifically, what matters is whether the software targets your chip's NPU — support is tied to the platform and toolkit, not simply to whether the CPU is Arm or x86. Either way, general local LLM runtimes will lean on the GPU or CPU today, so the Arm-versus-x86 choice is better decided on overall app compatibility, battery life and price than on local-AI throughput.

Realistic expectations

So what should you actually expect from a Copilot+ PC? A genuinely good experience with efficient, built-in on-device AI features that run quietly and barely touch the battery — that's the category's real strength. Plus the ability to run smaller local models yourself on the GPU or CPU at reasonable, if not blistering, speeds. What you should not expect is desktop-GPU performance on large local models, or that every AI app will light up the NPU. Both are moving targets as software matures, but that's the honest state of play.

If fast local large-model inference is your top priority, a machine with a strong discrete GPU remains the better tool, as our GPU vs NPU comparison explains. If you value portability, all-day battery and slick built-in AI features, a Copilot+ PC is a compelling choice. Browse the Windows AI hub for more on both.