How Much Unified Memory Do You Actually Need for Local AI? (64GB vs 96GB vs 128GB, 2026)

Quick answer: Buy 128GB if you want 120B-class MoE models or a long context window on a 70B; 64GB is the honest floor for a single 70B at Q4 and nothing more; 24–32GB is a 7B–30B box, not a big-model box. Unified memory on every one of these machines is soldered on-package — it is the one specification you cannot change after checkout. The concrete numbers: a 70B at 4-bit needs about 42GB, a 128GB box assigns up to 96GB to the GPU while a 64GB box assigns roughly 48GB, and a 122B-class MoE at Q4 weighs about 67GB before you have loaded a single token of context. On the Framework Desktop — the only box in our catalog with all three tiers priced — that decision is $1,269 / $1,959 / $3,449 for 32GB / 64GB / 128GB (frame.work configurator, checked 2026-08-30).

The 60-second answer: pick your tier

Every row below traces to products.ts or a cited source. GPU-allocatable figures come from our VRAM calculator's box table: Strix Halo states "up to 96GB GPU-allocatable" of 128GB, and the same ~75% platform default applies to its smaller SKUs; Apple's macOS default GPU budget is also about 75% of unified RAM; NVIDIA's GB10 leaves roughly 120GB of its 128GB coherent pool after OS overhead.

The one-line version, worth quoting on its own: capacity decides what loads; bandwidth decides how fast it answers. Buying more memory never makes a model faster. It only makes a bigger model — or a longer conversation — possible at all.

Why soldered memory makes this the only decision you can't undo

On a desktop PC, RAM is a $200 afterthought. You buy 32GB, discover you need 64GB, and eight months later you drop in two more DIMMs on a Tuesday evening. That reflex is what gets people into trouble here, because none of these machines work that way.

LPDDR5X in this class is mounted on-package, millimetres from the memory controller, because that physical proximity is exactly what buys the wide 256-bit bus and the low latency that makes a 40-CU iGPU usable for inference at all. The trade is absolute: no DIMM slot, no SO-DIMM, no aftermarket module, no upgrade. Our catalog lists it in the cons for every relevant box — the GMKtec EVO-X2 ("memory is soldered — you must buy the 128GB SKU up front; no upgrade path"), the Beelink GTR9 Pro ("128GB soldered, non-upgradable"), the Framework Desktop ("soldered RAM — modularity doesn't extend to memory"), and every Apple machine ("not expandable after purchase").

That last one deserves a beat. Framework built an entire company on repairability, ships the Desktop on a standard mini-ITX mainboard with open firmware, and still could not make the memory swappable. When the most upgrade-friendly vendor in the industry solders the RAM, it is not a cost-cutting decision — it is physics.

So the practical framing is this: every other spec on these boxes is recoverable. Storage is dual M.2 on most of them. Networking can be fixed with a USB4 or Thunderbolt adapter. A noisy cooler can be repasted. Memory is the single irreversible line item, and it is also the one that determines whether the machine can do the job you bought it for. Over-think this one; under-think the rest.

What 64GB actually gets you (and the GTT trap nobody mentions)

This is the tier where the spec sheet and reality diverge most, so it gets the most space.

On paper, 64GB is a great deal. It assigns roughly 48GB to the GPU, and a Llama 3.3 70B at Q4 needs about 42GB by our calculator's rule (parameters × 0.5 bytes × 1.2 for runtime overhead). 42 fits inside 48. At $1,959 on the Framework Desktop configurator, that is the cheapest legitimate path to a 70B-class model on a desk, and the pitch writes itself.

Two things complicate it.

First, the headroom is 6GB. Not "6GB spare for other work" — 6GB total for KV cache growth, for the OS compositor, for the embedding model your RAG stack also wants resident, for a second model you forgot you had loaded. A 70B at 42GB in a 48GB pool is a machine that runs exactly one thing, and it runs it at short context. We work through what that ceiling means in practice in the best local LLM models for a 128GB mini PC.

