The Weights Are Out and They Fit on Eight Blackwells: Inside Mistral Large 4's Day-Zero NVFP4 Release

Every self-hosting guide published in the past week tells you the same three things about Mistral Large 4: the licence file returns a 404, no quantised checkpoint exists, and any configuration you write is a projection borrowed from the previous model. As of the morning of 29 October 2026, all three are wrong. The licence is on the repository — 2,632 bytes of it — and the checkpoint family is real: mistralai/Mistral-Large-4-1T-A52B at 54 FP8 shards and 1,060.6 GB, plus an NVFP4 sibling at 32 shards and 610.1 GB. NVIDIA's day-zero note, the one that congratulates the Mistral AI team and mentions NVFP4 support on Hugging Face in the same breath, is the shortest possible version of this story. The useful version is the longer one: what the published recipe actually assumes, what happened to the price while nobody was looking, and which of Tuesday's self-hosting advice is now actively misleading. If you want to compare what is routable today rather than what is downloadable, the OrcaRouter model catalogue lists every model we serve, its context window and its per-token price, with failover configured per route.

Start with the dates, because they are the part most coverage gets wrong in both directions. Mistral Large 4 was announced on 6 October 2026 as an API preview — a 1.05-trillion-parameter mixture-of-experts model with 49 billion parameters active per token, or 52 billion once the embeddings and output layers are counted, a 1.6-billion-parameter vision encoder and a 1M-token context window, priced at $1.36 per million input tokens against $4.18 per million output. The open weights were promised before the end of October. They arrived at 14:51 UTC on 29 October, roughly two days after the 27 October date that press reports had settled on. The gap matters because a great deal of writing about this model was authored inside it.

What is actually on the Hub this morning

The repository metadata is more informative than the announcement prose, so here it is directly:

• Main checkpoint — mistralai/Mistral-Large-4-1T-A52B, 54 safetensors shards, 1,060.6 GB on disk, tagged fp8, repo created 30 September 2026, weights last written 29 October at 14:51 UTC, not gated.

• Quantised sibling — mistralai/Mistral-Large-4-1T-A52B-NVFP4, 32 shards, 610.1 GB, repo created 15 October 2026 and updated today at 14:11 UTC — forty minutes before the parent repository finished.

• Licence — the Mistral Ecosystem Open-Weight License, which Mistral describes as a modified MIT licence, with no revenue threshold attached.

• Architecture, from params.json — 128 experts with four routed per token plus one shared expert, 72 layers, hidden size 6,144, a 30-layer vision tower accepting images up to 1,540 pixels, and KV sharing across most layers.

• The numbers that do not agree — the NVFP4 model card lists 39 languages; the announcement claims 160+. The card counts 49 billion parameters active per token; the API documentation and the vendor's own table say 52 billion, which is the same figure with embeddings and output layers added. Mistral's post credits 3,800 Grace Blackwell GPUs for training; several outlets rounded that to 4,000. None of this is fatal, and each discrepancy tells you which document was written by which team.

The 610 GB number is the release

A 1.05-trillion-parameter model does not download in a way anyone describes casually. The FP8 checkpoint is 1,060.6 GB — comfortably over a terabyte of weights before a single token of KV cache, activation or fragmentation exists. On an eight-GPU Blackwell node that fits with roughly 400 GB to spare. On eight H200s it fits with almost nothing to spare. The NVFP4 checkpoint cuts that to 610.1 GB, and the saving is not cosmetic: it is the difference between a node that is entirely weights and a node that has room left for the 1M-token context the model advertises.

The quantisation scheme is also more specific than "4-bit". Per the card, the mixture-of-experts weights are NVFP4 while the linear layers stay FP8, and the vLLM recipe asks for an FP8 KV cache on the MLA layers. That is a mixed-precision serving stack, not a blanket downcast, and it is targeted at Blackwell specifically — B200, B300, GB200 and GB300 are the parts named.

One consequence deserves emphasis for anyone planning a purchase: the official recipe still asks for eight GPUs. vLLM is published with tensor parallelism 8; SGLang with tp-size 4. Quantisation here is not primarily a way to shrink the node count. It is a way to leave the node enough memory to actually serve long context, and the published serving parameters are the evidence.

The recipe, flag by flag

What makes this release different from most open-weight drops is that the vendor shipped serving instructions rather than leaving them to the community. The vLLM path, as published:

• Image — vllm/vllm-openai:mistral-large-4

• Parallelism — --tensor-parallel-size 8

• Cache — --kv-cache-dtype fp8_ds_mla, with --gpu-memory-utilization 0.85

• Parsers — --tool-call-parser mistral, --reasoning-parser mistral, --enable-auto-tool-choice

• Optional speculation — --speculative-config '{"method": "dspark", "num_speculative_tokens": 3}'

The SGLang path differs in ways worth reading twice:

• Image — lmsysorg/sglang:mistral-large-4, with --tp-size 4 and --mem-fraction-static 0.85

• Speculation — --speculative-algorithm DSPARK, on by default in the published command

• Serving limits — --max-running-requests 64, with the reasoning and tool parsers both set to auto

Three things the flags tell you that the announcement does not

The first is that DSpark is not a separate model. The configuration file describes three multi-token-prediction layers with a small recurrent draft head — a markov rank of 512 — embedded in the checkpoint itself. Speculative decoding normally means running a second, smaller model beside the big one and paying for its memory. Here the draft head is already inside the 610 GB, which is why the speculative flag is a short config string rather than a second deployment.

