Skip to content
,

Mistral Large 4 Open Weights Are Out: License, File Sizes and Hardware to Run It

13–19 minutes
Woman holding a tablet that reads "MISTRAL", with the text "Mistral large 4 is open"

Update, November 2, 2026: the wait is over. Mistral published the Mistral Large 4 open weights on Hugging Face on October 29, 2026, two days ahead of the October 31 ETA, at mistralai/Mistral-Large-4-1T-A52B.

The license is the new Mistral Ecosystem Open-Weight License (a modified MIT license), the official checkpoint is FP8 at about 1.06 TB, an official NVFP4 build is about 610 GB, and Unsloth and ggml-org already have GGUF files from 233 GB (1-bit) upward.

It is a 1.05 trillion parameter, natively multimodal mixture-of-experts model with a 1M token context window.

This guide now covers the real release: the license terms, every file size, how to run it with vLLM, SGLang and llama.cpp, and an honest look at the hardware you need, from a cloud server down to a home workstation.

TL;DR

  • Mistral Large 4 (“Le Chonk”) is a 1.05T parameter MoE with 49B active parameters per token (52B counting embeddings and output layers), a 1.6B vision encoder and a 1M token context.
  • Released: open weights went live on Hugging Face on October 29, 2026 (mistralai/Mistral-Large-4-1T-A52B, plus an official -NVFP4 repo). Architecture: 128 routed experts, 4 active per token, plus 1 shared expert.
  • License: Mistral Ecosystem Open-Weight License, a modified MIT license. Commercial use and fine-tuning are allowed; only companies selling it as a hosted model service (MaaS) need a separate commercial license. It is not Apache 2.0 like Large 3.
  • Real file sizes: FP8 about 1.06 TB, NVFP4 about 610 GB, Unsloth GGUF UD-IQ1_S 233 GB, UD-Q2_K_XL 378 GB, UD-Q4_K_XL 605 GB, Q8_0 1.12 TB.
  • Home use: the smallest 1-bit GGUF needs a 256 GB RAM machine (Unsloth names a Mac Studio or two DGX Sparks). A single RTX 5080 cannot run it; use the API ($1.36 in / $4.18 out per million tokens) or Ollama’s :cloud tag.

Mistral Large 4 Open Weights Release Date

Here is the full timeline, updated November 2, 2026:

Date Event Status
October 6, 2026 Mistral Large 4 public preview launched on Mistral’s API (model ID mistral-large-4, version v26.10) Done
October 2026 Red-teaming with cybersecurity partners, vetted organizations and state authorities Done
October 29, 2026 Open weights published on Hugging Face (mistralai/Mistral-Large-4-1T-A52B in FP8 and mistralai/Mistral-Large-4-1T-A52B-NVFP4), with the license and full model card Released
Within days Community GGUF builds from ggml-org and Unsloth (1-bit to BF16), plus vLLM and SGLang Docker images Available

Mistral beat its own October 31 estimate by two days. The weights are not gated, so you can download them straight away, but read the license section below first if you plan to offer it as a hosted service.

Specs: What We Know So Far

Spec Mistral Large 4 Source
Nickname “Le Chonk” Mistral launch post
Architecture Granular mixture of experts, hybrid instruct and reasoning Mistral launch post
Total parameters 1.05 trillion Mistral docs
Active parameters 49B per token, 52B including embeddings and output layers Hugging Face page
Vision encoder 1.6B parameters, native image input Mistral docs
Context window 1M tokens Mistral docs
Languages 160+, including all official EU languages Mistral launch post
Training From scratch on 3,800 NVIDIA Grace Blackwell GPUs in Europe Mistral launch post
Experts 128 routed experts, 4 active per token, plus 1 shared expert Hugging Face model card
Reasoning Configurable effort: low, medium, high (default high) Hugging Face model card
Speculative decoding Built-in DSpark draft head (3 tokens per step, up to 1.9x throughput) Hugging Face model card
Official formats FP8 (about 1.06 TB) and NVFP4 (about 610 GB) Hugging Face, vLLM recipe
License Mistral Ecosystem Open-Weight License (modified MIT) Hugging Face model card

The “49B or 52B active” question confused a lot of people in the first week, since the launch post says one and the docs card says the other.

The Hugging Face page settles it: 49B is the count for the transformer blocks, and 52B adds the embedding and output layers. That is also why the repo name ends in A52B.

Only about 4.7 percent of the weights are active for any given token. That matters a lot for running the model, as we will see below, because it means speed depends on the 49B active slice while memory depends on the full 1.05T.

