Mistral Large 4 open weights: the licence, GPU memory, and how to self-host the 1T model

Mistral has published the weights of Mistral Large 4, its 1-trillion-parameter mixture-of-experts model, three weeks after opening it as an API preview. The checkpoint is on Hugging Face as mistralai/Mistral-Large-4-1T-A52B, with a Blackwell-only NVFP4 variant beside it, official vLLM and SGLang images, and a licence that is MIT-shaped with one commercial catch. The announcement reached the top of Hacker News within hours.

This article is for engineers deciding whether to call it, self-host it or ignore it. You will learn what the model actually is (1T total, about 50B active, 1M context), what the licence lets you do without talking to Mistral, how much GPU memory the weights need, the exact serve commands from the model card, and which benchmark claims are Mistral's own.

What is Mistral Large 4?

Mistral Large 4 is a sparse mixture-of-experts language model with image input, about 1 trillion parameters in total and roughly 50 billion used for each token. Mistral calls it "the best open-weight model for coding" and says it was trained from scratch, in Europe, on 3,800 NVIDIA Grace Blackwell GPUs (model card).

It first appeared on 6 October 2026 as a public preview on Mistral's API (docs, OpenRouter). Today's release adds the weights and a retrained checkpoint: Mistral reports Terminal-Bench 4.0 rising from 28% in the preview to 41% (announcement). Mistral's own nickname for it is "Le Chonk".

Three reasoning modes replace the old on/off switch. high is the default and is meant for agentic and hard prompts, medium for everyday work, and low replaces the former "none" mode for fast chat. max_completion_tokens counts reasoning tokens and visible output together, so a low limit can cut an answer off while the model is still thinking.

How a token moves through a 1T mixture-of-experts model

Only a small slice of the model runs per token, but all of it has to sit in GPU memory. That one sentence explains both the pricing and the hardware bill.

A router picks 4 of 128 routed experts for each token, and a shared expert always runs alongside them, so the compute per token is close to a 50B dense model while the weights are those of a 1T one (model card). The checkpoint also ships DSpark, a speculative-decoding head of three dense MLA draft layers in BF16 that proposes three tokens at a time for the full model to verify. Mistral claims up to 1.9× throughput from it "depending on hardware and workload", without changing the target model's output.

Is Mistral Large 4 open source? What the licence allows

It is open-weight, not open source in the OSI sense: you can download, modify, fine-tune and sell products built on it, but running it as a hosted model service needs a separate commercial licence. The licence text is a modified MIT licence with one added section.

Section 2 says that if you or an affiliate operate a "Model as a Service" business, you need a commercial licence from Mistral before using the model. It defines that as giving a third party access to the model or its derivatives for inference or post-training "in a manner that allows such third party to exercise meaningful control over the inputs, parameters, or training data". Two things are carved out of that definition, and Section 3 exempts two more uses:

• End-user products where model capabilities are "solely embedded within specific features or harnesses" — a code-review button, a support-ticket summariser built into your app.
• Relaying requests to models hosted by others.
• Internal use: anything that does not make the model available to third parties.
• Use through Mistral's own products.

There are no revenue or user-count thresholds. The grey zone is "meaningful control over the inputs": a product that lets customers send arbitrary prompts to your deployment looks like a model service, while one that wraps the model in a fixed feature does not. That is exactly where the Hacker News thread got stuck, and it is a question for your lawyer, not for a blog.

How much GPU memory does Mistral Large 4 need?

Roughly a terabyte for an 8-bit checkpoint and about half that at 4-bit, before any KV cache. Mistral does not publish a minimum; the model card serves it with tensor parallelism of 8 and the NVFP4 card shows SGLang at a tensor-parallel size of 4, both as examples to adapt to your topology.

The arithmetic is simple: weights take parameters × bytes per parameter. At one byte (FP8) a trillion parameters is about 1 TB; at four bits it is about 500 GB, plus the scaling factors. The NVFP4 checkpoint quantises the MoE experts to NVFP4 and keeps the other linear layers in FP8, and Mistral says to expect "similar performance to the FP8 checkpoint". NVFP4 needs Blackwell hardware (B200, B300, GB200, GB300).

Note the H200 row. The FP8 weights alone are under 1,128 GB, but there is almost nothing left for KV cache, and a 1M-token context needs a lot of it. If you only have Hopper GPUs, the practical options are two nodes, a GGUF quantisation on a large-memory machine for experiments, or the API.

