May 23, 2026

Llama 4 Scout for Local AI in 2026: What "17B Active Parameters" Actually Means for Your GPU

Q: How much disk space do I need for Scout?

Plan for more than one copy. The default `ollama pull llama4:scout` download is 67 GB on its own, and if you experiment with the Unsloth variants you'll add 42.2 GB (UD-Q2_K_XL) or 33.8 GB (UD-IQ1_S) on top. A 256 GB SSD that already holds an OS will not survive two Scout quants plus a couple of other models — 1 TB of NVMe is the comfortable floor for a Scout-capable machine, and model load times off [a fast NVMe drive](/blog/nvme-ssd-local-ai-model-loading-2026/) matter more than usual when the file is this large.

By RunAIHome Team · 16 min read

llama-4scoutlocal-aivrammoehardwareollamabuying-guide

When Meta released Llama 4 Scout in April 2025, the headline was irresistible: a 17B active-parameter model with a 10 million token context window. Home lab forums lit up. People assumed Scout would run on their existing RTX 4090, since 17B models at Q4 need roughly 10–12 GB of VRAM.

Then they typed ollama pull llama4:scout and watched 67 GB download.

The “17B active parameters” claim is technically accurate — Scout only activates 17 billion weights per token during inference. But the model has 109 billion total parameters spread across 16 expert networks, and all 109 billion must be loaded into memory before a single token generates. The active-vs-total distinction matters for compute throughput, not for how much VRAM or RAM you need.

This is the article most Scout guides skip. Here’s the actual hardware math.

How Scout’s MoE Architecture Works (and Why It Matters for VRAM)

Scout is a Mixture-of-Experts (MoE) model. Unlike a dense model where every weight fires on every token, MoE divides the feedforward layers into 16 specialized “expert” networks. A router decides which 1–2 experts handle each token. The attention layers are dense (always active); the FFN experts are sparse (mostly idle).

The math behind 17B active parameters:

Attention layers shared across all tokens: ~7B parameters
Each of the 16 expert FFN networks: ~6.4B parameters each
Active at inference: attention (7B) + ~1–2 experts (~6.4–12.8B) ≈ 13–20B, averaging ~17B

The catch: all 16 experts must be in memory so the router can dispatch tokens to whichever expert it selects. You can’t pre-load only the “active” experts — you don’t know which one until runtime.

This is why Scout’s memory footprint is similar to a 109B dense model, not a 17B one. The inference compute resembles a 17B model (fast generation once loaded). The loading requirement resembles a 109B model (slow setup, large memory).

The VRAM Reality: Scout’s File Sizes by Quantization

The authoritative numbers come from Unsloth’s GGUF releases and the official Ollama library:

Quantization	Bits/weight	File size	Minimum VRAM (GPU-only)
BF16 (unquantized)	16	216 GB	4× A100 80GB
Q8_0	8	115 GB	Mac Studio M4 Ultra 192GB
Q4_K_M (Ollama default)	~4.5	67 GB	2× RTX 4090 or Mac 128GB
UD-Q4_K_XL (Unsloth)	4.5	65.6 GB	Same as above
UD-Q2_K_XL (Unsloth, recommended)	2.71	42.2 GB	2× RTX 3090
UD-IQ1_S (Unsloth, smallest)	1.78	33.8 GB	RTX 5090 32GB (partial offload)

The Unsloth dynamic quantization (UD) variants use a smart approach: they quantize the large MoE expert layers more aggressively, while leaving attention and embedding layers at 4–6 bit. This preserves quality better than applying uniform low-bit quantization across the entire model.

The practical takeaway:

ollama pull llama4:scout gives you the 67 GB Q4_K_M version
You need 70+ GB of combined memory (VRAM or unified) to run it without CPU offloading
For single-GPU users, CPU offloading is the only path — with significant speed penalties

GPU Decision Matrix: What Configuration Runs Scout How Fast