The second is that the attention stack is a compression story. The config carries a sparse indexer with a top-k of 2,048 over 32 heads, a KV LoRA rank of 512, and KV sharing across most of the 72 layers — the sort of layout that has become standard in DeepSeek-lineage models. The 1M context is reachable because the attention memory is aggressively shared and the KV cache is FP8, not because the model has a terabyte of cache to spend.

The third is arithmetic. The published YaRN block extends a 512-token native RoPE window by a factor of 2,048, which multiplies out to exactly 1,048,576 — the advertised context length. Whatever the training schedule looked like, the config you are downloading reaches 1M tokens by extrapolation, and that is worth knowing before you point a 900,000-token document at it and assume the model has seen that shape before.

The price book moved while the guides were being written

Mistral's documentation lists the current rate at $0.70 per million input tokens, $0.07 per million cached input and $2.10 per million output. The announcement on 6 October quoted a list rate of $1.36 and $4.18, with a preview discount running at roughly half of that. Read the two documents together and the open-weight release did not merely ship files — it moved the permanent list price down to about the level the preview had been renting at. For anyone budgeting from the October announcement, the new card is roughly half the number they wrote down.

The independent picture is less flattering than the price cut. Artificial Analysis, on its current Intelligence Index — the v5 series rebuilt on 27 October — scores Mistral Large 4 at 26, notes $2.06 to complete one Index task, and measures 161.3 output tokens per second with 1.42 seconds to first token. The speed is genuinely good: 161 tokens per second is more than twice the median for the comparison set. The cost per task is not: at $2.06 it is in the bottom quarter of its class, because a model that reasons at length spends the money on tokens rather than on the rate card.

Mistral's own numbers, and the one it did not publish

Every benchmark in Mistral's release post is Mistral's, which is worth stating before quoting any of them. Terminal-Bench 4.0 is claimed at 41%, thirteen points above the preview and, per the post, an open-weight lead; FrontierCode 2.0 at 19.7%; the AA Coding Agent Index at 48%, described as effectively tied with GLM-5.3; BrowseComp at 84.5% against 75% for the preview's supervised checkpoint; FinWorkBench at 73.3%, behind Kimi K3's 77.3%; and an average 96.6% refusal rate on malicious cyber requests, which is the number the release is really organised around. Some of these come from third-party harnesses — Cognition's FrontierCode, Artificial Analysis's Coding Agent Index, Surge Code's human preference — but Mistral ran them and Mistral reported them. None has been reproduced publicly at the time of writing.

The number that is missing is the one a self-hoster needs most: NVFP4 quality against the FP8 checkpoint on the same evaluation. The card presents the quantisation as offering memory reduction "with similar performance", which is a claim, not a measurement. Until someone publishes a like-for-like run, the honest position is that the 610 GB checkpoint is the one you can fit and the 1,060.6 GB checkpoint is the one with a paper trail.

Set the vendor table against the same benchmarks as run by Artificial Analysis and the picture changes shape. AA's current row for Mistral Large 4 — hosted API, high reasoning effort — puts Terminal-Bench 4.0 at 25%, sixteen points below the 41% in the release post, and FrontierCode 2.0 at 15% against the 19.7% Mistral quotes. Both are harnesses Mistral itself cites. The likely explanation is configuration: the release figures may come from a specific reasoning setting or a particular evaluation slice, and AA measures what the public API returns. The unacceptable explanation is the one most coverage has settled on — printing both numbers as if they measured the same thing.

The licence clause that decides who can serve it

The licence is short enough to read in a sitting, and the clause that matters is the one about model-as-a-service. Running a hosted service on the weights requires a separate commercial licence from Mistral. But the definition of model-as-a-service excludes embedded end-user products and, separately, "mere relaying of requests to models hosted by others". That carve-out is narrower than it first looks: it does not let you stand up your own inference and resell it, and it does let a gateway pass requests through to Mistral-hosted inference without becoming a licensee. Whether that reading holds in a dispute is a question for Mistral's lawyers, not this blog's.

Which brings up the awkward part. OrcaRouter does not list Mistral Large 4 — our 214-model catalogue contains no Mistral endpoint at all — so nothing in this release is routable here today, and anyone claiming otherwise is selling you a line. What the catalogue does carry is the other half of a rollout like this: a routing DSL that can hold a workload on one model and switch it without a code change, automatic failover when an endpoint degrades, and pass-through pricing at 0% markup, so a vendor's own rate change lands on our side the same day it lands on theirs. Teams that pull 610 GB and stand up their own vLLM box almost always keep a hosted route behind it for the first weeks, and that is the part we can actually operate.

Who should start the download tonight

If you already run eight Blackwell GPUs, or you have a data-residency rule that no hosted endpoint satisfies, the calculus changed this morning and it changed in your favour: the weights exist, the licence exists, and the vendor handed you a tested serving command rather than a suggestion. Pull the NVFP4 checkpoint first — 610.1 GB is a tolerable evening, and the vLLM image is pinned. Run your own evaluation against the hosted API before you commit a production path to it, because the quantisation claim is unmeasured and the vendor benchmarks are the vendor's.

If you do not run that class of hardware, nothing in this release is for you yet. A 1T model with 49 billion active parameters per token is not a laptop download or a single-card experiment, and the FP8 checkpoint is a terabyte. The news that should reach you is the price line, not the file listing: the hosted API now starts at $0.70 and $2.10, which is roughly half what the October announcement led you to expect, and that is a change you can use without owning a single GPU.

The open question is the interesting one. A trillion-parameter model that fits in 610 GB is a proof that NVFP4 can compress a frontier-scale mixture-of-experts without changing its shape. Whether it compresses it without changing its answers is something the next two weeks of independent runs will settle, and nobody has published that yet — including the people who shipped it.