Updated July 2026: Added real-world performance numbers, fine-tuning section, Behemoth status (shelved), corrected benchmarks based on community testing, and updated API pricing.

Llama 4 is Meta’s open-weight AI model family released April 2025. It comes in two usable versions: Scout (10M token context, fits on one H100) and Maverick (400B params, frontier-competitive). Both are free to download and run locally.

Fifteen months after launch, Llama 4 remains Meta’s terminal open-weight offering. Behemoth (2T+) was shelved due to MoE routing issues at scale. Muse Spark replaced it as Meta’s frontier model, but Muse Spark is closed-source. If you want open weights from Meta, Llama 4 is what you get.

Which Llama 4 model should you use?

Use Scout if:

• You need to process entire codebases or book-length documents (10M context)
• You want to run on a single GPU (fits on one H100, or one consumer GPU with quantization)
• Your task is long-context retrieval, summarization, or document Q&A

Use Maverick if:

• You need the best quality output Meta offers in open weights
• You are doing general coding, reasoning, or generation tasks
• You have access to 2+ GPUs or plan to use an API provider

Use neither (use something else) if:

• You need best-in-class coding: DeepSeek V4 Pro and Qwen 3.6-27B both beat Maverick on coding benchmarks
• You want the cheapest possible inference: DeepSeek V4 Flash at $0.28/M output is cheaper
• You need frontier quality regardless of cost: Claude Sonnet 5 or GPT-5.6 are stronger

Specs and architecture

Spec	Scout	Maverick	Behemoth
Total parameters	109B	400B	2T+
Active parameters	17B	17B	~288B
Experts	16 (1 active)	128 (1 active)	Unknown
Context window	10M tokens	1M tokens	N/A
Architecture	MoE + chunked attention	MoE + chunked attention	MoE
Multimodal	Text + images	Text + images	N/A
License	Meta Llama License	Meta Llama License	Never released
Status	Released (April 2025)	Released (April 2025)	Shelved

The MoE architecture is key: both Scout and Maverick activate only 17B parameters per token regardless of total size. This means inference cost scales with active params (17B), not total params (109B/400B). You get the knowledge of a large model at the cost of a small one.

Chunked attention (a variant of sliding window) means the model does not attend to previous tokens beyond 8192 boundaries, improving efficiency for long contexts.

Real-world benchmarks (July 2026)

Meta’s launch claims were optimistic. Community testing over 15 months tells a different story:

Benchmark	Maverick (real)	Scout (real)	DeepSeek V4 Pro	Claude Sonnet 5
SWE-bench Verified	49.2%	38.1%	80.6%	63.2%
Terminal-Bench 2.1	62.4%	51.8%	74.8%	Not published
HumanEval+	82.1%	76.3%	91.4%	89.7%
MMLU Pro	78.4%	72.1%	81.2%	83.6%
Long-context NIAH (128K)	94.2%	98.7%	91.3%	96.4%

Key takeaway: Maverick is not frontier-competitive on coding anymore. DeepSeek V4 Pro and Claude Sonnet 5 both decisively beat it. But Scout’s long-context performance (98.7% needle-in-a-haystack at 128K) is genuinely best-in-class, and the 10M context window has no equal in open weights.

For coding-first workloads, look at DeepSeek V4 Pro or Qwen 3.6. For long-context retrieval, Scout remains unbeatable.

Running Llama 4 locally

Hardware requirements

Setup	Scout	Maverick
Full precision (BF16)	113 GB (1x H100)	422 GB (5x H100)
Q4_K_XL (best quality local)	66 GB (1x A100 80GB)	243 GB (3x A100)
IQ2_XXS (Unsloth dynamic)	38.5 GB (1x RTX 4090 + RAM)	140 GB (2x A100)
IQ1_S (minimum viable)	33.8 GB (24GB GPU + CPU offload)	122 GB (2x RTX 4090)

Performance numbers

Based on community testing (estimates, treat as rough ranges):

Hardware	Model	Quantization	Speed
M4 Max 128GB	Scout	Q4_K_XL	15-32 tok/s
RTX 4090 24GB	Scout	IQ2_XXS (MoE on CPU)	~20 tok/s
2x RTX 4090	Maverick	IQ1_S	~40 tok/s
H100 80GB	Scout	BF16	~800 tok/s
H100 80GB	Scout	Q4_K_XL	~1200 tok/s

Setup with Ollama (easiest)

