NVIDIA RTX Spark: Code, Test and Deploy on One Machine With Local Coding Agents

NVIDIA's developer blog now describes RTX Spark as a place to "code, test, and deploy on one machine": a Windows PC platform with up to 128GB of unified memory that runs local coding agents, fine-tunes models and compiles code without leaving the desktop. Laptops are available now, and small desktops meant for always-on agents follow in November, per NVIDIA.

If you have followed our earlier coverage of PAIR and Hermes Desktop on RTX Spark, this post is the developer-workflow follow-up: what the hardware is, what NVIDIA says it gains, which agents and models are supported, and where you should be skeptical.

TL;DR: the questions developers ask first

What is RTX Spark, exactly?

NVIDIA calls RTX Spark its platform for AI development on Windows. The silicon is the GB10 system-on-a-chip, which combines a Grace Arm CPU with a Blackwell GPU and shares one large memory pool. That shared pool is the headline: models that would not fit in a typical laptop GPU's dedicated VRAM can sit entirely in memory, which matters for the large mixture-of-experts models now common in open-weight releases.

NVIDIA's argument is that development work has shifted from CPU-bound to GPU-bound: agent inference, app testing, fine-tuning and even builds lean on the GPU. A single machine that does all of it removes the usual loop of writing code locally and pushing to a cloud box to test.

Because the GPU is NVIDIA's, code tested locally can run on what NVIDIA describes as roughly 150 million RTX PCs in use and on most NVIDIA-based clouds. That portability claim is the real selling point versus an Arm laptop with a different accelerator.

The performance claims, and how to read them

Bar chart comparing RTX Spark with Intel Core Ultra X9 388H: 4.6x coding agents, 2.7x fine-tuning, 1.8x code compilation Image: NVIDIA

NVIDIA compares RTX Spark with an Intel Core Ultra X9 388H (Panther Lake, 12Xe graphics):

Three cautions. First, the baseline is an integrated-graphics laptop chip, not a discrete-GPU workstation, so the gap is the easy one to win. Second, these are NVIDIA-run numbers; we found no independent reproduction at the time of writing. Third, the 4.6x agent figure depends on one model and one benchmark. Compare with the dedicated-silicon speeds we covered in Cerebras running Qwen3.8 27B at 1,500 tokens per second: local unified-memory hardware trades raw speed for privacy, cost control and always-available inference.

Which coding agents run locally?

NVIDIA lists several, and describes three kinds of improvements: optimized recipes for deploying local models, OS-level sandboxing, and hybrid prompt routers.

• GitHub Copilot: local AI through Windows ML with llama.cpp as a backend. NVIDIA says the HydraFusion router now supports local models and that the MAI 1.1 Coding Flash model runs locally. For background on the router, see GitHub Copilot HydraFusion multi-model orchestration.
• Pi: an open-source terminal agent for local and cloud models, optimized for RTX Spark.
• JetBrains Junie Local: native support; it reads code, edits files and runs tests while the model and code stay on the machine. Its context window scales with GPU-accessible memory.
• Hermes and OpenClaw: supported, and the route by which the Nemotron model below is accessed.

Sandboxing and routing

Letting an agent run commands on your own machine is a risk. NVIDIA points to OS-level sandboxing through NVIDIA OpenShell or Microsoft Execution Containers. We looked at the OpenShell approach in NVIDIA's open agent safety platform.

The hybrid router idea is practical: send a prompt to the local model when it is good enough and escalate to a cloud model only when needed. That reduces token spend, but the quality of the routing decision is the part nobody has published numbers for.

Which models does NVIDIA highlight?

• Nemotron 3.5 Bolt 74B-A9B 24GB: a 74B-parameter mixture-of-experts model with 9B active parameters, quantized to 2 bits using quantization-aware training so it fits in about 24GB. NVIDIA says it runs on llama.cpp, vLLM, Ollama, Unsloth and LM Studio, and is fully open, including training data, weights and recipes.
• Qwen 3.8 Flash Next: named as a local coding model that cuts cloud token consumption.
• Decision models: supported in llama.cpp and Unsloth. They let an agent pick its next action without long reasoning loops, reportedly up to 200x faster than traditional agents. See our piece on Ollama's decision-model runtime.

