Meta shipped Llama 4 Scout and Llama 4 Maverick on the same day — April 5, 2025 — and it is easy to read them as “the small one” and “the big one.” That framing is wrong in the way that matters most for your bill. Both models activate exactly 17 billion parameters per token. What differs is the size of the expert pool those 17B are drawn from: 16 experts in Scout, 128 in Maverick. Everything else — the price gap, the hardware gap, the benchmark gap — falls out of that one architectural choice.
That also means the usual “bigger model, better answers” intuition breaks down here. Maverick is 3.7× larger in total parameters but does not run 3.7× better, and on a couple of benchmarks it does not run better at all. Below is the full side-by-side, grounded in Meta’s published model card and live provider pricing — including the one specification that is quoted constantly and is effectively unavailable in practice.
Key takeaways
- Same active parameters, different expert pools. Scout is 109B total / 17B active across 16 experts. Maverick is 400B total / 17B active across 128 experts. Inference compute per token is nearly identical; memory footprint is not.
- Scout’s 10M context is real but you almost certainly cannot rent it. Meta trained Scout for 10M tokens. Hosted providers serve between 128K and ~1.3M. The full 10M requires self-hosting and an enormous KV cache.
- Maverick’s lead is concentrated in reasoning and code. GPQA Diamond +12.6 points, LiveCodeBench +10.6. On document understanding the two are level — DocVQA is 94.4 for both.
- Scout costs roughly 2.3× less on a blended basis ($0.15 vs $0.35 per 1M blended at a 3:1 input:output ratio).
- Local hardware is where they truly separate. Scout fits one 80GB H100 at 4-bit; Maverick needs about 240GB at 4-bit and a full 8-GPU host at FP8.
- Treat Maverick’s famous 1417 LMArena score as void. That number came from an unreleased experimental chat variant, not the downloadable weights.
The 30-second version
Pick Scout if you are doing long-document work, retrieval, summarization, OCR and chart or form extraction, or anything high-volume where per-token cost compounds — and especially if you want to self-host on a single GPU. Pick Maverick if your workload is genuinely reasoning-bound or code-bound, where its double-digit lead on GPQA Diamond and LiveCodeBench pays for the extra hardware and the extra spend. For most document and extraction pipelines, paying 2.3× for Maverick buys you almost nothing measurable.
Architecture: one knob, two very different models
Both models are mixture-of-experts transformers using what Meta calls early fusion for native multimodality — image and text tokens enter the same backbone rather than being bolted together by a separate vision adapter. Both accept text and images and emit text. Both have an August 2024 knowledge cutoff.
The divergence is the router. Scout picks from 16 experts, Maverick from 128. Because only 17B parameters fire per token either way, the two cost roughly the same compute per token — but every expert must be resident in memory whether or not it activates on a given token. That is why Maverick is 3.7× the memory of Scout while being only marginally slower per token, and it is the reason a sparse 400B model can be served at prices that would be impossible for a dense 400B model.
One difference worth noting: Scout was trained on roughly 40 trillion tokens, Maverick on roughly 22 trillion. Scout saw more data spread across fewer experts; Maverick saw less data spread across many more. That helps explain why Scout holds its own on breadth-of-knowledge and document tasks while falling behind on hard reasoning.
Context window: 10M on paper, far less in practice
This is the most-quoted and most-misleading number in the Llama 4 launch. Meta advertises an “industry leading 10 million token” context window for Scout, achieved through an interleaved-attention design without positional embeddings. Maverick ships 1M.
The catch: essentially no hosted provider serves 10M. In practice the caps look like this — Groq around 128K–131K, DeepInfra around 320K, Together around 328K, Fireworks approaching 1M, and OpenRouter’s Scout listing showing 1,310,720 tokens with a 16,384-token completion cap. To actually use 10M tokens you have to self-host, and then you run into the real constraint: the KV cache. At multi-million-token depths the cache dwarfs the model weights themselves, which is precisely why providers cap it.
So the honest comparison is not “10M vs 1M.” It is closer to ~1.3M vs ~1M on the platforms most people will actually use — a real Scout advantage, but a narrow one rather than the tenfold gap the spec sheet implies. If you have a genuine multi-million-token requirement, budget for self-hosting and test throughput at depth before committing.
Benchmarks: where the extra 291B parameters show up
All figures below are Meta’s own published results for the Instruct variants. They are first-party numbers, so read them as directional rather than settled.
| Benchmark | Llama 4 Scout | Llama 4 Maverick | Gap |
|---|---|---|---|
| MMLU Pro (reasoning) | 74.3 | 80.5 | +6.2 |
| GPQA Diamond (graduate science) | 57.2 | 69.8 | +12.6 |
| LiveCodeBench (coding) | 32.8 | 43.4 | +10.6 |
| MMMU (image reasoning) | 69.4 | 73.4 | +4.0 |
| MMMU Pro | 52.2 | 59.6 | +7.4 |
| MathVista | 70.7 | 73.7 | +3.0 |
| ChartQA | 88.8 | 90.0 | +1.2 |
| DocVQA (test) | 94.4 | 94.4 | 0.0 |
| MGSM (multilingual math) | 90.6 | 92.3 | +1.7 |
| MTOB half-book (eng→kgv) | 42.2 | 54.0 | +11.8 |
The shape of this table is the whole argument. Maverick’s advantage is large and consistent on reasoning, science and code — a 22% relative gain on GPQA Diamond and a 32% relative gain on LiveCodeBench. On document and chart understanding it collapses to nothing: 1.2 points on ChartQA and a dead heat on DocVQA.
If your pipeline is invoice extraction, form parsing, receipt OCR or chart reading, Meta’s own numbers say Maverick will not read your documents better than Scout — and you would be paying roughly 2.3× per token for that parity. That is the single most actionable finding here.
One benchmark you should ignore entirely: Maverick’s widely repeated 1417 LMArena ELO. Meta submitted an “experimental chat version” that was never released for download or general API access, and researchers found its outputs did not match the Hugging Face weights. LMArena revised its policy on April 8, 2025 to require that open-weight submissions match published weights, stating that Meta’s interpretation of the rules did not match what it expects from model providers. The unmodified public weights ranked far lower. Whatever Maverick’s real conversational quality is, 1417 is not evidence of it.
Local hardware: VRAM at FP16, FP8 and 4-bit
Memory for weights is simply parameter count × bytes per parameter, then add roughly 15–25% for KV cache and activation overhead at modest context lengths. Long contexts push the cache far higher.
| Precision | Scout (109B) | Maverick (400B) |
|---|---|---|
| BF16/FP16 weights | ~218 GB | ~800 GB |
| FP8 weights | ~109 GB | ~400 GB |
| INT4 weights | ~55 GB | ~200 GB |
| INT4 practical (with overhead) | ~65 GB | ~240 GB |
| Minimum realistic hardware | 1× H100 80GB, or a 128GB Mac | Multi-GPU server (4× H100 at 4-bit) |
Meta states directly that Scout “fits in a single NVIDIA H100 GPU” with Int4 quantization, and that Maverick “fits on a single H100 host” — note the word host, meaning an 8-GPU node, not one card. An 8×H100 node provides 640GB, which comfortably holds Maverick at FP8 but not at BF16, where 800GB of weights alone exceeds the node. Full-precision Maverick needs H200-class memory or two nodes.
Practically: Scout is a single-GPU or single-workstation model and one of the more capable things you can run on a 128GB Mac Studio. Maverick is data-center-only. Use the VRAM calculator to check your own configuration and context depth.
| Spec | Llama 4 Scout | Llama 4 Maverick |
|---|---|---|
| Developer | Meta | Meta |
| Type | Multimodal (MoE) | Multimodal (MoE) |
| Parameters | 109B total / 17B active (MoE) | 400B total / 17B active (MoE) |
| Context window | 10M | 1M |
| Modality | Text, Image → Text | Text, Image → Text |
| License | Llama 4 Community (EU-restricted) | Llama 4 Community (EU-restricted) |
| Open weights | ✅ Yes | ✅ Yes |
| Input price ($/1M) | $0.1 | $0.2 |
| Output price ($/1M) | $0.3 | $0.8 |
| VRAM (4-bit) | ~65 GB | ~240 GB |
| Min GPU (local) | H100 80GB / Mac 128GB | Multi-GPU server |
| Released | 2025 | 2025 |
Key differences
- Cost: Llama 4 Scout is 133% cheaper than Llama 4 Maverick on a blended-token basis.
- Context: Llama 4 Scout wins on context window (10M vs 1M) — better for long documents, large codebases and big RAG inputs.
- Openness: both are open-weight, so either can be self-hosted or fine-tuned. Compare their VRAM needs above to see what your GPU can run.
- Run Llama 4 Scout locally: ~~65 GB at 4-bit (min H100 80GB / Mac 128GB).
- Run Llama 4 Maverick locally: ~~240 GB at 4-bit (min Multi-GPU server).
Which should you choose?
Choose Llama 4 Scout if you want the lower per-token cost for high-volume workloads, or you need the larger context window.
Choose Llama 4 Maverick if it fits your existing stack or you prefer Meta.
→ Estimate real costs in the API cost calculator · check local hardware in the VRAM calculator · browse all 30+ models.
API pricing across providers
Neither model is expensive by frontier standards; both are priced as commodity open-weight inference. Rates below are per 1M tokens and move frequently.
| Provider | Scout in / out | Maverick in / out |
|---|---|---|
| DeepInfra | $0.10 / $0.30 | $0.20 / $0.80 |
| Groq | $0.11 / $0.34 | — |
| DigitalOcean | — | $0.20 / $0.696 |
| NovitaAI | $0.18 / $0.59 | $0.27 / $0.85 |
| Parasail | — | $0.35 / $1.00 |
| Google Vertex | $0.25 / $0.70 | $0.35 / $1.15 |
Groq is the one to note for Scout: it is marginally more expensive than DeepInfra but offers cached input at $0.055 per 1M, which matters a great deal for agent loops that resend the same system prompt thousands of times. Parasail offers the equivalent for Maverick at $0.17.
What this actually costs
Assume a moderate production workload of 100M input and 20M output tokens per month at the cheapest mainstream rate:
- Scout: (100 × $0.10) + (20 × $0.30) = $16/month
- Maverick: (100 × $0.20) + (20 × $0.80) = $36/month
At ten times that volume the gap becomes $160 vs $360 per month. The ratio holds at roughly 2.25–2.3× regardless of scale, so the decision is not really about absolute dollars at small volumes — it is about whether Maverick’s reasoning and coding lead is worth a permanent doubling of unit cost. Run your own numbers in the API cost calculator.
Licensing: read the EU clause before you build
Both models ship under the Llama 4 Community License Agreement, which is open-weight and commercially usable but is not OSI-approved open source. Two restrictions matter in practice. First, products exceeding 700 million monthly active users require a separate license negotiated with Meta. Second — and far more likely to affect you — the license restricts multimodal use for entities and individuals domiciled in the European Union.
If you are an EU-based company planning to use the vision capabilities, this is a legal question to resolve before writing code, not after. Teams in that position often land on an alternative open-weight model with a cleaner license, such as an Apache-2.0 or MIT-licensed Qwen or GLM release.
Which should you pick?
Choose Llama 4 Scout if
- Your workload is documents, OCR, forms, charts or retrieval — where the benchmarks show near-parity
- You want to self-host on a single H100, a 128GB Mac, or a modest GPU box
- Per-token cost compounds at your volume and you want the ~2.3× saving
- You need the longest available context window and can work within provider caps
- You are prototyping and want the cheapest capable multimodal open-weight model
Choose Llama 4 Maverick if
- Your workload is genuinely reasoning-bound — scientific Q&A, analysis, multi-step logic
- You are generating or reviewing code, where the LiveCodeBench gap is 32% relative
- You already have multi-GPU infrastructure, or you are using it via API anyway
- You need the stronger multilingual and translation performance shown on MGSM and MTOB
- Accuracy on hard problems matters more than doubling your per-token cost
The pragmatic path for most teams: start on Scout, measure, and escalate only the queries that fail. Because both models take the same prompt format and the same multimodal inputs, routing hard queries to Maverick while serving the bulk on Scout is a small amount of engineering and usually beats standardizing on either one.
Frequently asked questions
Is Llama 4 Maverick better than Llama 4 Scout?
On reasoning and coding, clearly yes — Maverick leads by 12.6 points on GPQA Diamond and 10.6 on LiveCodeBench. On document and chart understanding the two are effectively tied, with identical 94.4 DocVQA scores. “Better” depends entirely on whether your workload is reasoning-bound or extraction-bound.
Can I really use Llama 4 Scout’s 10 million token context?
Not through a hosted API. Meta trained Scout to support 10M tokens, but providers serve between 128K and roughly 1.3M — Groq caps around 131K, DeepInfra around 320K, Together around 328K. Reaching 10M requires self-hosting, and the KV cache at that depth becomes larger than the model weights.
How much VRAM do I need to run Llama 4 Scout locally?
About 65GB at 4-bit including overhead, which fits a single 80GB H100 — Meta confirms this configuration. At FP8 you need roughly 109GB, and at BF16 roughly 218GB. A 128GB unified-memory Mac Studio can run it quantized.
Can Llama 4 Maverick run on a single GPU?
No. At 4-bit it needs roughly 240GB, which means about four H100s. Meta’s claim that it fits “a single H100 host” refers to an 8-GPU node at FP8, not one card. At BF16 its 800GB of weights exceed even a 640GB 8×H100 node.
How much cheaper is Scout than Maverick?
Roughly 2.3× on a blended 3:1 input-to-output basis — about $0.15 per 1M blended tokens versus $0.35. On a workload of 100M input and 20M output tokens per month, that is $16 versus $36.
Are Llama 4 models free to use commercially?
Mostly. The Llama 4 Community License permits commercial use, but products above 700 million monthly active users need a separate agreement with Meta, and multimodal use is restricted for EU-domiciled entities. It is open-weight, not OSI open source.
Why was Llama 4 Maverick’s LMArena score controversial?
Meta submitted an unreleased “experimental chat version” that scored 1417 ELO, but its outputs did not match the publicly downloadable weights. LMArena changed its policy on April 8, 2025 to require open-weight submissions to match published weights, and the unmodified model ranked substantially lower.
Bottom line
Scout and Maverick are the same engine with different-sized expert pools, and the decision between them is unusually clean because Meta’s own benchmarks draw the line for you. Maverick earns its premium on graduate-level reasoning and code generation, where double-digit gaps are too large to argue with. It earns nothing at all on document understanding, where it ties Scout outright while costing 2.3× more per token and requiring a data-center rack instead of a single GPU.
Two caveats to carry with you. Scout’s headline 10M context is not something you can rent today — plan around roughly 1.3M unless you are self-hosting. And Maverick’s 1417 LMArena figure should be struck from your evaluation entirely; it measured a model no one can download. Judge both models on the model-card benchmarks and, better still, on your own evaluation set — the gap between vendor marketing and shipped weights was the defining lesson of this particular launch.