Llama 4 is Meta’s most capable open model yet, and its Mixture-of-Experts architecture makes it faster than the parameter count suggests — not smaller. Scout activates 17B parameters per token but stores 109B, and Ollama ships it at ~67GB at Q4_K_M. No single consumer GPU holds that, the RTX 5090’s 32GB included. Locally this is a three-to-four-card build; Maverick, at ~245GB, is cloud or cluster only.
NVIDIA GeForce RTX 5090
32GB GDDR7Scout's Q4 weights are 67GB against this card's 32GB, so it takes three. Worth pricing four used 3090s — same capacity, a fifth of the cost.
Affiliate links — we may earn a commission at no extra cost to you. Amazon ships globally; Shopee SG covers Singapore & ASEAN.
Understanding Llama 4’s MoE architecture
Llama 4’s Mixture-of-Experts design is the key to understanding its hardware requirements. Unlike dense models where every parameter activates for every token, MoE models route each token through only a subset of “expert” layers.
- Scout (109B total, 17B active) — 109B parameters exist in memory, but only 17B activate per token. Inference speed resembles a 17B dense model, but you still need VRAM to hold all 109B weights. (For Ollama-specific VRAM math across every model size, see our Ollama VRAM Requirements guide.)
- Maverick (400B total, 17B active) — Same 17B active parameter count as Scout, but a much larger expert pool. Requires ~245GB VRAM at Q4 — cluster or cloud territory, not a workstation.
This is the critical distinction: active parameters determine speed, total parameters determine VRAM requirements. Scout does not need 109B worth of computation per token, but it does need 109B worth of memory.
At Q4_K_M, Scout’s 109B weights come to ~67GB. That is the number to plan around: MoE changes how much compute each token costs, not how much memory the model occupies.
Scout vs Maverick: which should you target?
| Feature | Scout (109B) | Maverick (400B) |
|---|---|---|
| Active params per token | 17B | 17B |
| Total model weights (FP16) | ~217GB | ~803GB |
| Q4_K_M size | ~67GB | ~245GB |
| Minimum VRAM | 80GB | 256GB+ |
| Single consumer GPU? | No | No |
| Benchmark quality | > Llama 3 70B | > Llama 3 405B |
| Best local option | 4x RTX 3090 (96GB) | None — cloud or cluster |
Scout is the practically deployable model. Maverick is what you access when you need the best quality and are willing to use cloud inference — see our Llama 4 Maverick hardware summary for the full breakdown of what Maverick requires. If you are specifically evaluating Scout as a standalone target, our Llama 4 Scout GPU guide goes deeper on its inference characteristics and hardware recommendations.
VRAM requirements by model and quantization
| Model | Quantization | VRAM Required | Fits On |
|---|---|---|---|
| Scout (109B) | Q4_K_M | ~67GB | 80GB card, 3x RTX 5090, 4x RTX 3090 |
| Scout (109B) | Q8_0 | ~117GB | 2x A100 80GB |
| Scout (109B) | FP16 | ~217GB | Data center only |
| Maverick (400B) | Q4_K_M | ~245GB | 4x A100 80GB or equivalent |
| Maverick (400B) | Q8_0 | ~428GB | Data center only |
| Maverick (400B) | FP16 | ~803GB | Cluster only |
VRAM capacity memory bandwidth Specs are manufacturer figures. Bar lengths are scaled independently per metric.
GPU benchmarks for Llama 4 Scout
Modelled from memory bandwidth at Q4_K_M (methodology). Only configurations that actually hold the 67GB of weights produce a throughput figure:
| Configuration | VRAM | Scout Q4_K_M | ~Tok/s | Price |
|---|---|---|---|---|
| Cloud H100 80GB | 80GB | Yes | ~80 tok/s | ~$3.5/hr |
| Cloud A100 80GB | 80GB | Yes | ~45 tok/s | ~$2/hr |
| 3x RTX 5090 | 96GB | Yes | ~40 tok/s | ~$14,700 |
| 4x RTX 3090 (used) | 96GB | Yes | ~25 tok/s | ~$3,280 |
| 2x RTX 5090 | 64GB | No — 3GB short | — | ~$9,800 |
| 2x RTX 4090 | 48GB | No — 19GB short | — | ~$4,400 |
| RTX 5090 | 32GB | No | — | ~$4,900 |
| RTX 4090 | 24GB | No | — | ~$2,200 |
Note: Ollama publishes only Q4_K_M, Q8_0 and FP16 for Llama 4, so there is no lighter official build to fall back on. Third-party GGUFs do go lower — Unsloth’s Scout repository reaches 29.3GB at UD-TQ1_0 and 39.6GB at Q2_K (checked 2026-09-13) — so a 24GB card is still out, but two of them are not. The Scout buyer’s guide works through whether that trade is worth taking.
Check NVIDIA GeForce RTX 4090 on Amazon→Buy on Shopee SG→Multi-GPU setup guide for Llama 4 Scout
Two cards are not enough for Scout at any consumer capacity — 48GB and 64GB both fall short of its 67GB. What you are building toward is 80GB or more, via llama.cpp tensor splitting:
What you need:
- 4x RTX 3090 or 3x RTX 5090 (96GB either way; 24GB cards are far cheaper per gigabyte)
- a board with four usable PCIe slots and a power budget around 1,400W
- llama.cpp with CUDA support compiled
- NVLink is not required — PCIe works fine for inference
Running Scout across four 3090s:
# Compile llama.cpp with CUDA
make LLAMA_CUDA=1
# Run Scout with tensor split across two GPUs
./llama-cli -m scout-q4_k_m.gguf \
--n-gpu-layers 999 \
--tensor-split 0.5,0.5 \
-p "Your prompt here"The --tensor-split 0.5,0.5 flag distributes layers evenly across both GPUs. llama.cpp handles the inter-GPU communication automatically over PCIe — no NVLink required for inference.
Dual 4090s give 48GB combined, which is still 19GB short of Scout at Q4. Two cards are not the answer to this model on any consumer part — four used 3090s (96GB) or three 5090s (96GB) are the smallest configurations that load it.
KV cache and long context requirements
Llama 4 Scout supports very long context windows. The KV cache VRAM cost scales with context length:
| Context Length | KV Cache Size (Scout) | Total VRAM (Q4_K_M) |
|---|---|---|
| 4K tokens | ~0.75GB | ~69GB |
| 16K tokens | ~3GB | ~72GB |
| 32K tokens | ~6GB | ~75GB |
| 64K tokens | ~12GB | ~81GB — past an 80GB card |
Context is a second-order problem here — Scout’s weights alone exceed every consumer card, so the KV cache question only arises once you are already at 80GB or more. An 80GB A100 leaves 13GB above the 67GB of weights, and runtime overhead takes about 1.5GB of that, so roughly 11.5GB is available for cache — around 60K context at 0.19MB per token. The full 64K window needs a quantized KV cache or a second card.
Maverick on cloud: RunPod
For Maverick-class workloads, cloud is the only practical answer. At ~245GB for Q4_K_M it needs a multi-GPU instance — four A100 80GBs or equivalent — which is exactly the kind of thing worth renting by the hour rather than owning.
Run Llama 4 Maverick on RunPod — 4x A100 80GB instances→A single 80GB card does not fit Maverick — its Q4_K_M weights are roughly three times that. Plan on four A100 80GBs or an equivalent multi-GPU instance, and note that a single 80GB card is the right size for Scout, not Maverick.
How Llama 4 compares to previous generations
Understanding the hardware shift from Llama 3 helps set expectations:
| Model | VRAM at Q4_K_M | Single GPU? | Best Single GPU |
|---|---|---|---|
| Llama 3 8B | ~5GB | Yes (any) | RTX 3060 12GB |
| Llama 3 70B | 43GB | No | Needs dual GPU |
| Llama 4 Scout | ~67GB | No single consumer card | 4x RTX 3090 or cloud 80GB |
| Llama 4 Maverick | ~245GB | No | Cloud only |
Scout beats Llama 3 70B on most benchmarks while computing only 17B parameters per token, which makes it unusually fast for its class. What it is not is unusually small: at 67GB it needs roughly two and a half times the memory of Llama 3 70B at Q4. MoE moved the cost from compute to memory rather than removing it.
Which GPU should you buy for Llama 4?
Running Scout at best quality? → Rent an 80GB A100 (~$2/hr on RunPod). Nothing you can buy for one card’s money runs it, and at ~$2/hr you would need well over a thousand hours before a three-card 5090 build breaks even.
Already own an RTX 4090? → A second one still will not run Scout. 48GB is 19GB short of its Q4 weights. What a second card does buy you is comfortable headroom on 32B-class dense models and on retrieval-augmented setups, which is a better reason to add it than Llama 4.
On a budget with a 24GB card? → Run a different model. Scout has no published quantization that fits 24GB. Qwen 3 32B at ~20GB or the Qwen 3 30B-A3B MoE at ~19GB are the models this hardware is actually for.
Need Maverick? → RunPod cloud, multi-GPU. At ~245GB for Q4_K_M, no single card of any kind holds it — you are renting four 80GB GPUs, not one.
Not sure which Llama 4 size to target? → Start with Scout, in the cloud. It already beats Llama 3 70B on benchmarks and Maverick is overkill for local use — but rent before you build, because the hardware bill for Scout starts around $3,300 in used cards.
Common mistakes to avoid
- Buying any single card expecting Scout to fit at Q4_K_M — none do. Scout’s Q4 weights are 67GB, so the smallest builds that load it are four used RTX 3090s or three RTX 5090s.
- Treating total parameter count as VRAM requirement — Scout has 109B total parameters but only 17B activate per token. VRAM need is set by all weights, but inference speed reflects only active parameters.
- Attempting Maverick on a single GPU of any kind — its Q4_K_M weights are ~245GB, so even an 80GB A100 is short by a factor of three. Use a multi-GPU cloud instance.
- Reading “17B active” as the VRAM requirement — it is the compute cost per token. All 109B parameters stay resident because routing happens at inference time, which is why the file is 67GB rather than 11GB.
- Comparing Scout directly to Llama 3 70B as equivalent — Scout beats Llama 3 70B on most benchmarks. The full expert pool provides qualitative improvements beyond what the active parameter count suggests. If reasoning quality is your priority and Scout’s MoE behavior feels uneven on long chains, our DeepSeek GPU guide covers an alternative dense-reasoning family that runs comfortably on the same 24-32GB hardware tier.
Final verdict
| Goal | Best GPU | Price |
|---|---|---|
| Llama 4 Scout, occasional use | RunPod A100 80GB | ~$2/hr |
| Llama 4 Scout, cheapest local build | 4x RTX 3090 used | ~$3,280 |
| Llama 4 Scout, fastest local build | 3x RTX 5090 | ~$14,700 |
| Llama 4 Maverick | RunPod cloud | Pay per hour |
NVIDIA GeForce RTX 5090
32GB GDDR732GB runs every 32B-class model with room to spare. For Scout specifically you need three of them — or four used 3090s at a fifth the price.
Affiliate links — we may earn a commission at no extra cost to you. Amazon ships globally; Shopee SG covers Singapore & ASEAN.
Llama 4’s MoE design makes Scout unusually fast for its size, but not unusually small. It remains a 67GB model, and the honest verdict is that it belongs on rented 80GB hardware unless you already own four 24GB cards.
For full VRAM breakdowns at every quantization level, see how much VRAM for Llama 4. If you are coming from an older setup, the Llama 3 GPU guide covers the previous generation. Comparing Llama 4 against Alibaba’s competing release? See our best GPU for Qwen 3 guide for the dense alternative. For VRAM sizing fundamentals, the local LLM VRAM guide explains the math.
Frequently asked questions
How much VRAM do I need for Llama 4 Scout?
Llama 4 Scout at Q4_K_M requires approximately 67GB of VRAM for model weights, plus KV cache overhead for context. No single consumer GPU reaches that, including the 32GB RTX 5090. An 80GB A100 or H100 is the smallest comfortable home for it, and the smallest local builds are four used RTX 3090s or three RTX 5090s.
Can I run Llama 4 on a single GPU?
Not at Q4_K_M, which is where most people start. Scout needs roughly 67GB there and Ollama publishes nothing lighter, so even a 32GB RTX 5090 falls well short. Third-party low-bit GGUFs get close to a single 32GB card, but with little room left for context and a real quality cost. A single 80GB A100 or H100 runs Scout comfortably. Llama 4 Maverick (400B) needs roughly 245GB at Q4_K_M, which is cluster or cloud territory.
What’s the difference between Llama 4 Scout and Maverick?
Both Scout and Maverick use Mixture-of-Experts architecture with 17B active parameters per token, so they have similar inference speeds. The difference is total parameters: Scout has 109B (Q4 = ~67GB) while Maverick has 400B (Q4 = ~245GB). Maverick’s larger expert pool delivers higher output quality but requires cluster or cloud deployment.
Does Llama 4 Scout actually beat Llama 3 70B?
Yes, on most standard benchmarks Llama 4 Scout outperforms Llama 3 70B while computing only 17B parameters per token. The MoE architecture’s larger expert pool lets it match or exceed the quality of larger dense models, and the low active count makes it fast. The cost is memory: at ~67GB for Q4_K_M it needs roughly two and a half times the VRAM of Llama 3 70B at the same quantization.
Can I run Llama 4 with a dual-GPU setup?
Yes, but two cards are not enough for Scout. Two RTX 4090s give 48GB against Scout’s 67GB at Q4_K_M, so you need four 24GB cards or three 32GB cards. Use llama.cpp with the —tensor-split flag to distribute layers across the GPUs. NVLink is not required; PCIe bandwidth is sufficient for inference workloads.