LLM VRAM Requirements 2026: The Open-Model GPU Index

Why VRAM Is the Real Spec Sheet for Open Models in 2026

Parameter counts stopped being a reliable predictor of deployability the moment mixture-of-experts (MoE) architectures went mainstream. Llama 4 Scout is billed as a 109B-parameter model but only activates 17B parameters per token, while DeepSeek V4 sits at 1T total parameters against 37B active. VRAM planning still has to account for the full parameter set that must be resident in memory for most serving engines, not just the headline 'active' figure — which is exactly why a lookup table beats a rule about model size.

For a UK buyer, the practical question mid-2026 is binary at first glance but consequential in practice: does a model fit on a single 24GB workstation card, a dual-GPU 24-48GB desk-side rig, or does it require an 80GB/141GB-class datacentre GPU? That single fact drives capex, power draw, rack space, and whether a workload can stay on-prem or has to move to cloud capacity.

Deconstructing VRAM: Weights, KV Cache, Activations and Overhead

Spheron's 2026 memory guidance breaks GPU planning into five components: model weights, KV cache, activation memory, framework overhead, and a fragmentation buffer. Skipping any one of these is the most common reason a model that 'should fit' runs out of memory in production once real traffic arrives.

Weight memory follows a simple rule of thumb, per Data Dynamics' 2026 model-landscape figures: roughly 2GB per 1B parameters at FP16, about 1GB per 1B at 8-bit, and about 0.5GB per 1B at 4-bit. A related weight-only shortcut from Convly AI is parameter count multiplied by quantisation bits, divided by eight — useful for a first-pass estimate before overhead is added.

On top of weights, Data Dynamics recommends adding 20-40% for KV cache and activations. Spheron's own serving guidance is more specific: budget 1.3x-1.5x the weight size for moderate concurrency and context, rising to 1.5x-2x for high-concurrency or long-context serving.

The 2026 Lookup Table: VRAM by Model and Quantisation

The table below combines model-specific 2026 cheat-sheet entries with broader model-class heuristics. The named-model rows (Llama 4 Scout, Llama 4 Maverick, DeepSeek V4) are deployment lookup values that already assume a particular configuration and context, not universal formulas — treat them accordingly rather than applying the same multiplier to a different context length.

Note the scope difference: some figures here are close to weights-only estimates at a stated precision, while others carry an explicit warning that the listed configuration is tight once KV cache is factored in. DeepSeek V4's ~1,000GB FP8 figure falls into the latter category — budget headroom above it, not exactly at it.

Worked Examples: From Raw Weights to Real Deployment

Llama 4 Scout (109B total, 17B active) needs roughly 55GB of VRAM at INT4 but jumps to around 218GB at FP16 — a near four-fold swing driven purely by precision. At INT4 this comfortably suits a dual 48GB-class workstation; at FP16 it demands multi-GPU 80GB-class serving.

Note: While Spheron's 2026 cheat sheet indicates ~55GB VRAM at INT4 for Llama 4 Scout, other 2026 sources suggest figures as low as ~24GB at Q4. This discrepancy highlights the importance of confirming specific context length and overhead assumptions when sizing hardware — the two figures likely reflect different assumptions about context window, concurrency, or the exact 4-bit method used, rather than a contradiction in the model itself. Readers should treat any single VRAM figure as provisional until they've confirmed the quantisation method, target context length, and concurrency assumptions behind it.

Qwen 3 32B, a dense model rather than MoE, scales far more predictably: around 16GB at INT4 and about 64GB at FP16, which lines up neatly with the ~2GB-per-1B-parameter FP16 rule. Dense models are consequently easier to size than MoE architectures where 'total' and 'active' parameters diverge sharply.

DeepSeek V4 (1T total, 37B active) needs approximately 1,000GB at FP8 — and the source explicitly flags this as tight for KV cache on the listed configuration. In practice that means any production deployment needs a materially larger memory pool than the headline figure, not a config that just clears the bar.