Second — and this is the part no competing buying guide mentions — the 48GB is not automatic on Linux. On Strix Halo, memory handed to the iGPU beyond the BIOS-reserved carve-out comes through the kernel's GTT (Graphics Translation Table) allocator, governed by the amdgpu and TTM module parameters. The defaults are conservative. kyuz0, whose amd-strix-halo-toolboxes project maintains the most-cited per-backend benchmark grid for gfx1151, documents the failure mode plainly: without raising the GTT/TTM limits you silently lose 30+ GB of usable GPU memory with no error message. Nothing crashes. Nothing warns you. llama.cpp simply offloads fewer layers, the rest fall back to the CPU, and throughput collapses — and because it looks like the model "just runs slowly," people conclude the hardware is bad rather than the configuration.

On a 128GB box, that mistake costs you performance. On a 64GB box, it costs you the entire reason you bought the machine — 48GB minus 30GB is 18GB, which does not hold a 70B at any quantisation worth using. And the 64GB tier is tighter still: kyuz0's notes for 64GB configurations call for reserving GTT headroom explicitly (offloading some MoE expert layers to the CPU, e.g. --n-cpu-moe 4 or higher) or the first Vulkan queue submit fails outright with a vk::DeviceLostError rather than degrading gracefully.

Our verdict on the tier: 64GB is viable for a fixed, known workload run by someone willing to tune kernel parameters, and frustrating for everyone else. If that describes you, our Strix Halo VRAM allocation guide is the next thing to read — it covers exactly how to unlock the memory you paid for. If it does not describe you, read the last sentence of this section as a $1,490 argument for the 128GB SKU.

The Apple route at this tier sidesteps the problem entirely. The Mac Mini M4 Pro reaches 64GB at 273 GB/s — notably higher bandwidth than Strix Halo's ~215 GB/s real — and macOS manages the GPU memory budget for you with no kernel flags involved. You give up capacity headroom and pay more per GB, and you get a machine that behaves the way the spec sheet says it does.