Hardware	Combined VRAM	Best quant that fits	Approx. tok/s	Assessment
Single RTX 4090 (24GB)	24 GB	UD-IQ1_S with ~10GB CPU offload	~10–15	Possible, slow
Single RTX 5090 (32GB)	32 GB	UD-IQ1_S (~34GB, minor offload)	~20–28	Borderline, usable
2× RTX 3090 (48GB)	48 GB	UD-Q2_K_XL (42.2GB, fits)	~28–38	Good value path
2× RTX 4090 (48GB)	48 GB	UD-Q2_K_XL (42.2GB, fits)	~35–48	High-end consumer
3× RTX 4090 (72GB)	72 GB	Q4_K_M (67GB, fits)	~40–55	Top-tier home setup
Mac Studio M5 Max (128GB)	128 GB unified	Q4_K_M (67GB, fits easily)	~18–25	Best single-device option
Mac Studio M4 Ultra (192GB)	192 GB unified	Q8_0 (115GB, fits)	~12–18	Full quality, lower throughput
AMD Ryzen AI Max+ 395 mini-PC (128GB)	96 GB allocatable unified	Q4_K_M (67GB, fits)	up to ~15 (AMD’s figure)	Cheapest single-box unified-memory path

Notes:

Tok/s estimates are for Scout’s active-parameter profile (~17B active), which generates tokens faster than a dense 70B model but slower than a dense 17B model (overhead from expert routing)
CPU offloading tokens-per-second drops sharply as more layers hit system RAM — PCIe 4.0 bandwidth (32 GB/s) versus GDDR6X (1008 GB/s on RTX 4090) is the bottleneck
For multi-GPU tensor parallelism with llama.cpp, you need a recent build with true tensor parallel support; NVLink is dead on consumer Ampere and later

The clear winner for a single home device with no compromise: Mac Studio M5 Max with 128GB. The line starts at $2,499 for 36GB, and the 128GB config carries enough unified memory bandwidth (614 GB/s) to run Scout at full Q4 quality. See the Mac Studio vs dual RTX 4090 breakdown for full context.

For NVIDIA setups, the 2× RTX 3090 path running UD-Q2_K_XL (42.2 GB, fits in 48 GB combined) hits a reasonable price-to-performance point. Used RTX 3090s run $700–$1,000 on eBay — the value analysis is here.

There’s also a dark-horse x86 option: AMD’s Ryzen AI Max+ 395 (“Strix Halo”) mini-PCs and laptops with 128 GB of unified LPDDR5X. A July 2025 AMD driver update raised the Variable Graphics Memory ceiling to 96 GB on Windows, which is exactly enough to hold Scout’s 67 GB Q4_K_M entirely in GPU-addressable memory via Vulkan llama.cpp (LM Studio supports it out of the box). AMD quotes up to 15 tok/s on Scout — a best-case vendor number, and sustained speed depends on the specific chassis and its power limits — but it makes Scout-class MoE models runnable on a single quiet box that costs far less than a 128 GB Mac Studio. Scout’s 17B active-parameter profile is the ideal workload for this class of hardware: bandwidth-light per token, memory-hungry in total.

Don’t want to buy hardware to evaluate Scout? Rent an A100 80GB on RunPod for $1.19/hr and run Q8_0 to see if it fits your workload before committing to hardware.

Scout vs Llama 3.3 70B: The Quality Comparison

The benchmark picture is more nuanced than headlines suggest.

Benchmark	Scout (109B MoE)	Llama 3.3 70B	Winner
MMLU (general knowledge)	79.6%	86.0%	Llama 3.3 70B
MMLU-Pro (hard subset)	74.3%	68.9%	Scout
MGSM (multilingual math)	90.6%	91.1%	Llama 3.3 70B (marginal)
GPQA Diamond (PhD-level science)	57.2%	—	Scout
DocVQA (document understanding)	94.4%	N/A (text only)	Scout (unique capability)
ChartQA	88.8%	N/A (text only)	Scout (unique capability)
HumanEval (coding)	—	88.4%	Llama 3.3 70B

The headline MMLU number (standard test) goes to Llama 3.3 70B by 6.4 percentage points. On MMLU-Pro — the harder subset that weeds out pattern-matching — Scout wins by 5.4 points. The GPQA Diamond score (57.2%) is notably strong, suggesting Scout reasons better on difficult scientific problems despite losing the general-knowledge headline.

The more important comparison for local AI use: Scout is a multimodal model; Llama 3.3 70B is text-only. If your use case includes reading PDFs, analyzing charts, or processing images alongside text, Scout has no head-to-head competitor at this open-weights quality level.

For pure text tasks — coding, writing, summarization — Llama 3.3 70B remains the stronger choice, and it fits better in commodity hardware at 40 GB for Q4_K_M versus Scout’s 67 GB. For reference, the quantization quality tradeoffs for either model are covered here.

The 10 Million Token Context Window (and Why You Probably Won’t Use It)

Meta’s official context limit for Scout is 10 million tokens — roughly 7.5 million words, or a small library of documents. The actual Ollama library entry shows 128K as the functional context window, and this is intentional: a 10M context requires extraordinary memory.

