Memory inflation redrew the minimum spec for running AI at home

01 The spec sheet moved under everyone

Local AI has always been a memory problem wearing a compute costume. Model weights must live somewhere, and the somewhere is RAM or VRAM that the rest of the machine also needs. What changed in 2026 is not that arithmetic. What changed is the price of the silicon that the arithmetic consumes.

This is not another recap of the memory-price crisis; the repricing itself has been documented at length elsewhere. The question here is accounting: which model classes fit in which memory tiers, and how the DRAM repricing moved the rows in the table buyers use to turn a budget into a capability.

The uncomfortable summary is that the minimum spec for capable local inference rose even though nothing about the models demanded it. The bar moved because the cost of reaching the old bar moved - and a minimum spec, properly defined, is a cost statement, not a technical one.

02 From parameters to gigabytes

Everything starts with one multiplication. At 4-bit quantization a parameter occupies roughly half a byte, so resident weights are approximately parameter count times 0.5 bytes, plus a ten to fifteen percent allowance for scales, embeddings, and quantization constants. A 7B model lands near 4 GB. A 13B lands near 7 GB. A 34B needs about 18 GB, and a 70B needs roughly 38 GB before a single token of context exists.

At 8-bit the same multiplication simply doubles: about 7 GB, 13 GB, 34 GB, and 70 GB respectively. That doubling is the difference between a midrange machine and a workstation, and it buys fidelity rather than new capability - which is why most local deployments live at 4-bit and treat 8-bit as a luxury good.

The rule is nearly deterministic, and that is the point. You cannot negotiate with parameters times bytes. Whatever the marketing says, the tier that runs a given model class is fixed by arithmetic; only the price of admission to each tier is set by the memory market, and that price is the thing that moved.

03 The overhead you cannot skip

Weights are the floor, not the budget. The operating system and desktop environment realistically claim three to six gigabytes on a consumer machine - more when an integrated GPU shares the same physical pool - so a "16 GB" laptop never offers sixteen gigabytes to a model. The first deduction happens before inference starts.

On top of the OS sits the KV cache, which grows with context length and concurrency. A short chat with a 70B model at 4k context is one budget; the same model serving 32k-context documents is a materially larger one, sometimes by several gigabytes. Long-context local agents are where tier headroom goes to die.

The working rule of thumb: budget weights plus twenty-five to forty percent before calling a model comfortably resident. Comfortably is doing real work in that sentence - a model that fits with 200 MB to spare will swap the moment a browser tab gets ambitious, and swapping turns a fast local model into a slow one.

04 The four tiers, audited

The 16 GB laptop tier: 7B to 8B models at 4-bit run comfortably and 13B runs tight once the OS takes its share. This tier is genuinely useful - drafting, summarizing, code completion - but it is not where agentic workloads live, and pretending otherwise is the most common first-buyer mistake.

The 32 GB desktop tier: the historical sweet spot. 13B to 34B at 4-bit fits with working room, and 34B-class quality was, for most of 2024 and 2025, the practical ceiling of consumer local inference. A 70B does not fit here - its weights alone exceed the tier - which is why the jump from 32 GB to 64 GB felt less like an upgrade and more like a gate.

The 64 to 96 GB unified-memory tier is where 70B at 4-bit becomes real: 38 GB of weights plus overhead and context sits fine in 64 GB, and the 96 GB configuration covers 8-bit or longer contexts. Above that, the 128 GB-plus workstation tier runs a 70B at 8-bit with headroom, or quantized 100B-plus mixture-of-experts models. Each step up the ladder is a discrete purchase, not a bolt-on upgrade.

05 What 2024 money bought versus what 2026 money buys

In 2024, the standard route to 70B-class local inference was a 64 GB unified-memory machine or a dual-GPU rig with 48 GB of VRAM, priced in a cheap-DRAM world where adding capacity was the cheapest way to buy capability. That route was already expensive; at least it was predictable.

The repricing broke the predictability. Industry contract-price reporting through late 2025 and 2026 showed conventional DRAM rising in successive waves - less a spike and recovery than a re-leveling - with module prices in some categories multiplying within three quarters. Indexed to mid-2025, the reporting consensus puts the commodity tier somewhere between double and triple by late 2026, which is the kind of move that rewrites build guides mid-year.

Translated into the tier table: the row that read "70B local: midrange workstation" now reads "70B local: upper-tier workstation." The models did not change - the models never change the tier table; the arithmetic does. The currency of admission did. A buyer with a fixed 2024 budget lands one to two tiers lower in 2026, and the difference is measured in model classes, not percentage points.

06 Soldered ceilings and the collapsed upgrade path

The old escape hatch was sequential buying: start at 16 GB, add memory modules when the workload grows. That hatch is closing. Thin laptops, mini-PCs, and a growing share of desktop boards ship memory soldered or permanently configured, which converts capacity from an upgrade into a day-one decision.

Losing the upgrade path has a price even when prices are flat, because option value is real: waiting let buyers learn their true workload before paying for capacity. In a repriced market the loss doubles. The capacity must now be bought at peak prices, and it must be bought before the buyer knows how much is needed.

GPU-side VRAM is a separate market with its own squeeze, driven by datacenter demand; that story has been covered elsewhere. The consumer consequence is simply that the 24 GB card did not become the affordable fallback either. In 2026, every door out of the memory constraint got more expensive at the same time.

07 Buying strategy when memory is the constraint

Buy for the model class you expect to run in year two, not the one you demo this month. Quantization research keeps improving, but 4-bit is already near the practical floor for weights, and no credible roadmap repeals parameters times bytes. The capacity you under-buy is the capability you will rent back from the cloud at a monthly rate.

Decision rules follow straight from the tier table. If the target is 34B-class, a 64 GB unified-memory machine beats a 32 GB machine plus optimism. If the target is a 70B at 8-bit with long context, price the 96 to 128 GB tier now and watch the contract-price index before committing. If the target is anything larger, the honest answer is that local is a development surface, not a deployment platform.

Finally, keep the cloud fallback priced and honest. Local inference is a hedge with a carrying cost, and when the carrying cost spikes, rebalancing the hedge is accounting, not defeat. Buyers who treat memory as the budget line it has become will end 2026 with working machines; buyers who priced 2026 like 2024 will end it refreshing benchmarks they cannot run.