Two-bit quantization of a 74B model is aggressive. NVIDIA's QAT claim should be tested on your own tasks before you trust it for production code changes.

Software ecosystem: Windows on Arm is the catch

Diagram of RTX Spark software ecosystem: coding agents, AI models, frameworks and CUDA-X libraries Image: NVIDIA

The quiet risk with any Arm Windows machine is software compatibility. NVIDIA, working with Microsoft, says it now has:

• the first PyTorch-CUDA build for Windows on Arm
• Python 3.15 as the native default
• over 2,000 Conda packages
• Arm-compatible builds for over 97% of the top 15,000 Python packages

The remaining 3% is where surprises live. NVIDIA also published a porting checklist for Windows apps: assess dependencies for Arm, choose native Arm64 or gradual Arm64EC migration, then test installation, functionality, performance and CUDA code paths.

NVIDIA is also shipping a Windows Developer Config built with Microsoft that installs common frameworks, silences notifications and improves the terminal, and an "NVIDIA Skills" repository meant to teach agents to use CUDA-X libraries such as FlashInfer and NeMo. If agent skills are new to you, start with what agent skills are.

Who should care, and who should wait

Worth a look: developers who already run local models through Ollama or llama.cpp and are limited by VRAM; teams with code-privacy rules that forbid sending source to cloud APIs; and anyone who wants an always-on home agent box when the November desktops land. See our earlier guide to home distributed AI with PAIR for the multi-device angle.

Wait for data: anyone buying on the 4.6x number, anyone whose toolchain has Windows x64-only dependencies, and anyone who needs price and thermals, which the post does not give.

Why unified memory changes the local-model math

Local inference has two bottlenecks: whether the weights fit, and how fast they stream to the compute units. On a typical gaming laptop, a 24GB or smaller GPU forces you into small models or heavy offloading to system RAM, which slows generation sharply. A shared pool of up to 128GB removes the first bottleneck for most open-weight models, because a quantized mixture-of-experts model only needs its weights resident, not duplicated across two memory spaces.

That is why NVIDIA leads with a 74B-parameter model that activates only 9B parameters per token. Mixture-of-experts designs suit this kind of machine: capacity comes from the large memory, while per-token compute stays modest. Runtimes such as llama.cpp and Unsloth, both named in the post, are how most developers will actually load these weights, and both already support the quantization formats NVIDIA mentions.

The trade-off is memory bandwidth. Unified memory on a compact SoC is generally slower than the dedicated memory on a high-end discrete card, so token generation speed is the number to measure on any machine you test. NVIDIA's post does not publish tokens per second for the Nemotron model, which is the figure most buyers would want first.

A practical evaluation checklist

1. Install your current agent (Copilot, Junie or a terminal agent) and point it at a local model through llama.cpp.
2. Run five real tasks from your own repository, such as a bug fix, a test addition and a refactor, and record pass rate and wall-clock time.
3. Repeat with your cloud model and compare cost per task, not only speed.
4. Check that your build chain, containers and native extensions install on Windows on Arm.
5. Leave the agent running for a day with sandboxing on, and review what it touched.

How to try it

NVIDIA's three steps: find an RTX Spark system through its marketplace, follow the AI Development playbook to set up Windows, configure an agent and connect NVIDIA Skills, then explore its local AI development resources. Before spending money, test your own stack: pull the model you actually use, run it in llama.cpp on a borrowed machine if you can, and measure tokens per second and task success rather than relying on the vendor chart. For a sense of how far small local models can go, read what happens when a local model replaces a cloud assistant.

What is confirmed and what is not

Specs and availability are accurate as of October 16, 2026 and come from NVIDIA's own announcement. Follow @explainx_ai for updates once independent tests appear.

Related reading

• PAIR and Hermes Desktop on RTX Spark
• NVIDIA PAIR: open-source distributed home AI
• GitHub Copilot HydraFusion
• NVIDIA OpenShell agent safety platform
• Ollama for decision models
• Cerebras Qwen3.8 27B at 1,500 tokens per second