Llama 4 Scout: 10M Context, Native Multimodal

Overview

Llama 4 is Meta’s first mixture-of-experts release. Scout has 109B parameters in total but routes each token through one of 16 experts, so only 17B parameters do work per token. Meta’s card puts its pre-trained MMLU at 79.6 against 79.3 for the dense Llama 3.1 70B, which is the comparison Meta itself draws. The catch for local use is that all 109B parameters still have to sit in memory; the routing saves compute, not space.

The two headline features are a 10-million-token context window (the Maverick sibling is 1M) and native image input through what Meta calls early fusion: text and image tokens enter the same transformer rather than an image encoder being bolted on afterwards. Meta says the model has been tested with up to five input images.

Pretraining used about 40 trillion tokens across 200 languages, with 12 languages officially supported. On consumer hardware the realistic entry point is a 48 GB setup (two 24 GB cards) running a 2-bit build, or a 64 GB Mac at 3-bit; see the hardware section and the MoE VRAM calculator.

Llama 4 Scout model card: 109B total, 17B active, 10M context

Meta’s model card lists Llama 4 Scout (17Bx16E) at 17B activated and 109B total parameters with a 10M context length; the Hugging Face API counts 108,641,793,536 parameters in the BF16 safetensors. The rest of the card’s facts:

From Meta’s Llama 4 model card and the Hugging Face model page. There are two checkpoints, the pretrained Llama-4-Scout-17B-16E and the instruction-tuned Llama-4-Scout-17B-16E-Instruct; the Ollama tags are the instruct model.

Architecture

Why MoE matters for local AI

Each token activates one of the 16 experts plus the shared block, so the arithmetic per token is that of a roughly 17B dense model while the parameters that could be consulted number 109B. That is where the “70B quality at 17B cost” framing comes from, and Meta’s own tables bear part of it out (Scout’s MMLU-Pro 58.2 vs 53.8 for Llama 3.1 70B, pre-trained). The trade-off is that all 109B parameters must be resident: a 4-bit Scout is 65 GB, a 4-bit Llama 3.3 70B is 43 GB. Runtimes that keep the experts in system RAM and stream the active ones to the GPU exist, but this site has not measured how fast that is, so no speed figure is quoted. The MoE VRAM calculator does the split arithmetic for any MoE model.

Interleaved attention: how 10M positions are reached

The configuration alternates two kinds of layer. Thirty-six layers use rotary position embeddings with the Llama 3 scaling recipe (factor 16 over the 8,192 base, up from factor 8 in Llama 3.1) and attend within 8,192-token chunks; the other twelve, every fourth layer, use no positional embedding at all and attend across the whole sequence. Meta’s announcement calls this iRoPE. The practical consequence for memory is in the next section: only the twelve global layers have a cache that grows with the full window.

The 10M context window: official, and what it costs

The 10 million token context is official: Meta’s model card lists “10M”, the configuration sets 10,485,760 maximum positions, and Ollama lists every Scout tag with a 10M context window. Nobody runs it at that length on a local machine, because the key-value cache for 10M tokens is measured in hundreds of gigabytes even under the most favourable reading of the configuration:

Add the 65 GB of Q4_K_M weights and a 128K context lands between 73 and 92 GB, a 1M context between 120 and 272 GB. Ollama opens a 4,096-token window by default regardless of the tag’s listed context, so you set the window you can afford: /set parameter num_ctx 131072 inside ollama run, OLLAMA_CONTEXT_LENGTH=131072 ollama serve, or num_ctx in the API request.

The only long-context evaluation on Meta’s card is MTOB, translating between English and Kalamang from a grammar book held in context: Scout scores 42.2 / 36.6 chrF on the half-book task and 39.7 / 36.3 on the full book, where the Llama 3.x models cannot be scored because their window is 128K. Meta publishes no needle-in-a-haystack or other long-context benchmark for Scout on the card.

Benchmarks published by Meta