Matching Models to GPU Tiers: Single Card to Multi-Node

The single-24GB tier suits 8B, 14B-class and 32B dense models at Q4: LocalAIMaster's 2026 database puts an 8B model at roughly 5GB, a 14B-class model at 9-10GB (fitting a 12-16GB GPU), and a 32B dense model at around 20GB (fitting a 24GB GPU).

70B-and-up dense models need 40GB+ and, per the same database, typically require system RAM spillover or two 24GB GPUs working together — the point at which UK buyers should be evaluating proper AI servers configurations rather than assuming one workstation card will do.

Beyond that, Llama 4 Maverick's ~200GB INT4 footprint and DeepSeek V4's ~1,000GB FP8 footprint push firmly into multi-GPU node or multi-node datacentre territory — a decision UK teams increasingly resolve by weighing on-prem capex against self-hosting LLMs versus cloud GPU costs.

Quantisation Trade-offs: INT4 vs FP8 vs FP16

Quantisation is the single biggest lever on VRAM. Applying the weight rule of thumb, moving a model from FP16 (~2GB per 1B parameters) down to 4-bit (~0.5GB per 1B) roughly quarters the weight footprint — visible directly in the Llama 4 Scout figures, where INT4 sits at ~55GB against ~218GB at FP16, and in Qwen 3 32B, where INT4 sits at ~16GB against ~64GB at FP16.

The practical implication for a UK team is that INT4/Q4-class quantisation should be the default assumption for anything targeting consumer or single-workstation GPUs, with higher precision (FP8, FP16) reserved for cases where the extra multi-GPU cost is justified by the workload.

KV Cache and Context Length: Why Long Context Changes the Answer

KV cache is the component most often left out of a naive VRAM estimate — and the one most affected by context length and concurrency. Data Dynamics' 20-40% overhead allowance is a starting point for moderate use; Spheron's serving guidance is more granular, recommending 1.3x-1.5x the weight size for moderate concurrency and context, rising to 1.5x-2x for high-concurrency or long-context serving.

In practice this means the same ~55GB INT4 weight figure for Llama 4 Scout could realistically demand meaningfully more once a team serves long context windows or several concurrent sessions — the gap between a weight-only number and a production-ready figure. Use how much VRAM an LLM needs as a working reference when converting a raw weight estimate into a serving budget.

Methodology

This index compiles VRAM and GPU-count figures published in 2026 by vendor, cloud and hardware-guide sources tracking open-model memory requirements, including model-specific cheat sheets, local-model databases, and model-landscape rule-of-thumb articles. Data collection ran through to July 2026, capturing the most recent published figures for Llama 4 Scout, Llama 4 Maverick, DeepSeek V4, Kimi K2.5, Qwen 3 32B and Mistral Large 2, alongside broader 8B/14B/32B/70B+ model-class heuristics.

Each figure was checked against its original source's stated scope — quantisation level (INT4, FP8, FP16), whether the figure was weights-only or included KV cache and overhead, and any explicit caveat about tight headroom — to avoid conflating figures that measure different things. Where a source described a configuration as tight for KV cache, that caveat is preserved rather than simplified into a binary fit/no-fit verdict.

This is a lookup index, not a live calculator: figures reflect the assumptions of their original publishing source (context length, concurrency, and serving engine) and should be treated as deployment reference points. Readers sizing a specific workload should still model their own context length and concurrency rather than applying these figures universally.

Sources

Every figure in this article traces to the sources below.

• •Spheron — 2026 GPU requirements cheat sheet (model-specific VRAM figures)
• •Spheron — 2026 GPU memory requirements guide (VRAM components and overhead multipliers)
• •LocalAIMaster — 2026 local AI model database (model-class VRAM heuristics)
• •Data Dynamics — 2026 AI model landscape (weight-memory rule of thumb)
• •Convly AI — 2026 AI models and GPUs comparison (weight-only estimate formula)