Mistral Large 4 vs Mistral Large 3

Mistral Large 3 Mistral Large 4
Total parameters 675B 1.05T
Active parameters 41B 49B (52B with embeddings)
Context 256K 1M
Vision Not stated 1.6B encoder, native
License Apache 2.0 Mistral Ecosystem Open-Weight License (modified MIT)
API price (in / out per 1M tokens) $0.50 / $1.50 $1.36 / $4.18
Weights On Hugging Face On Hugging Face since October 29, 2026

Large 4 is about 55 percent bigger in total parameters but only about 20 percent bigger in active parameters, with four times the context. It is also nearly three times more expensive through the API, which tells you Mistral sees it as a frontier product rather than a cheap workhorse.

Benchmarks

All of these are vendor-reported, and the coding results were run privately, so treat them as claims until independent tests arrive with the weights.

Area Benchmark Mistral Large 4
Cybersecurity Cybench (40 challenges) 93%
Cybersecurity Vulnerability reproduce-and-patch (CyberGym-style end to end) 82%
Coding DeepSWE v1.1 61.7%
Coding SWE-Atlas-QnA 59.4%
Coding Terminal-Bench 4 28.3%
Coding Artificial Analysis Coding Agent Index 49.8%
Agents AutomationBench (657 workflows) 59.9%
Multimodal Dense 200 42%
Safety Lakera B3 attacks resisted 93.3%
Human eval Surge AI blind coding evaluation (1 to 5) 3.74, second of five

The cybersecurity numbers are the headline. Mistral says several closed frontier models score near zero on the reproduce-and-patch test because they refuse the task, while Large 4 completes it. That, combined with self-hosting, is clearly the pitch to security teams: a capable model you can run on-premise, where your data never leaves the building.

In the Surge AI blind human evaluation of coding, Large 4 placed second of five models, behind Claude Opus 5 (4.22) and ahead of Kimi K3 (3.59). In finance and legal tasks, vals.ai reports it ahead of GPT-6 Astra on representative tasks, and Mistral claims it outperforms every open-source model on Harvey’s Legal Agent benchmark.

Pricing and How to Use It Today

You do not have to wait for the weights to try it.

Where Input / 1M tokens Cached input Output / 1M tokens Notes
Mistral API (list price) $1.36 $0.14 $4.18 Model ID mistral-large-4
Ollama Cloud (mistral-large-4:cloud) $0.68 $0.07 $2.09 Runs on Ollama’s servers, not your PC
OpenRouter $0.68 – $2.09 Promotional price, 524K context listed

The Ollama route is handy if you already use Ollama for local models, because the command is the same as for a local model:

ollama run mistral-large-4:cloud

Be clear about what that is, though. The :cloud tag sends your prompts to Ollama’s hosted servers.

Now that the weights are out, a true local run is possible through Unsloth’s GGUF (for example ollama run hf.co/unsloth/Mistral-Large-4-1T-A52B-GGUF:UD-Q4_K_XL), but even the smallest file is 233 GB, so the cloud tag is still the only practical Ollama route on a normal PC.

Ollama also lists launch shortcuts for coding agents, such as ollama launch claude --model mistral-large-4:cloud and ollama launch opencode --model mistral-large-4:cloud, if you want to test it as a coding model.

Mistral Large 4 License: What You Can and Cannot Do

It is not Apache 2.0. Large 4 ships under a new Mistral Ecosystem Open-Weight License, which Mistral describes as a modified MIT license. In plain terms:

  • Allowed: personal use, research, fine-tuning, building products on it, and running it inside your company for your own staff, with no license fee.
  • The catch: if you sell access to the model itself as a hosted service (model-as-a-service, like an inference API), you need a separate commercial license from Mistral.
  • No gate: the Hugging Face repo can be downloaded without an access request.

For home users and most businesses this is effectively as open as Apache 2.0. The MaaS clause mainly targets cloud providers who would otherwise resell Large 4 without paying Mistral. Always read the LICENSE file in the repo yourself before a commercial launch.

Hardware: What It Takes to Run Mistral Large 4

Now that the weights are out, we have real file sizes instead of guesses. These are the published sizes of the official checkpoints and the Unsloth GGUF builds. You need extra memory on top for the KV cache, which grows with context length.