Meta reports Scout’s pre-trained MMLU as 79.6 (5-shot) and the instruct model’s MMLU Pro as 74.3 and GPQA Diamond as 57.2. These are Meta’s own results on the BF16 weights; the card compares Llama 4 only with earlier Llama models and contains no figures for any other company’s models. Earlier versions of this page quoted a GPQA of 84.8 and a SWE-bench of 70.3; neither appears on the card and both have been removed.

Source: Meta’s Llama 4 model card. To see how these scores sit against other local and hosted models, check the AI model leaderboard.

Llama 4 Scout vs Llama 3.3 70B

On Meta’s instruct table Scout beats Llama 3.3 70B on MMLU Pro (74.3 vs 68.9) and GPQA Diamond (57.2 vs 50.5), ties it on LiveCodeBench (32.8 vs 33.3) and MGSM (90.6 vs 91.1), and adds image input and a far longer window. Llama 3.3 70B needs 43 GB at 4-bit; Scout needs 65 GB. The card has no MMLU row for the instruct models, so the “79.6 vs 79.3” comparison that circulates is the pre-trained Scout against the pre-trained Llama 3.1 70B, not 3.3.

The honest summary: if you have 48 GB and want the best text model that fits, Llama 3.3 70B at Q4_K_M is the safer pull, because Scout at that memory is a 2-bit build. If you have 80 GB or more, or need image input or a window past 128K, Scout is the one Meta’s own numbers favour.

Hardware requirements: how much VRAM does Llama 4 Scout need?

About 68 GB at Q4_K_M with an 8K context, so the standard setup is an 80 GB card, a Mac with 96 GB of unified memory, or two 48 GB cards. A 48 GB setup (two 24 GB cards) runs the 2-bit builds, which are 37–42 GB files. No single 24 GB card holds any build: the smallest file that exists is 29 GB. The arithmetic is parameters × bits per weight ÷ 8: 108.64B × 4.81 bits ÷ 8 = 65.4 GB at Q4_K_M, which matches the published file.

File sizes are from unsloth/Llama-4-Scout-17B-16E-Instruct-GGUF (multi-part files summed) and Ollama’s tag list. The context cache is 1.6 GB for 8,192 tokens (arithmetic above). “Memory needed” is file + that cache + a 1 GB allowance for buffers; add the 1.75 GB vision projector (mmproj) if you use image input with llama.cpp.

• One 24 GB card (RTX 3090, 4090): nothing fits entirely. Ollama and llama.cpp will split the model between the card and system RAM; with 64 GB of RAM the default 67 GB build loads, but most of the experts live in RAM. This site has not measured how fast that runs.
• Mac: the same totals apply to unified memory. 64 GB runs the Q3 builds, 96 GB the default Q4_K_M, 128 GB the Q8_0.
• No GPU: the file loads into system RAM, so 96 GB of RAM covers Q4_K_M; see running an LLM on CPU only.
• Disk: the download size in the table, once per build you pull.
• Meta’s own figure: the card says Scout “can fit within a single H100 GPU with on-the-fly int4 quantization”, which is the 80 GB tier in the table.

For what else fits each tier see best LLM for 24 GB of VRAM, best LLM for 32 GB of VRAM and best LLM for 64 GB of RAM; splitting a model across cards is covered in the Ollama multi-GPU guide, and the build names in quantization explained.

Quick start with Ollama

With Ollama installed, pull the tag that matches your memory. Every tag below is on ollama.com/library/llama4/tags; all are listed with text and image input.

# Default Scout build: Q4_K_M, 67 GB — for 80 GB of memory
ollama pull llama4:scout
ollama run llama4:scout

# Raise the context window inside a session (default is 4,096)
/set parameter num_ctx 32768

# Or set it for the server
OLLAMA_CONTEXT_LENGTH=32768 ollama serve

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Text-only query
response = client.chat.completions.create(
    model="llama4:scout",
    messages=[
        {"role": "user", "content": "Explain MoE architectures in 3 sentences"}
    ]
)