What 96GB gets you (and why it's an Apple-only tier)

96GB is not a mainstream x86 configuration. No Strix Halo box ships it; the tier exists because of where Apple landed in the 2026 DRAM shortage. The Mac Studio M3 Ultra shipped at launch in configurations up to 512GB — enough to run DeepSeek R1 671B at 4-bit entirely in memory — and those 256GB and 512GB configurations were pulled during the shortage. What remains new in 2026 is a 96GB-only M3 Ultra at $3,999.

Read that as a bandwidth tier rather than a capacity tier. The M3 Ultra runs at 819 GB/s, roughly 3.8× the ~215 GB/s real throughput of a Strix Halo box. That inverts the usual advice:

• 96GB of fast memory beats 128GB of slow memory for dense models. A dense 70B re-reads every weight for every token, so it is bandwidth-bound, and the Mac finishes several times sooner on the same model.
• 128GB of slow memory beats 96GB of fast memory for capacity. A 122B-class MoE that does not fit at 72GB allocatable does not run at all, and "slow" beats "impossible" every time.

The 96GB headline hides the number that matters: macOS assigns roughly 75% of unified RAM to the GPU by default, so plan around ~72GB, not 96GB. That is comfortable for a 70B with a genuinely long context window, and tight-to-impossible for the 120B-class MoE models covered below. We take the bandwidth-versus-capacity argument apart properly in Strix Halo memory bandwidth: why 256 GB/s isn't 256 GB/s, and the Apple Silicon hub lists the rest of the line. If you are choosing inside Apple's range, M4 Max vs M3 Ultra is the 128GB-versus-96GB question in a single page.

What 128GB gets you in September 2026

Here is where the answer changed this year, and where most competing guides are still quoting March.

128GB on Strix Halo means about 96GB allocatable to the GPU; on NVIDIA's GB10 it means roughly 120GB of a coherent pool after OS overhead. What that buys, with current model footprints:

Derived figures use our calculator's parameters × 0.5 bytes × 1.2 rule and are estimates. Throughput figures and the reported Qwen3.5 / GPT-OSS file sizes are third-party community reports — not DataHardware measurements. Qwen3.5 and Qwen3.6 are not yet in our model catalog; treat their numbers as reported until we can verify them. Unsloth's run-locally documentation is the most reliable current source on quant footprints across the MXFP4_MOE and UD-Q4_K_XL variants; the community-maintained Strix Halo Wiki llama.cpp performance tables are the best source for per-model throughput.

Now the conclusion that most of the internet gets backwards. A 122B-class MoE at ~67GB leaves roughly 29GB free inside a 96GB allocatable pool. That is not room for a second model. That is room for context. The extra 64GB over a 64GB box does not buy you a meaningfully bigger model — the biggest thing you can run locally moved from ~70B to ~122B-total-parameters, which is one step, not a leap. What it actually buys is the ability to keep a long conversation, a whole codebase, or a large retrieved document set resident while the model runs.

That reframing matters because it changes who should buy 128GB. If you ask a model short questions, 128GB is an expensive way to hold a model you could have held in 64GB. If you paste 40,000 tokens of code into it and expect the answer to account for all of them, 128GB is not a luxury. For the practical walkthrough on the largest of these, see running GPT-OSS 120B locally on a mini PC, and the Strix Halo hub for the full field of 128GB x86 boxes.

The context-window math (the part that actually decides it)

Model weights are the floor, not the requirement. The number nobody puts in a buying guide is the KV cache: the per-token attention state the runtime must hold for every token in the context window, growing linearly as the conversation gets longer.

The formula is straightforward and you can run it on any model whose architecture is published:

KV bytes per token = 2 (K and V) × layers × KV heads × head dimension × bytes per element

Take Llama 3.3 70B, whose published architecture is 80 layers with grouped-query attention at 8 KV heads and a head dimension of 128. At FP16 that is 2 × 80 × 8 × 128 × 2 = 327,680 bytes, about 0.31 MB per token. Multiply out:

KV figures computed from Llama 3.3 70B's published architecture; weight figures derived from our calculator. Both are estimates — real runtimes add allocator overhead, and quantising the KV cache to 8-bit roughly halves the cache column.

That table is the whole argument. The same model at 8K and at 64K context are two different hardware requirements, separated by roughly 18GB — more than the entire memory budget of an entry-tier box. A 64GB machine runs a 70B as a chatbot with a short memory. A 128GB machine runs the same 70B as a tool you can hand a repository to.

Two practical notes before you use this. Quantising the KV cache to 8-bit halves the numbers above and is supported in llama.cpp — it is the cheapest way to buy context on a tier you already own. And long context is not free on the compute side either: prefill is compute-bound rather than bandwidth-bound, so a 40,000-token prompt takes real wall-clock time to process before the first token appears. We measured that separately in Strix Halo prefill and time-to-first-token. Run your own model against the tiers with our VRAM calculator before you commit.

Cost per usable GB across the tiers

The Framework Desktop is the only box in our catalog with all three capacity tiers priced by the same vendor on the same day, which makes it the clean comparison. Prices from the frame.work configurator, checked 2026-08-30; "usable" applies the ~75% GPU-allocatable platform default.

The counterintuitive result: the marginal memory is cheaper than the average memory. Going 32GB → 64GB costs $690 for 32GB, or $21.56 per additional GB. Going 64GB → 128GB costs $1,490 for 64GB, or $23.28 per additional GB. Both are well under the $26.95–$39.66 blended rate, because a large share of each price is chassis, APU, board and cooler rather than DRAM. In pure $/GB terms, the top tier is the best value on the sheet.

That is exactly the argument a vendor blog stops at, so here is the other half: $/GB is only a meaningful metric for memory you will address. If your largest model is a 32B at ~20GB, the 128GB tier's superior $/GB is $1,490 spent on capacity you will never touch. Cost-per-usable-GB is the right metric only once you have decided what "usable" means for your workload.

One timing caveat. The 2026 DRAM shortage has moved every number on this page — DRAM contract prices rose roughly 180% in Q1 2026 versus Q4 2025 (TrendForce), NVIDIA raised the DGX Spark's official price from $3,999 to $4,699 on 2026-02-27 citing memory supply, and the newly pre-ordering AMD Ryzen AI Halo developer platform lands at $3,999 for the same 128GB Ryzen AI Max+ 395 configuration (ServeTheHome coverage; third-party reported). Every price here carries a checked-on date for that reason. We track the trend in the 2026 local-AI mini PC price increase.

Which box to buy at each tier

The analysis is done above; this is just the shortlist.

• 16–24GB — experimenting, 7B–14B models: Mac Mini M4 ($499–$799, 120 GB/s) if you want macOS and silence, GMKtec M8 ($389–$409) or MAGICNUC AS1 ($229–$299) for an always-on agent host. Mac Mini M4 vs Beelink SER8 splits the entry tier.
• 32GB — 30B-class ceiling: GMKtec M6 Ultra ($579) is the value pick; Beelink SER8 ($799–$939) if you want a quieter, faster Zen 4 box. The 32GB Framework Desktop at $1,269 costs more but sits on the Strix Halo platform, which matters only if you later regret not buying up.
• 64GB — one 70B, tuned: Framework Desktop 64GB ($1,959) for the cheapest 70B-capable configuration, with the GTT caveat above. Mac Mini M4 Pro ($1,399–$1,599) at 273 GB/s if you would rather have higher bandwidth and no kernel flags than maximum capacity.
• 96GB — bandwidth first: Mac Studio M3 Ultra ($3,999), the only 96GB-native box and the fastest unified memory you can buy at 819 GB/s.
• 128GB — the ceiling: Framework Desktop ($3,449) is the cheapest credible entry; GMKtec EVO-X2 ($3,649) is the quiet, dual-M.2 appliance; Beelink GTR9 Pro ($4,349) adds dual 10GbE; Minisforum MS-S1 Max ($3,799) adds PCIe x16 and a rack option; HP Z2 Mini G1a ($3,300–$3,734) adds ECC and a 3-year warranty. EVO-X2 vs Framework Desktop is the matchup most people are actually deciding.
• 128GB with CUDA: NVIDIA DGX Spark ($4,699+) or ASUS Ascent GX10 ($6,449–$8,820) — roughly 120GB allocatable at 273 GB/s, bought for the toolchain and 200GbE clustering rather than the bandwidth. See the GB10 hub.
• 128GB with real bandwidth: Mac Studio M4 Max ($1,999–$5,999) reaches 128GB at 410–546 GB/s — roughly 2–2.5× Strix Halo's real throughput, at Apple pricing.

If you are still upstream of the capacity question entirely, start with the best mini PC for local LLMs, and read unified memory vs VRAM for why GPU-allocatable memory is the number that matters rather than the headline capacity.

Bottom line

Buy 128GB if you want 120B-class MoE models or a long context window on a 70B; 64GB is the honest floor for a single 70B at Q4 and nothing more; 24–32GB is a 7B–30B box. The three numbers that decide it: a 70B at Q4 needs ~42GB, a 64GB box allocates ~48GB to the GPU, and a 64K-token context on that same 70B adds ~20GB of KV cache — which is why the tier below 128GB runs big models only as short-memory chatbots. On the Framework Desktop the step from 64GB to 128GB is $1,490, and it buys context rather than a materially bigger model.

Two corrections to carry with you. More unified memory does not make models run faster — bandwidth does, which is why a 96GB Mac Studio at 819 GB/s outruns a 128GB Strix Halo box on dense models it holds less comfortably. And on Linux, the 64GB tier's usable GPU pool is smaller and more fragile than the spec sheet implies until you raise the GTT limits — budget an evening for that, or buy the tier that does not require it. Whatever you choose, choose carefully: the memory is soldered, and you get exactly one chance at this decision.