File Real size What can hold it
Official FP8 (mistralai/Mistral-Large-4-1T-A52B) about 1.06 TB 8x B200 or 8x B300, two 8x H200 nodes, or 8x AMD MI350X (validated vLLM setups)
Official NVFP4 (-NVFP4 repo) about 610 GB Blackwell GPUs, about 76 GiB per GPU on 8 GPUs; Mistral says 4x B200/B300 for a quantized run
GGUF Q8_0 1.12 TB 1.2 TB+ RAM servers
GGUF UD-Q4_K_XL 605 GB 768 GB RAM server plus a GPU
GGUF UD-Q3_K_XL 493 GB 512 GB unified memory, short context
GGUF UD-Q2_K_XL 378 GB 384 to 512 GB RAM
GGUF UD-IQ2_XXS 302 GB 384 GB RAM
GGUF UD-IQ1_S 233 GB 256 GB RAM, for example a Mac Studio or two DGX Sparks (per Unsloth)

For reference, here is the estimate table I published before release, worked out as parameters times bits per weight divided by eight. It held up well: the real Q4 and 1-bit files landed within a few percent of these numbers.

Precision Approx. bits per weight Weights only (estimate) What could hold it
BF16 16 about 2.1 TB Multiple servers
FP8 (likely release format) 8 about 1.05 TB 8x H200 (1,128 GB) with little room left, or B200-class servers
Q4-class GGUF about 4.5 about 590 GB 8x H100 (640 GB) is tight; large CPU RAM servers
Q3-class GGUF about 3.5 about 460 GB 512 GB unified memory or RAM, little room for context
Q2-class GGUF about 2.6 about 340 GB 384 to 512 GB RAM workstations
Dynamic 1.x-bit about 1.7 about 220 GB 256 GB RAM plus a GPU, with real quality loss

The FP8 guess was right: the official checkpoint is FP8. For comparison, Mistral’s own card for Large 3 called for a single node of H200 or B200 GPUs. With roughly 55 percent more weights, Large 4 at FP8 fills a whole 8x H200 node before you add any context.

Why MoE makes home use possible at all

A dense 1 trillion parameter model would be hopeless outside a data center. With a mixture of experts, each token only touches about 49B parameters. At 4-bit that is roughly 28 GB of weights read per token.

If those weights sit in system RAM with around 400 GB/s of bandwidth, the theoretical ceiling is somewhere around 10 to 14 tokens per second, and real-world numbers will be lower. That is slow but usable for batch jobs, coding questions and document analysis.

It is the same logic that lets people run very large MoE models with llama.cpp’s expert offloading, where the shared layers live on the GPU and the experts stream from RAM.

Can You Run It at Home?

Here is a realistic breakdown by machine.

Machine Can it run Large 4? Best option
Gaming PC: one 16 GB GPU, 32 to 64 GB RAM (for example an RTX 5080) No API or Ollama Cloud. Use smaller local models.
Workstation: 24 to 32 GB GPU, 128 GB RAM No Same as above
Workstation: 24 to 48 GB GPU, 256 GB RAM Maybe, at about 1.7 bits Unsloth UD-IQ1_S GGUF (233 GB) with experts in RAM; expect real quality loss
Mac Studio or similar with 512 GB unified memory Likely at 2 to 3 bits MLX or GGUF Q2/Q3, short context
Server: 512 GB to 1 TB RAM, multi-channel DDR5, one or two GPUs Yes, at 4-bit llama.cpp with expert offloading
8x H200 or B200 node Yes, at FP8 vLLM or SGLang, the way Mistral intends

On my own RTX 5080 with 16 GB of VRAM, Large 4 is simply not a local model, and I would be suspicious of any guide that says otherwise.

The 49B active slice alone is bigger than the card at any useful precision, and the full model is many times bigger than typical desktop RAM.

That does not make it irrelevant to home users: the API is the practical way in, and open weights mean third-party hosts can compete on price, which tends to push costs down fast.

I covered the same question for Meta’s giant open model in Can You Run Meta Muse Spark Open Locally?, and the conclusions are similar: unified-memory machines and big-RAM servers are the realistic home path for trillion-scale MoE models.

How to Run Mistral Large 4 Now (vLLM, SGLang, llama.cpp)

These commands come from the official model card and the Unsloth GGUF page. Pick the one that matches your hardware.

vLLM on an 8-GPU server (recommended by Mistral)

