Jetson AGX Thor and DGX Spark both put 128GB of LPDDR5X at 273 GB/s behind a Blackwell GPU. On paper they look like one machine in two cases, but they are not. In the only public llama.cpp run of both on the same build, Spark processed prompts about 1.9 times faster than Thor.
So the Jetson Thor vs DGX Spark choice is about where your box lives: on a robot with cameras and a 40 to 130 W budget, or on a desk serving models. We cover specs, cited benchmarks, prices after NVIDIA’s 2026 hikes and the software on each. The weight-size check below was run on an Ubuntu 26.04 lab VM in October 2026, with prices read the same day.
Pick Thor or Spark by where the model runs
Buy DGX Spark if your model serves people from a desk. Buy Jetson AGX Thor if your model rides on a machine that moves. Spark is faster at LLM inference and has the bigger CPU and network, while Thor has the sensor I/O, the real-time kernel and the power envelope a robot needs.
Best for local LLMs: NVIDIA DGX Spark, 128GB. It wins every single-stream llama.cpp test against Thor and runs DGX OS with NVIDIA’s Spark playbooks. NVIDIA lists it at $6,950 since October 2. Amazon’s NVIDIA listing and the ASUS Ascent GX10 (same GB10 chip) are both out of stock, so check NVIDIA’s DGX Spark page before you plan around one.
Best for robotics: NVIDIA Jetson AGX Thor Developer Kit. It is the only one of the two built to go inside a robot. You get Holoscan Sensor Bridge camera input, a QSFP28 port that splits into four 25GbE links, CAN headers and JetPack 7. Amazon sells it directly at about $5,300, a little under NVIDIA’s $5,499 list, so check the live price.
(paid link)If you only want a local chatbot or coding model, neither box is the cheapest answer. Our DGX Spark vs Strix Halo vs Mac Studio comparison covers 128GB Strix Halo boxes at about half the price per gigabyte.
How we compared Thor and Spark
Neither machine has been on our bench. Every speed you see here is a cited third-party or NVIDIA run, linked where it appears. Specs come from NVIDIA’s Thor launch post and the DGX Spark hardware guide, and Amazon price and stock come from Amazon’s catalog API.
The one thing we measured is model size. Both boxes have exactly 128GB, so the real question is which checkpoints fit before the OS and the KV cache take their share. We pulled the weight sizes of nine common checkpoints from the Hugging Face API, and you’ll find that table further down.
Jetson Thor vs DGX Spark specs
Memory size and bandwidth are identical, and nearly everything else differs. Spark has 2.4 times the CUDA cores and six more CPU cores, while Thor has the lower power floor and the robot I/O:
| Spec | Jetson AGX Thor Developer Kit | DGX Spark |
|---|---|---|
| Chip | Jetson T5000 (Blackwell GPU) | GB10 Grace Blackwell |
| CUDA cores | 2,560, 96 Tensor Cores, 1.57 GHz max | 6,144 |
| FP4 AI compute (sparse, vendor figure) | 2,070 TFLOPS | 1,000 TFLOPS (1 PFLOP) |
| CUDA compute capability | 11.0 | 12.1 |
| CPU | 14-core Arm Neoverse-V3AE, 2.6 GHz | 20-core Arm (10 Cortex-X925 + 10 Cortex-A725) |
| Memory | 128GB 256-bit LPDDR5X, 273 GB/s | 128GB 256-bit LPDDR5X, 273 GB/s |
| Networking | 5GbE RJ45, QSFP28 (4x 25GbE), Wi-Fi 6E | 10GbE RJ45, 2x QSFP ConnectX-7, Wi-Fi 7 |
| Power | Module configurable 40 to 130 W | 240 W external PSU, GB10 TDP 140 W |
| Size | 243 x 112 x 57 mm | 150 x 150 x 50.5 mm, 1.2 kg |
| OS | JetPack 7 (Ubuntu 24.04, Linux 6.8) | DGX OS |
| Price (October 2026) | $5,499 list, about $5,300 on Amazon | $6,950 list (128GB) |
The FP4 row is the one that misleads buyers. Thor’s 2,070 TFLOPS is a sparse FP4 peak at the full 130 W, and “sparse” assumes weights pruned to NVIDIA’s 2:4 structured sparsity pattern, which the checkpoints you download are not. The CUDA core row predicts LLM speed far better. The Jetson Thor launch post and the DGX Spark hardware guide are the sources for every row except price.
Read the llama.cpp numbers, not the TFLOPS
DGX Spark is faster than Jetson AGX Thor on every single-stream LLM test run on both. On the gpt-oss models and Qwen3 Coder 30B it leads by roughly 1.9x on prompt processing and 1.1x to 1.4x on token generation. On the dense Qwen2.5 Coder 7B the gap shrinks to about 1.4x and 1.2x, and Thor even edges ahead in a few batched decode rows. The cleanest data is the llama.cpp discussion where both machines ran build b6767 on the same MXFP4 GGUF files, which JetsonHacks collected into one side-by-side table in October 2025:
| Model and test (tokens/s) | DGX Spark | Jetson AGX Thor | Spark lead |
|---|---|---|---|
| gpt-oss-20b, prompt 2048 | 3,610.56 | 1,861.26 | 1.94x |
| gpt-oss-20b, generate 32 | 79.74 | 57.18 | 1.39x |
| gpt-oss-120b, prompt 2048 | 1,689.47 | 937.81 | 1.80x |
| gpt-oss-120b, generate 32 | 52.87 | 41.82 | 1.26x |
| gpt-oss-120b, generate 32 at 32K context | 38.76 | 32.62 | 1.19x |
| gpt-oss-20b, generate, batch 32, 4K context | 426.22 | 303.98 | 1.40x |
Prefill tracks GPU compute, so Spark’s 6,144 CUDA cores against Thor’s 2,560 show up as a near-2x gap at every context depth. Decode is mostly a memory bandwidth job. Both have 273 GB/s, which is why the generation gap is smaller and narrows as context grows.
On gpt-oss-120b at 32K context the two are within 20 percent. If you chat alone with a big MoE model, you’ll notice the gap less than the prefill row suggests. You’ll feel it most when you paste long documents or run an agent that keeps re-reading its context.
NVIDIA’s own Thor figures are higher because they use vLLM with eight concurrent requests. Its launch post lists 150.8 output tokens/s on Llama 3.1 8B, 226.42 on Qwen3-30B-A3B and 12.64 on Llama 3.3 70B in MAXN mode. Those are aggregate numbers, so do not compare them with the single-stream rows above.
Both data sets are about a year old, and newer engine builds have moved both machines since. Treat the ratio as the durable part, not the absolute tokens per second. Our Ollama vs vLLM vs llama.cpp benchmark shows how much the engine alone moves these numbers on one GPU.
Check what fits in 128GB before you buy
Both boxes share the same 128GB between the CPU, the GPU and the OS, so the first question for any model is its weight size. Model cards rarely state it, so we summed the safetensors files of each repo through the Hugging Face API from a lab VM. Save the script on any Linux machine with Python 3:
vim weights.pyPaste this in. It counts only the top-level safetensors files, because repos like gpt-oss also keep a second copy of the weights under original/:
#!/usr/bin/env python3
import json, sys, urllib.request
POOL_GB = 128
repos = sys.argv[1:]
print(f"{'model repo':48} {'weights GB':>10} {'left of 128GB':>14}")
for repo in repos:
url = f"https://huggingface.co/api/models/{repo}?blobs=true"
with urllib.request.urlopen(url, timeout=30) as r:
data = json.load(r)
size = sum(s.get("size") or 0 for s in data.get("siblings", [])
if "/" not in s["rfilename"] and s["rfilename"].endswith(".safetensors"))
gb = size / 1e9
print(f"{repo:48} {gb:10.1f} {POOL_GB - gb:14.1f}")Pass the repos you’re considering as arguments. These nine cover the models people most often ask about for a 128GB box:
python3 weights.py openai/gpt-oss-20b openai/gpt-oss-120b Qwen/Qwen3-30B-A3B Qwen/Qwen3-32B nvidia/Llama-3.3-70B-Instruct-FP4 RedHatAI/Llama-3.3-70B-Instruct-FP8-dynamic meta-llama/Llama-3.3-70B-Instruct nvidia/Qwen3-235B-A22B-FP4 Qwen/Qwen3-235B-A22B-FP8The script counts decimal gigabytes, so read the last column as a rough guide rather than an exact free figure:
model repo weights GB left of 128GB
openai/gpt-oss-20b 13.8 114.2
openai/gpt-oss-120b 65.2 62.8
Qwen/Qwen3-30B-A3B 61.1 66.9
Qwen/Qwen3-32B 65.5 62.5
nvidia/Llama-3.3-70B-Instruct-FP4 42.7 85.3
RedHatAI/Llama-3.3-70B-Instruct-FP8-dynamic 72.7 55.3
meta-llama/Llama-3.3-70B-Instruct 141.1 -13.1
nvidia/Qwen3-235B-A22B-FP4 134.1 -6.1
Qwen/Qwen3-235B-A22B-FP8 239.0 -111.0Two results matter here. A 70B model at BF16 is 141.1GB and fits on neither box, so you’ll run it at FP8 (72.7GB) or NVFP4 (42.7GB). Our NVFP4 vs FP8 benchmarks show what that costs in accuracy.
The second is NVIDIA’s NVFP4 build of Qwen3-235B-A22B at 134.1GB, about 125 GiB. Ollama’s Spark write-up counts about 120GB of the pool as usable GPU memory, so the “up to 200 billion parameters” line in the Spark guide does not stretch to this model on one unit. This is where Spark’s ConnectX-7 ports earn their price, because NVIDIA’s guide puts a dual-Spark setup at models up to 405B parameters.
The “left” column is not all usable. The OS, the CUDA context and your other processes come out of the same pool, and the KV cache grows with context and users. Plan on gpt-oss-120b or the FP8 70B as the comfortable ceiling for either box.
Choose Jetson AGX Thor for robots that move
Thor earns its place when the model sits next to sensors and motors, and LLM speed is secondary. Its power is configurable from 40 W, which matters on a battery, and the dev kit carries I/O that DGX Spark simply doesn’t have:
- Holoscan Sensor Bridge input for up to 20 cameras over the QSFP28 port
- up to 6 MIPI CSI-2 cameras on the module
- two 13-pin CAN headers and two automation headers
- a preemptable real-time kernel and MIG in JetPack 7
- PVA vision accelerator, optical flow and dual video encoders
MIG is the quiet feature. You can reserve a GPU slice for the control loop while a VLA model or LLM planner runs on the rest, so a long generation cannot starve the part that keeps the arm from hitting something. NVIDIA’s Thor figure for Isaac GR00T N1.5 (41.5 tokens/s in TensorRT) is the workload this box was designed around.
Skip Thor if nothing in your project has a camera on it. You would pay about $5,300 for a machine that is roughly half as fast at prompt processing as Spark, with a smaller CPU and 5GbE where Spark has 10GbE. If you are coming from Orin, our Jetson Orin Nano Super edge LLM comparison covers the cheap end of the Jetson range.
Choose DGX Spark for a desk that serves models
Spark is the better LLM machine at the same memory size, and its software targets that job. DGX OS ships with the NVIDIA container runtime, and NVIDIA’s Spark playbooks walk through vLLM, SGLang, fine-tuning and multi-node clustering. Most of what you run on a cloud GPU works the same way here.
It’s also a fair robotics development machine, as long as the robot is simulated. NVIDIA publishes an Isaac Sim and Isaac Lab playbook for DGX Spark that builds Isaac Sim from source for linux-aarch64 and runs the Isaac-Velocity-Rough-H1 training sample. You can train and simulate on Spark, then deploy the policy to Thor, since both are Arm machines running CUDA.
Skip Spark if you cannot wait for stock or do not need CUDA. At $6,950 it costs about $1,450 more than Thor’s list price. Amazon has no new units from NVIDIA or ASUS, and the partner GB10 boxes listed there come from resellers at about $8,000 and up. For pure inference on a budget, a discrete GPU picked by VRAM or a Strix Halo mini PC gets you further per dollar.
Plan for the CUDA and JetPack differences
Moving work between the two is easier than it was with Orin, but it is not free. JetPack 7 aligns Thor with the Arm server (SBSA) layout and one CUDA 13 install across Arm targets, so you no longer juggle a separate Jetson CUDA build. The GPUs still differ, though. NVIDIA’s compute capability table lists the Jetson T5000 at 11.0 and the GB10 at 12.1.
That gap shows up in three places when you move a project from Spark to Thor:
- Prebuilt wheels and containers must include kernels for 11.0; check before assuming a Spark image runs on Thor.
- TensorRT engines are built per GPU, so rebuild every engine on Thor itself.
- Source builds need both targets in the arch list, for example
TORCH_CUDA_ARCH_LIST="11.0;12.1"for PyTorch extensions.
The OS side differs too. Thor runs JetPack 7 on Ubuntu 24.04 with a Linux 6.8 kernel, and Spark runs DGX OS. Driver updates come from different channels, so a fix on one may not reach the other the same day. Neither uses the desktop driver install path in our NVIDIA drivers and CUDA guide for Ubuntu, which is for x86 machines with discrete cards.
Buy the same silicon for less
Both families now have cheaper entries, and each keeps the 273 GB/s bandwidth that sets decode speed. NVIDIA raised every Jetson price in July 2026, taking the Thor kit from $3,499 to $5,499 per CNX Software’s table. These are the options worth pricing:
- DGX Spark 64GB: from $4,999, partner-built only, same GB10 and 273 GB/s
- Jetson T4000 module: 64GB, 1,536 CUDA cores, 40 to 70 W, $2,999 at 1,000 units
- Jetson T5000 module alone: $4,999 at 1,000 units, for a custom carrier board
Skip the 64GB Spark if your largest model is gpt-oss-120b. Its 65.2GB of weights (about 61 GiB) leaves almost nothing for the OS and context on a 64GB box, and Qwen3-32B at BF16 is even larger at 65.5GB. gpt-oss-20b at 13.8GB and the NVFP4 Llama 3.3 70B at 42.7GB fit with room for context, so the 64GB unit suits you if those are your models. The T4000 is a module, not a desk machine, and it only makes sense once your robot design has moved past the dev kit.