How to serve Mistral Large 4 with vLLM or SGLang

Use the tagged Docker images from the model card: the card does not pin a vLLM or SGLang release, and the images are the combination Mistral tested. The commands below are copied from the cards.

1. 1

   Download the weights

   pip install -U huggingface_hubhf download mistralai/Mistral-Large-4-1T-A52B

2. 2

   Serve with vLLM

   docker pull vllm/vllm-openai:mistral-large-4docker run --runtime nvidia --gpus all \  -v ~/.cache/huggingface:/root/.cache/huggingface \  -p 8000:8000 \  --ipc=host \  vllm/vllm-openai:mistral-large-4 \  --model 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}'

3. 3

   Or serve with SGLang

   docker pull lmsysorg/sglang:mistral-large-4sglang serve \  --model-path mistralai/Mistral-Large-4-1T-A52B \  --tp-size 8 \  --mem-fraction-static 0.85 \  --speculative-algorithm DSPARK \  --max-running-requests 64 \  --reasoning-parser auto \  --tool-call-parser auto \  --host 0.0.0.0 \  --port 30000

4. 4

   Call it

   from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") resp = client.chat.completions.create(    model="mistralai/Mistral-Large-4-1T-A52B",    messages=[{"role": "user", "content": "Explain the MaaS clause in one sentence."}],    reasoning_effort="low",          # low | medium | high (default high)    max_completion_tokens=4096,       # counts reasoning + answer tokens    temperature=1.0,    top_p=0.95,)print(resp.choices[0].message.content)

Two things break in practice. First, if the server runs out of memory at start-up, the card's own advice is to lower --max-model-len or --max-num-seqs; unless you set --max-model-len, vLLM plans for the model's full context length, and that KV cache is what fills the GPUs. Second, without --reasoning-parser the reasoning text lands in the visible answer and your JSON parsing fails, so keep the parser flags even if you do not use tools.

Mistral Large 4 API pricing: cheaper with the weights release

The API price roughly halved with today's release: 0.70 per million input tokens, 0.07 cached and 2.10 output, against 1.36, 0.14 and 4.18 in the preview (announcement, preview pricing on the docs page). OpenRouter lists the new prices, a 256K-token output cap, and an EU in-region endpoint at 0.77 / 2.31.

The model identifier is not quite settled: the docs page lists mistral-large-4, while the chat and docs URLs use mistral-large-4-0, as does OpenRouter. Check the model list in your Mistral console before hard-coding either.

Mistral Large 4 benchmarks: what Mistral reports

Every number below is Mistral's own, from the announcement and model card; none is an independent run yet, and the full technical report is "coming soon".

Read the refusal claim carefully. Mistral reports a 96.6% average refusal rate on malicious cyber requests, but, as a commenter on Hacker News pointed out, not the rate at which benign security questions get refused. If you work in security, test that yourself before relying on it.

Should you self-host Mistral Large 4 or call the API?

Call the API unless you already own Blackwell-class nodes or have a data-residency reason. At 0.70 / 2.10 per million tokens you pay only for what you use, a full 8-GPU node costs the same whether it is busy or idle, and the licence question disappears when Mistral is the one serving it. Do the sum with your own token volumes and GPU prices before deciding.

Self-hosting makes sense when the data cannot leave your network, when you need to fine-tune, or when an EU-trained, EU-licensed model is the requirement. Mistral also lists NVIDIA-hosted endpoints and Microsoft Foundry as alternatives to its own API.

• To do: Read Section 2 of the licence and write down whether your use is internal, an embedded feature, or a model service.
• To do: Size memory from the real checkpoint files and your target context length, not from the parameter count alone.
• To do: Use the mistral-large-4 Docker images for vLLM or SGLang rather than guessing versions.
• To do: Keep --reasoning-parser on and budget max_completion_tokens for reasoning as well as the answer.
• To do: Pin reasoning_effort explicitly; the default high is the slowest and most expensive mode.
• To do: Re-run your own evals: every published score is self-reported until the technical report and third-party runs land.

Sources and further reading

• Mistral: Mistral Large 4 open-weight release
• Model card: mistralai/Mistral-Large-4-1T-A52B
• Model card: Mistral-Large-4-1T-A52B-NVFP4
• Mistral Ecosystem Open-Weight License
• Mistral docs: Mistral Large 4 model page
• OpenRouter: Mistral Large 4 listing
• Yotta Labs: Mistral Large 4 hardware requirements (estimates)
• Hacker News discussion