# Scout - fits in 32GB+ RAM with default quantization
ollama pull llama4-scout
ollama run llama4-scout "Analyze this code for security issues"

# With specific quantization for tighter hardware
ollama pull llama4-scout:q4_k_m

Ollama pulls Q4_K_M by default. For Scout on a 24GB GPU, you need heavier quantization or CPU offload.

Setup with llama.cpp (most control)

# Build llama.cpp with GPU support
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j \
    --clean-first --target llama-cli

# Download Unsloth dynamic quant (best quality-per-byte)
pip install huggingface_hub hf_transfer
huggingface-cli download unsloth/Llama-4-Scout-17B-16E-Instruct-GGUF \
    --include "*IQ2_XXS*" --local-dir ./models/

# Run with MoE layers offloaded to CPU (key trick for consumer GPUs)
./llama.cpp/build/bin/llama-cli \
    --model ./models/Llama-4-Scout-17B-16E-Instruct-UD-IQ2_XXS.gguf \
    --threads 16 \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    -ot ".ffn_.*_exps.=CPU" \
    --temp 0.6 --min-p 0.01 --top-p 0.9 \
    -no-cnv \
    --prompt "Your prompt here"

The -ot ".ffn_.*_exps.=CPU" flag is critical. It offloads all MoE expert layers to CPU while keeping attention on GPU. This lets Scout fit on a single 24GB GPU with dramatically better speed than full CPU inference.

Meta’s recommended inference settings: Temperature 0.6, Min_P 0.01, Top_P 0.9.

For more on local AI setup, see our Ollama guide and LM Studio guide.

Fine-tuning Llama 4

Fine-tuning Llama 4 is practical thanks to QLoRA and Unsloth:

Scout fine-tuning (single GPU)

# Install Unsloth
pip install unsloth

# Fine-tune Scout on a single H100 80GB or A100 80GB
# Uses QLoRA (4-bit base + LoRA adapter)
python -m unsloth.train \
    --model unsloth/Llama-4-Scout-17B-16E-Instruct-unsloth-bnb-4bit \
    --dataset your_dataset.jsonl \
    --output ./scout-finetuned \
    --lora_r 16 \
    --epochs 3 \
    --learning_rate 2e-4

What you need:

• Scout fine-tune: 1x H100 80GB or A100 80GB (QLoRA, ~3 hours for 10K samples)
• Maverick fine-tune: 2x H100 80GB minimum (not practical for most teams)
• Consumer GPU: Not feasible for fine-tuning, only inference

Unsloth makes it 1.5x faster with 50% less VRAM than standard training, and supports 8x longer context lengths than Flash Attention 2 alone.

When to fine-tune vs use prompting:

• Fine-tune when you need consistent domain-specific behavior (legal language, medical terms, company style)
• Use prompting when you need flexibility or are prototyping
• Fine-tune when inference volume is high (amortize training cost over millions of tokens)

For fine-tuning alternatives, see DeepSeek V4 Pro (MIT license, easier to modify) or Gemma 4 12B (small enough to fine-tune on consumer GPUs).

API access and pricing

Since Llama 4 is open-weight, multiple providers host it at competitive prices:

Provider	Scout (input/output)	Maverick (input/output)	Speed	Notes
Together AI	$0.10 / $0.10	$0.49 / $0.49	~800 tok/s	Cheapest, serverless
Fireworks AI	$0.12 / $0.12	$0.50 / $0.50	~900 tok/s	Fast inference
OpenRouter	$0.15 / $0.15	$0.60 / $0.60	Varies	Multi-provider routing
AWS Bedrock	$0.18 / $0.18	$0.65 / $0.65	~700 tok/s	Enterprise compliance
Spheron	$0.36/M (spot H100)	N/A	~800 tok/s	Self-managed

For comparison: Claude Sonnet 5 costs $2/$10, Gemini 3.6 Flash costs $1.50/$7.50. Llama 4 Maverick via API is 10-20x cheaper than proprietary alternatives.

Use OpenRouter for multi-model routing, or see AI API Pricing Compared 2026 for the full pricing landscape.

Multimodal capabilities

Llama 4 supports native image input. Both Scout and Maverick can process images alongside text:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.together.xyz/v1",
    api_key="your-key"
)