# Image + text query
import base64
with open("chart.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="llama4:scout",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What does this chart show?"},
            {"type": "image_url", "image_url": {
                "url": f"data:image/png;base64,{image_data}"
            }}
        ]
    }]
)

ollama pull llama4:scout
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  ghcr.io/open-webui/open-webui:main

Multimodal capabilities

Meta’s card describes the Llama 4 models as “natively multimodal”, using early fusion: image tokens from the 34-layer vision encoder enter the same transformer as the text, rather than a separate vision model being attached after the fact. The card lists the instruct model as “optimized for visual recognition, image reasoning, captioning, and answering general questions about an image”, tested with up to five input images. Its published image scores:

Whether Scout is the right local vision model depends on memory: it is the only one on this page that needs 80 GB. For the alternatives that fit a single card, see best local vision models and the guide to local vision tasks (OCR, invoices, alt-text).

Licence: the Llama 4 Community License

Llama 4 is released under the Llama 4 Community License Agreement (effective 5 April 2025). Meta describes it as a custom commercial licence; it is not an open-source licence such as MIT or Apache 2.0. The terms that matter in practice:

• Commercial use is permitted, along with modification and redistribution.
• If you distribute the model, a derivative, or a product or service that contains it, you must include the licence and “prominently display ‘Built with Llama’” on a related website, interface, blog post, about page or documentation.
• A model you train or fine-tune from it and distribute must “include ‘Llama’ at the beginning of any such AI model name”.
• “If, on the Llama 4 version release date, the monthly active users of the products or services made available by or for Licensee, or Licensee’s affiliates, is greater than 700 million monthly active users in the preceding calendar month, you must request a license from Meta.”
• Use must comply with the Llama 4 Acceptable Use Policy, and the card lists use in languages or capabilities beyond the 12 supported languages as out of scope.

The licence text as published on GitHub, on Meta’s developer site and in the Hugging Face access prompt was checked on 15 October 2026 and contains no clause restricting use by region. This is a summary, not legal advice; read the licence before building a product on it. Other model licences are compared in LLM licences for commercial use.

Where Scout fits, and where it does not

Advanced setup

# Llama 4 Scout Modelfile
FROM llama4:scout

PARAMETER temperature 0.2
PARAMETER top_p 0.9
PARAMETER num_ctx 65536

SYSTEM """You are a precise document analyst. When given images
or text, extract key information accurately. Cite specific
sections. Be thorough but concise."""

ollama create scout-analyst -f Modelfile
ollama run scout-analyst

# Files from huggingface.co/unsloth/Llama-4-Scout-17B-16E-Instruct-GGUF
#   Llama-4-Scout-17B-16E-Instruct-UD-IQ2_XXS.gguf   37.4 GB
#   mmproj-F16.gguf                                    1.75 GB (image input)

./llama-cli -m Llama-4-Scout-17B-16E-Instruct-UD-IQ2_XXS.gguf \
  -ngl 99 -c 8192 --temp 0.3 -p "Summarise the attached document"

# 32K context: about 70 GB total at Q4_K_M
OLLAMA_CONTEXT_LENGTH=32768 ollama serve

# 128K context: 73–92 GB total depending on how the runtime caches the chunked layers
OLLAMA_CONTEXT_LENGTH=131072 ollama serve

Frequently asked questions

Sources

• Meta: Llama 4 model card — parameters, context, languages, training data, benchmark tables, the single-H100 statement
• Llama 4 Community License Agreement — the licence text
• Hugging Face: meta-llama/Llama-4-Scout-17B-16E-Instruct — original weights, parameter count
• config.json (ungated mirror) — layers, heads, experts, positions, chunk size
• unsloth GGUF files — the file sizes in the hardware table
• Ollama: llama4 tags — every tag with its download size and context
• Ollama FAQ — the 4,096-token default context window
• Meta’s Llama 4 announcement — the iRoPE description