AutomaterThe Local AI Workstation, 2026 Edition: DGX Spark, Ryzen AI Max, or a Mac?
DGX Spark, Ryzen AI Max 395, Mac Studio, or used 3090s? The 2026 local LLM hardware guide: bandwidth vs capacity, three priced builds, and when local wins.
Go deeper. Build your own.
The most consequential number in local AI right now is 46GB. That is roughly what it takes to serve Qwen3-Coder-Next — the 80B-parameter, Apache-2.0 coding model that turned “my agent runs on my own machine” from a flex into a Tuesday — and it is the number your local LLM hardware either clears or doesn’t. Clear it and you own a frontier-adjacent coding agent with no meter attached. Miss it and you’re shopping again next quarter.
Four credible ways to clear it exist as of August 2026: NVIDIA’s DGX Spark, the AMD Ryzen AI Max 395 mini-PC wave, Apple’s M-series Macs, and a rig built from used datacenter-refugee GPUs. They price from under $1,000 to five figures, and the spec sheets are nearly useless for choosing between them, because the number vendors print biggest — TOPS — matters least.
This guide is the decision framework: the reference workload that defines the box, the bandwidth-versus-capacity math that actually predicts how it will feel, honest profiles of all four platforms, three priced builds, the serving-stack ladder, and a clear-eyed answer to when local beats the API at all. Prices move; the flagged figures below carry verify notes for a reason.
The reference workload: Qwen3-Coder-Next in 46GB
Buying local AI hardware without naming the model you’ll run is how people end up with expensive boxes that serve 8B models very fast. So name it. For agent work in 2026, the reference workload is Qwen3-Coder-Next: 80B total parameters with ~3B active per token (MoE), Apache-2.0, a vendor-reported ~70.6% on SWE-bench Verified, and a served footprint around 46GB of unified memory at 4-bit — with a 30B Flash variant that fits in ~18GB, per the mid-2026 open-model field data. It is the model behind most credible local-agent setups we see, and we profile it alongside its peers in open-weight models that can actually drive a harness.
Two tiers, then: ~18GB buys the Flash class on a single 24GB GPU, and ~46GB-plus-headroom buys the full build. The headroom clause is where agent workloads differ from chat. A harness session is not a 200-token question; it is a 40,000-token context of repo files, diffs, and tool output that grows for an hour. That means the KV cache — the per-token working memory of inference — claims real gigabytes on top of the weights: several GB to ~15GB for long six-figure contexts, depending on model and quantization. Budget 64GB of usable memory to run the 46GB model like an agent rather than a demo.
Everything bigger — GLM-5.2, DeepSeek V4, Kimi K3 — stays hosted for almost everyone, as the open-weight scorecard makes plain. The local game in 2026 is the 18–64GB band. Buy for that band.
Local LLM hardware is two numbers: bandwidth and capacity
Memory capacity decides which models you can load at all: weights plus KV cache must fit in VRAM or unified memory, full stop. Memory bandwidth — how many gigabytes per second the processor can read from that memory — decides how fast generation runs once the model fits. Capacity is the guest list; bandwidth is the speed limit. Local LLM hardware shopping is the art of buying enough of both without overpaying for either.
Here is why bandwidth rules generation speed. Producing one token requires reading, roughly, every active parameter’s bytes out of memory once. Decode is therefore memory-bound, and the ceiling is simple division: tokens/second ≈ bandwidth ÷ bytes read per token. A dense 46GB model on a 273 GB/s machine tops out near 6 tokens/second — coffee-break territory. But Qwen3-Coder-Next is MoE: only ~3B of its 80B parameters activate per token, so each token reads on the order of 2GB, and the same 273 GB/s machine has a ceiling above 100 tokens/second, with real-world results landing at a third to a half of ceiling once overhead does its work. That single fact is why the 2026 unified-memory boxes are viable at all: sparse models need big capacity but only modest bandwidth per token. Capacity for 80B, bandwidth for 3B.
Agent work adds a third axis the spec sheets ignore: prefill. Before the first token of a reply, the machine must process your whole prompt, and harness prompts are enormous. Prefill is compute-bound, not bandwidth-bound — so a box with strong GPU compute chews through a 40k-token context in seconds, while a bandwidth-rich but compute-lighter machine makes you wait. This is where the Spark outruns its bandwidth reputation, where Macs feel slower than their bandwidth suggests, and where community results scatter most. For agents, ask three questions in order: does it fit (capacity), how fast does it think about your repo (prefill compute), how fast does it type (bandwidth).
The field, in those terms:
| Platform | Memory | Bandwidth | The shape of the deal |
|---|---|---|---|
| NVIDIA DGX Spark | 128GB unified | ~273 GB/s | CUDA + strong compute, modest bandwidth |
| Ryzen AI Max+ 395 boxes | up to 128GB unified | ~256 GB/s | Cheapest 128GB in the field |
| Mac Studio (M4 Max) | up to 128GB unified | ~546 GB/s | Bandwidth + polish, mid compute |
| Mac Studio (M3 Ultra) | up to 512GB unified | ~819 GB/s | The only 512GB desk box |
| Used RTX 3090 | 24GB VRAM each | ~936 GB/s | Bandwidth king per dollar, capacity-capped |
Capacity decides what fits; bandwidth decides how it feels. The reference workload only needs you in the shaded band.
The four platforms, honestly
NVIDIA DGX Spark is the petaflop-in-a-lunchbox: a Grace Blackwell desk unit from NVIDIA with 128GB of unified memory, serious FP4 compute, a ~240W envelope, and a port that pairs two units into one 256GB pool. Street price sits around $4,000, with partner variants from ASUS, Dell, and others somewhat under it. The case for it: the CUDA ecosystem runs everything first and best — vLLM, fine-tuning stacks, whatever ships next — and its prefill speed suits agent contexts. The case against: 273 GB/s of bandwidth means dense models decode slowly for the money, so its value concentrates on MoE workloads and on being a desk-sized dev twin of datacenter NVIDIA. You are buying the ecosystem and the compute, not the bandwidth.
Ryzen AI Max 395 boxes — AMD’s Strix Halo platform in machines like the Framework Desktop and a swarm of mini-PCs — deliver the same 128GB unified capacity as the Spark at roughly half the price, around $2,000 for well-specced 128GB configurations. Bandwidth is Spark-adjacent (~256 GB/s), so the MoE math works identically. The trade is software: ROCm and Vulkan inference matured a lot through 2025–2026, and the mainstream llama.cpp-based stacks run well, but you will meet more rough edges than CUDA users do, and prefill compute trails the Spark. The case for it is blunt and strong: cheapest ticket to the 46GB club, sane power draw, real Linux boxes.
Apple M-series is the option your non-hobbyist colleagues actually buy. A Mac Studio with an M4 Max and 128GB brings ~546 GB/s — double the Spark — for roughly $3,700, and the M3 Ultra configuration scales to 512GB at ~819 GB/s for around $9,500, the only single desk box that can even attempt 200GB-class MoE quants. The MLX ecosystem is genuinely good now, quantized releases land fast, and the machine is silent and also your computer. The honest caveats: prefill on big agent contexts trails NVIDIA compute, the memory is priced like Apple memory, and none of the serious multi-user serving stacks target macOS — this is a one-engineer box.
Used-GPU rigs are the bandwidth play. A used RTX 3090 gives 24GB at ~936 GB/s for about $700–900; two of them plus a workstation board make a 48GB CUDA machine around $2,500 that decodes faster than anything else at the price and fine-tunes overnight. The full build runs with tensor-parallel vLLM; the Flash tier flies on a single card. Costs beyond cash: 350W per card before undervolting, actual noise, driver-and-riser weekends, and a capacity ceiling that makes 100GB-class models a hardware project rather than a purchase. If you enjoy this kind of thing, you already knew that; if you don’t, you won’t start now.
Three builds that make sense in 2026
| Build | Cash outlay | What it actually runs | Who it’s for |
|---|---|---|---|
| Budget: one used 3090 | ~$700–1,500 all-in | Qwen3-Coder-Next Flash (~18GB) at interactive speed; 8–14B fine-tunes | First local lane; agent tasks that repeat all day |
| One-box: 128GB unified | ~$2,000–4,000 | The full 46GB model with KV headroom; 100B-class MoE at tighter quants | The local daily driver; privacy-bound repos |
| Deep end: 512GB Mac or multi-GPU | ~$6,000–12,000 | 200GB-class MoE quants; concurrent team serving (GPU rig + vLLM) | Teams, researchers, the incurable |
The budget build is a used RTX 3090 dropped into a tower you probably already own — mind the 850W power supply — and it is the correct first move for most readers. The Flash tier is a real agent engine, not a consolation prize, and the same card handles the QLoRA fine-tuning lane from our train-your-own-mini-model playbook, which no unified-memory box does as well.
The one-box build is where the reference workload lives, and the three ways to buy it map cleanly to temperament: the Strix Halo box if you want the cheapest 128GB and run Linux without flinching; the DGX Spark if CUDA-first tooling and fine-tune compute justify the premium; the Mac Studio if it must also be your daily computer and stay silent doing it. All three serve the 46GB model with room for long contexts.
The deep end splits by goal. The 512GB M3 Ultra is for one person running enormous models quietly. The multi-GPU rig — four 3090s on a used workstation platform, or a pair of 48GB cards — is for serving a team: it is the only tier where vLLM’s continuous batching gets to earn its keep across concurrent harness sessions. Price the electricity before the GPUs; the next section is not a joke.
Three builds, three ceilings: 18GB, 46GB-with-headroom, and the 200GB-class deep end.
The serving stack ladder
Software turns the box into an endpoint, and the ladder has three rungs. Start at the bottom; climb only when something concrete pushes you.
Rung one: Ollama or LM Studio. One command serves the reference model — ollama pull qwen3-coder — with quantization handled for you and an OpenAI-compatible endpoint on localhost. LM Studio adds a GUI and MLX builds on Macs. This rung covers a single engineer completely, and there is no shame in never leaving it.
Rung two: llama.cpp directly. The engine under most of rung one, run bare when you want control: exact quant selection from the community GGUF builds on Hugging Face, KV-cache quantization to stretch context, layer offloading, sampling flags. You climb here the day defaults stop fitting.
Rung three: vLLM or SGLang. Datacenter-grade serving — continuous batching, paged KV, tensor parallelism, real concurrency — for CUDA and ROCm boxes. One harness session leaves this rung idle; five simultaneous lanes justify it, which makes it the natural OS for the deep-end rig serving a team. On Apple silicon this rung is effectively MLX-based servers instead.
The whole ladder speaks the OpenAI-compatible dialect, which is the only reason the next sections work. Where these pieces sit among the rest of your tooling is mapped in the open-source AI agent stack.
When local wins — and when the API keeps winning
Local’s honest scorecard has three wins, one tie, and one loss.
Privacy wins outright. Code that cannot leave the building, clients with data-residency terms, air-gapped environments, regulated repos: a local model is not competing with the API here, because the API is disqualified. This is the cleanest reason to own the box.
The always-on lane wins. A local model’s marginal token is free, which changes behavior: you stop rationing. Background triage of every test failure, commit messages on every commit, log summarization on a timer, an overnight batch pass across the backlog — workloads you would never meter through a paid API become defaults. The box earns its keep on volume you currently don’t buy.
Custom models win by default. Your fine-tuned specialist from the mini-model playbook has to live somewhere, and it is not going on someone else’s cloud.
Unit cost is the tie, and be honest about it. DeepSeek V4 Flash sells at $0.14 per million input tokens; at that floor, a $2,000 box amortized over two years costs about $85 a month before power, which buys several hundred million Flash-priced tokens. Local wins the math only at sustained heavy volume — think a billion-plus tokens a month through the cheap lane — or when the privacy and always-on cases are doing the real lifting. Most people who claim the box “paid for itself” are right, but because it changed what they automated, not because it undercut the meter.
Peak capability loses, full stop. Nothing in 46GB reasons like Claude Fable 5 or GPT-5.6. The correct architecture keeps a frontier lane for the hard 20% and routes the repetitive 80% locally. Local is a lane, not a defection.
Product note: The privacy case only closes if the whole stack is local — a local model with cloud transcripts is half a promise. Automater Lite is the other half: it archives sessions from 10+ CLIs into a local-first, full-text-searchable library and meters your token usage across providers locally, so prompts, transcripts, and usage data stay on the same machine the model runs on. Nothing leaves the box. Free on automater.ai.
Noise, power, and desk reality
The spec nobody benchmarks is living with the thing. The unified-memory boxes are civilized: a Mac Studio idles silent and stays quiet under load; the Spark and the Strix Halo minis run laptop-class acoustics at ~140–240W working draw. All three sit on a desk and are forgotten.
The GPU rig is a different roommate. Four 3090s pull 1,400W before the platform joins in — undervolting to ~275W per card costs little speed and is basically mandatory — and the result still heats the room audibly and legibly. At 8 working hours a day, a 1kW rig burns roughly 240kWh a month: $35–75 on typical residential rates, every month, forever. It also wants its own circuit; North American 15A breakers and space heaters have opinions about sharing. Garage, closet, or basement placement plus a long Ethernet cable solves what the fan curve cannot.
Pairing local models with your harness
The last mile is pleasantly short, because the mid-2026 harness world standardized on two dialects — nearly every serious CLI accepts an OpenAI-compatible endpoint, and many take Anthropic-Messages too. Your local server is just another base URL:
export OPENAI_API_BASE="http://localhost:11434/v1" # Ollama
export OPENAI_API_KEY="local"
aider --model openai/qwen3-coder # or OpenCode, Qwen Code, Crush…Point any of the open-source harnesses at it and the workstation becomes a lane in your fleet: the free, private, always-on lane that handles volume work while metered lanes handle the hard problems. Route by task the way we lay out in running multiple AI coding agents without the chaos, and treat the local endpoint exactly like a provider — same configs, same evals, same skepticism. The harness field map has the compatibility details per tool.
That is the 2026 shape of it. One reference workload, two numbers that matter, four platforms, three builds — and a box on your desk that turns “should I spend tokens on this?” into a question you’ve stopped asking.
FAQ: local LLM hardware
What hardware do I need to run LLMs locally in 2026?
For agent-grade coding models: a 24GB GPU (used RTX 3090 class) runs the ~18GB Qwen3-Coder-Next Flash tier well. The full 80B model wants ~46GB plus KV-cache headroom — a 128GB unified-memory box (DGX Spark, Ryzen AI Max 395, Mac Studio) or 64GB of pooled VRAM.
Is the DGX Spark worth it for local LLM work?
It depends on what you value: its 128GB capacity and CUDA ecosystem are excellent, and prefill compute suits agent contexts, but ~273 GB/s bandwidth means MoE models are its sweet spot — dense models decode slowly for $4,000. Strix Halo boxes match its capacity for roughly half the price; Macs double its bandwidth.
How much memory does Qwen3-Coder-Next need?
Roughly 46GB of VRAM or unified memory for the 80B-A3B build at 4-bit quantization, plus several gigabytes of KV cache for long agent contexts — so plan for 64GB usable. The 30B Flash variant fits in about 18GB, which is why a single 24GB GPU is the classic entry point.
Does memory bandwidth or capacity matter more for local AI?
Capacity gates what loads; bandwidth sets generation speed — tokens/second is roughly bandwidth divided by bytes read per token. For MoE models like Qwen3-Coder-Next (~3B active parameters), modest 256–273 GB/s boxes are genuinely usable, which is exactly why the 2026 unified-memory wave works. Dense 70B models still want serious bandwidth.
Is running an LLM locally cheaper than the API?
Rarely on raw unit cost — hosted floors like DeepSeek V4 Flash at $0.14 per million input tokens are brutal to undercut after hardware and power. Local wins on privacy, on fine-tuned custom models, and on always-on background workloads where a free marginal token changes what you automate at all.