At Q4 (67 GB model), processing a 10M token context in a single pass would require additional KV cache memory proportional to context length. At 10M tokens with Scout’s architecture, the KV cache alone would dwarf the model weights — running into hundreds of gigabytes of additional memory. The 128K Ollama default is practical.

The context advantage is real at 128K: Llama 3.3 70B’s maximum is 128K as well, and Scout hits that limit while activating dramatically fewer compute resources per token. For long-document processing, Scout’s throughput advantage (faster token generation due to fewer active parameters) compounds over a long context.

For most home AI use cases — coding assistance, document Q&A, image analysis — the 128K default context is sufficient. If you genuinely need million-token context, that workload belongs on cloud infrastructure regardless.

How to Run Scout on Ollama

Ollama 0.22.0 (released April 2026) ships native Windows binaries with full Llama 4 support. The standard install path:

# Pull the default Q4_K_M variant (~67 GB download)
ollama pull llama4:scout

# Run with text input
ollama run llama4:scout

# Run with image input (native multimodal)
ollama run llama4:scout
>>> Describe what you see in this diagram: /path/to/image.png

# Check GPU/CPU split (important — confirm GPU is actually being used)
ollama ps

For memory-constrained setups, the Unsloth dynamic quantization variants are not yet in the official Ollama registry as of this writing — you would pull them via llama.cpp or LM Studio directly from Hugging Face:

# Smaller Unsloth variant via llama.cpp (42.2 GB — fits in 2x 3090)
./llama-cli -hf unsloth/Llama-4-Scout-17B-16E-Instruct-GGUF:UD-Q2_K_XL

Run ollama ps after loading the model. If the output shows partial CPU offload (100% is GPU-only; anything less means layers are running on CPU), expect tok/s to drop proportionally. A 50% GPU offload on a 67 GB model typically drops throughput to 30–40% of full-VRAM speed.

For the full vLLM vs Ollama comparison for concurrent users, note that Scout’s MoE architecture benefits more from vLLM’s continuous batching at scale than a dense model would — the active-parameter overhead per batch is fixed at 17B regardless of how many requests you serve simultaneously.

Who Should Switch to Scout

Switch to Scout if:

You process images, charts, PDFs, or screenshots alongside text — Llama 3.3 70B can’t do this
You have a Mac Studio with 128GB+ unified memory already
You’re running a 2× RTX 3090 or 2× RTX 4090 setup and want the best open-weights model that fits
Your workload is GPQA-style reasoning rather than coding or general knowledge retrieval

Stick with Llama 3.3 70B if:

You have a single 24GB GPU and care about generation speed — Llama 3.3 at Q4 with moderate CPU offload still runs faster
Coding is your primary use case (HumanEval 88.4% vs Scout’s unreported coding score) — and if the goal is a local coding assistant specifically, the Cursor + local Llama hardware tier guide on our sister site covers which GPU tier actually earns its cost for that workload
You want the simplest hardware path — Llama 3.3 70B Q4 fits in 2× RTX 3090 with room to spare, and the RTX 3090 is currently available used at $700–$1,000
MMLU matters to you — Llama 3.3 wins by 6.4 points on the standard benchmark

The close-call case: single RTX 4090 users. Scout at UD-IQ1_S (33.8 GB) with 10 GB CPU offload will run, but at 10–15 tok/s — usable for multimodal tasks where you’re not waiting for a real-time conversation. For pure text inference, Llama 3.3 70B at that same hardware level is more practical.

Scout’s multimodal native capability — not an afterthought, not via a separate vision model — is genuinely differentiated. For home AI setups where image and document processing is part of the workflow, it’s the right model to run despite the harder hardware requirements. For pure text workloads on commodity hardware, Llama 3.3 70B remains the easier path.

See the full open-weights model comparison here for how Scout fits against Qwen3 and other current alternatives.

Where Scout Falls Short

Scout’s weaknesses deserve the same scrutiny as its specs, and a few of them only became clear after launch.

The 10M context claim doesn’t survive contact with long prompts. Beyond the memory math covered above, there’s a quality problem: AI researcher Andriy Burkov reported that Scout’s output degrades sharply once prompts pass roughly 256K tokens — his argument is that no Llama 4 model was trained on prompts longer than that, making the advertised 10M window effectively virtual. Treat 128K as the real ceiling and the 10M figure as marketing.