response = client.chat.completions.create(
    model="meta-llama/Llama-4-Maverick-17B-128E-Instruct",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What bugs do you see in this screenshot?"},
            {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}},
        ],
    }],
    temperature=0.6,
    top_p=0.9,
)
print(response.choices[0].message.content)

Use cases: UI bug detection, document OCR, visual debugging, architecture diagram analysis. Vision quality is competitive with GPT-4o-class models for basic understanding, though not as strong as Gemini 3.6 Flash for complex visual reasoning.

What happened to Behemoth?

Behemoth (2T+ parameters) was announced alongside Scout and Maverick in April 2025. It was meant to be a “teacher” model for distilling knowledge into smaller models.

Status as of July 2026: Effectively shelved.

Meta encountered mid-training MoE routing and chunked attention issues at 2T scale. They lost confidence the gains justified shipping. No public cancellation, no timeline, no indication it will ever release.

Meta’s frontier strategy shifted to Muse Spark (released April 2026), which is closed-source. For open-weight users, Llama 4 Scout and Maverick are the end of the line from Meta for now.

Llama 4 vs alternatives (July 2026 honest take)

Need	Best choice	Why not Llama 4?
Best open-weight coding	DeepSeek V4 Pro	80.6% vs 49.2% SWE-bench
Cheapest frontier inference	DeepSeek V4 Flash	$0.28/M vs $0.49/M
Longest context (open)	Llama 4 Scout	Nothing beats 10M tokens open-weight
Best closed-source coding	Claude Sonnet 5	63.2% SWE-bench, 1M context
Run on consumer GPU	Gemma 4 12B	12B dense, runs on 16GB RAM
Fine-tuning friendly	Qwen 3.6-27B	Apache 2.0, smaller, easier
Enterprise compliance	Llama 4 via Bedrock	Actually good here (SOC2, etc.)

For the full landscape of open-weight alternatives, see our Best Open Source Coding Models 2026 roundup. If Qwen interests you, check How to Run Qwen 3.6 Locally.

Llama 4’s real strengths in 2026:

1. 10M context window (Scout) - genuinely unmatched in open weights
2. Massive ecosystem support (every provider, every framework)
3. Multimodal native (text + images, no separate model needed)
4. Enterprise-grade hosting options (Bedrock, Azure, GCP)

Llama 4’s real weaknesses in 2026:

1. Coding performance lags significantly behind DeepSeek V4 and Qwen 3.6
2. Behemoth is dead, Muse Spark is closed - no upgrade path
3. Meta’s Llama license is more restrictive than MIT/Apache alternatives
4. Community has found quantization issues in specific MoE layers (1st, 3rd, 45th in Maverick)

• Granite 4.1 vs Llama 4 Scout — Dense vs MoE for Coding (2026)

• How to Run Llama 4 Locally

FAQ

Is Llama 4 free?

Yes. Llama 4 is free to download and use under Meta’s Llama license, which permits commercial use for organizations with fewer than 700 million monthly active users. Self-host at no cost, or access via API starting at $0.10 per million tokens through Together AI.

Can I run Llama 4 Scout on a Mac?

Yes. Scout runs on Apple Silicon Macs with 32GB+ unified memory using Q4 quantization via Ollama or llama.cpp. Expect 15-32 tok/s on an M4 Max. For 16GB Macs, use IQ2_XXS quantization (38.5 GB disk, but works with memory mapping).

Should I use Llama 4 or DeepSeek V4 for coding?

DeepSeek V4 Pro. It scores 80.6% on SWE-bench Verified vs Maverick’s 49.2%. The gap is too large to ignore. Use Llama 4 only if you specifically need the 10M context window (Scout) or prefer Meta’s ecosystem and enterprise support.

Can I fine-tune Llama 4?

Yes. Scout can be fine-tuned on a single H100/A100 80GB GPU using QLoRA through Unsloth (~3 hours for 10K samples). Maverick requires 2+ H100s. Consumer GPUs are not practical for fine-tuning, only inference.

What is the difference between Scout and Maverick?

Scout has 10M context with 16 experts (109B total), best for long-document processing. Maverick has 1M context with 128 experts (400B total), delivering higher quality output for general tasks. Both activate the same 17B parameters per token, so inference cost is similar. Choose Scout for context length, Maverick for output quality.

Is Behemoth ever coming?

Unlikely. Meta shelved it due to technical issues at 2T scale and shifted their frontier strategy to Muse Spark (closed-source). As of July 2026, there is no timeline or indication of release.

Related Articles