docker run --gpus all -p 8000:8000 vllm/vllm-openai:mistral-large-4 \
  mistralai/Mistral-Large-4-1T-A52B \
  --tensor-parallel-size 8 \
  --tool-call-parser mistral --reasoning-parser mistral \
  --enable-auto-tool-choice --gpu-memory-utilization 0.85 \
  --speculative-config '{"method": "dspark", "num_speculative_tokens": 3}'

Or pip install vllm and run vllm serve "mistralai/Mistral-Large-4-1T-A52B" with the same flags. If you run out of memory, lower --max-model-len or --max-num-seqs. On Blackwell GPUs, swap in mistralai/Mistral-Large-4-1T-A52B-NVFP4 to roughly halve the memory.

SGLang

sglang serve --model-path mistralai/Mistral-Large-4-1T-A52B --tp-size 8 --mem-fraction-static 0.85

The official Docker image is lmsysorg/sglang:mistral-large-4. It serves on port 30000 by default.

llama.cpp with a GGUF (big-RAM workstation or Mac)

# install: winget install llama.cpp (Windows) or curl -LsSf https://llama.app/install.sh | sh
llama cli -hf unsloth/Mistral-Large-4-1T-A52B-GGUF:UD-IQ1_S
# or, for an OpenAI-compatible server
llama serve -hf unsloth/Mistral-Large-4-1T-A52B-GGUF:UD-Q2_K_XL

Add the vision projector with --mmproj mmproj-F16.gguf if you want image input. Unsloth also ships a small DSpark draft model (about 2.25 GB at Q8_0) for speculative decoding. Use a current llama.cpp build, because older builds do not know the new architecture.

Recommended settings

  • Temperature 1.0 and top_p 0.95, per Mistral’s model card.
  • Reasoning effort: high for agentic and complex work, medium for daily use, low for quick chat.
  • Start with short context. The KV cache for anything near 1M tokens is enormous. Test at 8K to 32K first.
  • Test your own tasks. 1-bit and 2-bit builds lose real quality. Compare against the API on your real prompts before you commit to a quant.

FAQ

When were the Mistral Large 4 open weights released?

On October 29, 2026, on Hugging Face at mistralai/Mistral-Large-4-1T-A52B (FP8) and mistralai/Mistral-Large-4-1T-A52B-NVFP4. That was two days before the October 31 ETA.

How many parameters does Mistral Large 4 have?

1.05 trillion in total, with 49B active per token in the transformer blocks, or 52B including the embedding and output layers. It also has a 1.6B parameter vision encoder.

What is the context window?

1M tokens, according to Mistral’s docs. Some third-party hosts list less, for example OpenRouter showed 524K.

Can I run Mistral Large 4 with Ollama?

Yes, two ways. ollama run mistral-large-4:cloud runs on Ollama’s servers. For a true local run, ollama run hf.co/unsloth/Mistral-Large-4-1T-A52B-GGUF:UD-Q4_K_XL pulls the 605 GB GGUF, or pick the 233 GB UD-IQ1_S tag for a 256 GB RAM machine.

Is Mistral Large 4 open source?

It is open weights under the Mistral Ecosystem Open-Weight License, a modified MIT license. You can use, fine-tune and build commercial products on it. Only companies offering it as a hosted model service need a separate commercial license. It is not Apache 2.0 like Large 3.

Can an RTX 4090 or RTX 5090 run it?

Not on its own. The smallest published GGUF (UD-IQ1_S) is 233 GB and the 2-bit UD-Q2_K_XL is 378 GB. A high-end GPU helps only as an accelerator for the shared layers while the experts sit in a very large pool of system RAM.

Should I switch from Large 3?

If you self-host Large 3 on a single 8-GPU node today, Large 4 at FP8 will likely need more hardware. Benchmark both on your tasks through the API before planning a migration.

Final Thoughts

Mistral Large 4 is the biggest open weights release from a European lab so far, and with a license that allows commercial use for everyone except model-hosting resellers, it is a strong default for companies that cannot send data to US clouds. For individual users the honest answer has not changed now that the weights are out: you will use it through an API, because even the 1-bit GGUF needs a 256 GB RAM machine and a usable 4-bit build needs over 600 GB. If you own that kind of hardware, the llama.cpp and vLLM commands above get you running today.

Related guides on this site:

Sources

Free weekly email

Get new AI guides every week

One short weekly email with our newest local AI, ComfyUI and AI tool guides. No spam, no pop-ups, just the good stuff.

Free. Unsubscribe anytime in one click. We only use your email to send this newsletter. See our privacy policy.

Woman holding a tablet that reads "MISTRAL", with the text "Mistral large 4 is open"