The launch window was rocky. Llama 4’s release drew criticism when the variant Meta submitted to LM Arena (a conversation-optimized Maverick build) differed from the publicly released weights, and early users reported quality that varied wildly between inference providers. Meta attributed the inconsistency to implementation bugs in a fast rollout. The practical consequence for home users: if you tested Scout on an early Ollama or llama.cpp build in spring 2025 and dismissed it, current builds behave noticeably better.

Quality drops hard at the quantization floor. UD-IQ1_S at 1.78 bits per weight is the only path onto a single consumer GPU, and it is a real compromise — even Unsloth’s dynamic approach, which protects attention and embedding layers, squeezes the expert layers hard at that size. If your workload is precision-sensitive (code generation, math, structured extraction), UD-Q2_K_XL on 48 GB of combined VRAM is the floor worth standing on.

No official coding benchmark. Meta published no HumanEval score for Scout, and community coding reports at launch ran weaker than Llama 3.3 70B and DeepSeek V3. If coding is the primary workload, Scout is not the model to build a rig around.

Fine-tuning carries the full 109B footprint. The same all-experts-in-memory rule that governs inference applies to training. LoRA fine-tuning Scout is multi-GPU or cloud territory, while a QLoRA run on Llama 3.3 70B fits in a 48 GB dual-3090 setup.

Frequently Asked Questions

Can I run Llama 4 Scout on a single 24GB GPU like an RTX 3090 or 4090?

Yes, but only the 33.8 GB UD-IQ1_S quant with roughly 10 GB of layers offloaded to system RAM, at 10–15 tok/s. That’s workable for batch multimodal jobs — summarizing a folder of PDFs, describing images — where you aren’t waiting on each token. For interactive chat or coding it will feel slow, and Llama 3.3 70B at Q4 with moderate offload is the better experience on the same card.

How much system RAM do I need for CPU offloading?

Combined VRAM plus RAM needs to clear the model file with room for KV cache and OS overhead. For UD-IQ1_S (33.8 GB) on a 24 GB GPU, 32 GB of system RAM is the floor and 48 GB is comfortable. For the default Q4_K_M (67 GB) on a single 24 GB card, plan on 64–96 GB of RAM — and accept that the more layers sit in system memory, the more PCIe bandwidth becomes the bottleneck, as covered in the decision matrix above.

Is Scout or Llama 4 Maverick the better local option?

Scout, almost by default. Maverick has 400B total parameters and needs roughly 225 GB at Q4 — multi-node or cloud territory, not home hardware. Scout is the only Llama 4 variant that lands on consumer-adjacent setups at all. The Llama VRAM requirements guide has the full memory table across every Llama generation.

Can an AMD Ryzen AI Max+ 395 (Strix Halo) machine with 128GB run Scout?

Yes — and it’s currently the cheapest single-device path to the full Q4_K_M quant. After AMD’s July 2025 Adrenalin driver update, Windows machines on this chip can assign up to 96 GB as Variable Graphics Memory, so the 67 GB model loads fully GPU-side through Vulkan llama.cpp or LM Studio. AMD’s own figure is up to 15 tok/s on Scout; treat that as a ceiling, since sustained throughput varies with the cooling and power limits of the specific mini-PC or laptop. That’s slower than a dual-4090 rig but competitive with a Mac Studio at a lower price, and far better than CPU offloading on a single 24 GB card.

How much disk space do I need for Scout?

Plan for more than one copy. The default ollama pull llama4:scout download is 67 GB on its own, and if you experiment with the Unsloth variants you’ll add 42.2 GB (UD-Q2_K_XL) or 33.8 GB (UD-IQ1_S) on top. A 256 GB SSD that already holds an OS will not survive two Scout quants plus a couple of other models — 1 TB of NVMe is the comfortable floor for a Scout-capable machine, and model load times off a fast NVMe drive matter more than usual when the file is this large.

1V1 PLAYBOOK · LOCAL LLM

Cut your local AI bill from $400/month cloud GPU to $47/month at home.

4-path hardware decision table, Ollama cold-start fix, Cursor/Claude Code routing configs, full 24-month TCO calculator.

Get it for $19 (early bird) →

Sources

Last updated October 21, 2026. Hardware prices and model availability change; verify current listings before purchasing.

Recommended Gear

The hardware mentioned in this guide, with current prices on Amazon (affiliate links — at no extra cost to you, purchases help support this site):

Was this article helpful?

Get the numbers before you buy

New GPU and mini-PC benchmarks, VRAM thresholds, and price checks — sent when there's something worth acting on, not on a schedule. No spam, unsubscribe anytime.