Mistral Large 4 Requirements
VRAM & GPU for the 1T MoE (FP8 1.06TB, NVFP4 610GB)
Mistral Large 4 weights: 1,061GB (FP8), 610GB (NVFP4); 1T total, 49B active, 1M context. 4x B200 or 8x H200 fit. License, Mac, API cost. Updated Oct 31, 2026
The open weights of Mistral AI's flagship Mistral Large 4 (nicknamed Le Chonk) were released on Hugging Face on October 29, 2026. The official checkpoints measure about 1,060.6GB at FP8 and about 610.0GB at NVFP4, and that is the capacity the weights alone need. It is a Mixture-of-Experts model with about 1 trillion (1T) total parameters and 49B active (52B including embedding and output layers), and it takes text and image input. This is not a size for a personal PC; the realistic options are the API, 4x B200 (NVFP4), or 8x H200 (FP8, with little headroom).
There are two official repositories: the FP8 build (mistralai/Mistral-Large-4-1T-A52B) and the NVFP4 build (the same name with -NVFP4). NVFP4 targets Blackwell-generation GPUs (B200, B300, GB200, GB300), and the model card says it performs on par with FP8. The license is the Mistral Ecosystem Open-Weight License (a modified MIT license): commercial and non-commercial use are both allowed, but running a Model-as-a-Service business requires a separate commercial license from Mistral. The context length is 1M (1,048,576) tokens. This article was first written with estimates on October 7, 2026; on October 31 we updated it with figures from the model card, the config file, and measured file sizes. Items that are still estimates are labeled as such.
Requirements at a glance (official checkpoint sizes)
The FP8 and NVFP4 sizes are the sums of the safetensors files in each Hugging Face repository (1GB = 1 billion bytes). They include the vision encoder and the speculative-decoding draft head. BF16 and the GGUF builds are converted versions published by ggml-org and Unsloth, measured from their files; we found no official BF16 checkpoint. The right-hand column is our estimate of the total VRAM needed when serving with --gpu-memory-utilization 0.85 from the official vLLM recipe (weights divided by 0.85), assuming KV cache and the like fit in that margin.
| Format | Source | Weights only (measured) | Total VRAM needed at 0.85 (est.) | Notes |
|---|---|---|---|---|
| BF16 (GGUF) | ggml-org, Unsloth (converted) | ~2,098.9GB | ~2,470GB | No official BF16; impractical outside research |
| Q8_0 (GGUF) | ggml-org, Unsloth (converted) | ~1,115.2GB | ~1,312GB | 8-bit, considered near-lossless |
| FP8 | Mistral official | ~1,060.6GB (987.7GiB) | ~1,248GB | Reference precision (54 files) |
| Q4_K_M (GGUF) | ggml-org (converted) | ~634.8GB | ~747GB | 4-bit class for llama.cpp |
| NVFP4 (GGUF) | ggml-org (converted) | ~619.4GB | ~729GB | GGUF of the official NVFP4 |
| NVFP4 | Mistral official | ~610.0GB (568.1GiB) | ~718GB | For Blackwell (32 files) |
| Q2_K (GGUF) | ggml-org (converted) | ~380.7GB | ~448GB | 2-bit class, large quality loss |
| IQ2_XXS (GGUF) | ggml-org (converted) | ~297.7GB | ~350GB | Sub-2.5-bit class, lower bound for a 512GB Mac |
If you want to check quickly whether your own GPU or Mac can run it, our VRAM calculator (free, no signup) estimates the required VRAM from a model, quantization, and context length. Mistral Large 4 is available in its model list.

NVFP4 is about 610GB, more than the roughly 500GB you would get at a flat 4 bits, because according to the model card only the experts are NVFP4 while the linear layers stay in FP8. The longer the context you use, the more KV cache is added on top of this table. Computing from config.json, the model uses MLA (compressed KV), so the cache per token per layer is (KV LoRA rank 512 + RoPE dimension 64) = 576 elements. Some layers share KV, so 63 of the 72 layers hold their own; with an FP8 KV cache that comes to about 36KB per token, about 4.8GB at 128K tokens, and about 38GB at 1M tokens (per request) (our own calculation, excluding the indexer cache and the draft head). For the general way to think about KV cache, see our guide to KV cache and context length VRAM.
What is Mistral Large 4: facts confirmed on the model card
Mistral Large 4 is a large language model that France's Mistral AI announced in October 2026. It is a Mixture-of-Experts (MoE) model with about 1 trillion total parameters and 49B active per token (52B including embedding and output layers), natively multimodal (text plus image input, text output), and it unifies instruct and reasoning in one model. Reasoning effort can be set per request to low, medium, or high. It supports more than 160 languages, including all official EU languages, and the model card says it was trained in Europe on 3,800 NVIDIA Grace Blackwell GPUs.
| Item | Detail | Status |
|---|---|---|
| Total parameters | About 1T (one trillion) | Confirmed (model card) |
| Active parameters | 49B (52B including embedding and output layers) | Confirmed (model card) |
| Experts | 128 routed (4 active per token) plus 1 shared; first of 72 layers is dense (config.json) | Confirmed |
| Attention | MLA (KV LoRA rank 512); hidden size 6,144, vocabulary 204,800 | Confirmed (config.json) |
| Context length | 1M (1,048,576) tokens | Confirmed (config.json) |
| Multimodal | Pixtral-style vision encoder (30 layers, hidden size 2,048); text + image input, text output | Confirmed |
| Speculative decoding | Ships a DSpark draft head (3-token block, up to 1.9x throughput as measured by the developer) | Confirmed (developer-measured) |
| Languages | 160+ (including all official EU languages) | Confirmed |
| Training | 3,800 NVIDIA Grace Blackwell GPUs in Europe | Confirmed |
| Open weights | Released on Hugging Face on October 29, 2026 (FP8 and NVFP4) | Released |
| Checkpoint size | FP8 ~1,060.6GB (54 files), NVFP4 ~610.0GB (32 files) | Measured (file sizes) |
| License | Mistral Ecosystem Open-Weight License (modified MIT). Commercial and non-commercial use allowed; Model-as-a-Service businesses need a separate commercial license | Confirmed (LICENSE) |
| API | Available as mistral-large-4 (since October 6, 2026; the docs label it Public Preview) | Available |
| API pricing | $0.70 per 1M input tokens, $2.10 per 1M output tokens (cached input $0.07) | Official docs (checked Oct 31) |
Benchmarks (developer-announced figures)
The figures below were presented in the announcement. They are the developer's own claims, and we could not confirm independent third-party verification. The model card also cites Artificial Analysis indices (Coding Agent Index 48%, Intelligence Index v5 26), but those are figures the developer chose to quote. Now that the weights are out, outside evaluations may change the picture.
| Benchmark | Score | Area |
|---|---|---|
| DeepSWE 1.1 | 61.7% | Software engineering |
| Terminal Bench 4.0 | 28.3% | Terminal use / agents |
| AutomationBench | 59.9% | Business automation |
| Cybench | 93% | Security (CTF tasks) |
| Vulnerability reproduction | 82% | Security |
| Dense 200 | 42% | Visual grounding (GPT-6-Astra: 41%) |
It was also announced that the model ranks in the global top 5 on the AA Cyber Index and is the best open model on the Harvey Legal Agent Benchmark. The model card adds that it scores highest among western open-weight models on Intelligence Index v5 while leading Chinese open models score higher, and that on the Coding Agent Index it is on par with GLM-5.3 while using 47% fewer tokens per task (all developer statements). This suggests a focus on legal and multilingual business use, but whether it helps in your use case can only be tested with your own data.
Why memory is estimated from the 1T total parameters
An MoE model uses only some experts to compute each token, but which experts get picked next changes with every input. In principle all expert weights must therefore sit in memory, so required capacity is set by the total parameter count (about 1T). The roughly 1,060GB FP8 checkpoint bears this out. The 49B active parameters affect speed. Using the NVFP4 size ratio (610GB / 1T = about 0.61 bytes per parameter), the weights read per token come to roughly 30GB (49B x about 0.61 bytes, our calculation), so on hardware with enough memory bandwidth the model runs far faster than a dense 1T model. Compute per token is close to a 49B-class model, while the memory requirement stays at the 1T level; that is the defining trade-off of the MoE design.
What quantization is and which bit width to choose
Quantization compresses memory by reducing the number of bits used to represent each weight. Going from BF16 (16-bit) to 8-bit halves memory, and 4-bit cuts it to about a quarter. 8-bit is nearly lossless and 4-bit is considered practical for most uses, but dropping to 2-bit visibly degrades output quality. For Mistral Large 4 the developer officially ships both FP8 and NVFP4 builds. NVFP4 uses NVFP4 for the MoE experts and FP8 for the linear layers, and the model card says it matches FP8 across multimodal reasoning, long-context, and coding-agent evaluations (the developer's own evaluation, not independently verified). When using reasoning mode, errors can accumulate over long chains of thought, so choosing the highest precision you can afford is the safer approach.
As a rule: FP8 if quality comes first on Hopper-generation GPUs (H100, H200), NVFP4 if you have Blackwell, GGUF Q4_K_M (about 634.8GB) as the 4-bit option for llama.cpp, and 2-bit-class GGUF (Q2_K at about 380.7GB, IQ2_XXS at about 297.7GB) only as a last resort when memory runs short. There is no official BF16 checkpoint; the converted GGUF is about 2,098.9GB, which has little reason to be chosen outside research.
GPU configurations (calculated from measured sizes)
The table below works out whether the weights fit using the measured sizes above. Headroom is roughly total VRAM x 0.85 (the setting in the official vLLM recipe) minus the weights, and KV cache and activations must fit inside it. Whether it actually runs depends on the framework's parallelism strategy, context length, and concurrent requests. The model card states NVFP4 targets Blackwell, so Hopper is marked as not applicable.
| GPU setup | Total VRAM | FP8 (~1,060.6GB) | NVFP4 (~610.0GB, Blackwell) | 2-bit GGUF (Q2_K ~380.7GB) |
|---|---|---|---|---|
| H100 80GB x 8 | 640GB | No | N/A (Hopper); weights alone are 95% | Fits (comfortable) |
| H100 80GB x 16 | 1,280GB | Fits, ~27GB headroom at 0.85 (two nodes) | N/A (Hopper) | Excessive |
| H200 141GB x 4 | 564GB | No | N/A; 610GB does not reach 564GB | Fits |
| H200 141GB x 8 | 1,128GB | Fits, but weights are 94%; not enough at 0.85. Headroom ~67GB (utilization must go to ~0.95) | N/A (Hopper) | Excessive |
| B200 192GB x 4 | 768GB | No | Fits (~43GB headroom at 0.85, ~158GB in total) | Excessive |
| B200 192GB x 8 | 1,536GB | Comfortable (~245GB headroom at 0.85) | Ample | Excessive |
Our guidance: 4x B200 is the minimum for NVFP4, and the model card's SGLang example also uses --tp-size 4 on a Blackwell node. The KV cache for one 1M-token request (about 38GB, calculated above) fits within the roughly 158GB of total headroom. For FP8, 8x B200 is the safe choice; 8x H200 has weights taking 94% of total VRAM, so the official recipe's 0.85 utilization will not load it, and even if you raise it only about 67GB remains, leaving little room for KV cache. The official FP8 example uses tensor parallel 8 (--tensor-parallel-size 8), which reads as sized for this class. BF16-equivalent (about 2,100GB) does not fit even in 8x B200 (1,536GB total) and is out of scope. Note that some frameworks require a power-of-two GPU count, so whether a setup like 5x H200 is usable depends on the framework.
Running on Apple Silicon
Apple Silicon lets the GPU use unified memory, making it an option for running large models on a desk. However, the maximum Mac Studio configuration is 512GB, and after the OS takes its share the usable amount is smaller still. 4-bit-class GGUF (Q4_K_M at about 634.8GB, Unsloth's UD-Q4_K_XL at about 604.8GB) does not fit in a single machine. What fits on one machine is the 2-bit-class Q2_K (about 380.7GB) or IQ2_XXS (about 297.7GB), or Unsloth's 3-bit-class UD-IQ3_XXS (about 423.5GB, over 80% of 512GB for weights alone), all of which trade away quality.
To target 4-bit, one could connect two 512GB Mac Studios and use distributed inference across 1,024GB in total. Q4_K_M (about 634.8GB) would fit on paper, but inter-machine link speed becomes the bottleneck and stable operation is difficult. FP8 (about 1,060.6GB) exceeds the 1,024GB total and does not fit even across two machines. For llama.cpp the model card points to GGUFs and instructions (ggml-org), but it does not mention running on Mac through Metal or MLX support, so Mac operation is unconfirmed. We discuss 512GB machines in our Reflection Beam requirements article as well.
CPU plus large system RAM offload
Taking advantage of the 49B active parameters, you can keep the experts in large system RAM and put only the shared layers on the GPU. But Mistral Large 4 is about 610-635GB even at 4-bit class, so 512GB of RAM is not enough and you effectively need a 1TB-class server (the 2-bit Q2_K at about 380.7GB fits in 512GB, at a cost in quality). Because roughly 30GB must be read per token, even a server with about 300GB/s of bandwidth has a theoretical ceiling of around ten tokens per second, and real-world speed is likely to be a fraction of that (estimate).
Consumer GPUs such as the RTX 5090 (32GB) fall far short on VRAM alone. Extreme CPU offload with more than 512GB of RAM might run it, but the speed would be far from practical. For simply trying things locally, this model is not a realistic choice, and a smaller Mistral model is better suited. For the smaller model, see our Mistral Small 4 article.
Cost: API versus running it yourself
According to the official docs, Mistral Large 4's API pricing is $0.70 per 1M input tokens and $2.10 per 1M output tokens (cached input $0.07). We have replaced the $1.36 / $4.18 from launch-time reports with the current price in the docs. For example, processing 1M input tokens and 300K output tokens a day costs $0.70 for input plus $0.63 for output (0.3 x $2.10), or about $1.3 per day. That is about $40 over 30 days and only about $490 over a year.
| Daily usage | Input | Output | Cost per day | 30 days |
|---|---|---|---|---|
| Small | 1M tokens | 300K tokens | ~$1.3 | ~$40 |
| Medium (10x) | 10M tokens | 3M tokens | ~$13 | ~$400 |
| Large (100x) | 100M tokens | 30M tokens | ~$133 | ~$4,000 |
A server like 4x B200 or 8x H200 costs tens of millions of yen to buy, and renting it in the cloud means continuous hourly charges. For this reason, the API is far cheaper for most small and midsize businesses. Self-hosting is realistic only with a clear reason: confidential data cannot leave the company, data residency must be limited to Europe, or daily volume is so large that pay-per-use becomes expensive. The weights are now out, so self-hosting is an option, but evaluating through the API with your own data first is still the order least likely to lead to a bad investment.
Comparison with other large open MoE models
Here are the figures alongside those confirmed in our existing articles. The higher the ratio of total to active parameters, the more the model has the typical MoE character: heavy on memory, light on compute per token.
| Model | Total params | Active | Context length | License | 4-bit memory estimate |
|---|---|---|---|---|---|
| Mistral Large 4 | ~1T | 49B | 1M | Mistral Ecosystem Open-Weight License (modified MIT; separate contract for MaaS) | ~610GB (official NVFP4, measured, weights only) |
| Reflection Beam | 501B | 23B | 1M | Apache 2.0 | ~250-290GB (est., weights only) |
| DeepSeek V4-Pro | 1.6T | 49B | 1M | MIT | ~920GB |
| GLM-5.2 | 753B | ~40B | 1M | MIT | ~430GB |
| Mistral Small 4 | 119B | 6.5B | 256K | Apache 2.0 | ~60GB (Q4) |
| Kolibri-1 | 78B | ~3.46B | 262K (native) | Apache 2.0 | ~39–45GB (est.) |
Mistral Large 4 matches DeepSeek V4-Pro at 49B active, but its total is about two thirds as large, and 4-bit memory comes to about two thirds as well at roughly 610GB. It needs a little over twice the memory of Reflection Beam. Among European models, the 78B MoE Kolibri-1 runs in far less memory. The license is MIT-based, but the separate-contract requirement for Model-as-a-Service businesses sets it apart from the Apache 2.0 and MIT models in the table. Benchmark rankings rest on each developer's own figures, so this table does not compare them.
What to check now that the weights are out
- Reserve free disk space before downloading (about 1,060.6GB for FP8, about 610.0GB for NVFP4)
- Choose the build by GPU generation (NVFP4 for B200, B300, GB200, GB300; FP8 for H100 and H200)
- Pick a serving stack from those the model card lists: the official vLLM image (vllm/vllm-openai:mistral-large-4, recommended), SGLang (lmsysorg/sglang:mistral-large-4), transformers (main branch), or llama.cpp GGUFs
- Start with a lower --max-model-len and --max-num-seqs to avoid OOM, then raise them (a 1M-token context needs KV cache on top of the weights)
- Read the full license. Internal use falls under the exempt conditions, but offering the model to third parties through an API or hosting as a business requires a separate contract with Mistral
- If you want more speed, enable the bundled DSpark speculative decoding (up to 1.9x as measured by the developer; results vary by environment and workload)
- If you are not handling confidential data, evaluate quality through the API with your own data first
Troubleshooting (out of memory)
- OOM at startup: the weights do not fit. Drop one precision level (FP8 to NVFP4) or add GPUs
- OOM partway through: KV cache is the likely cause. Lower the maximum context length, reduce concurrent requests, or use KV cache quantization (the official NVFP4 recipe uses --kv-cache-dtype fp8_ds_mla)
- Crashes on image input: multimodal use adds image tokens and the vision weights. Reduce image resolution or the number of simultaneous images and retest
- Offload setup is slow: memory bandwidth is the bottleneck. Check the number of DDR5 channels and revisit expert placement
- GPUs are free but the model will not fit: parallelism constraints can leave GPUs unused when the count does not split evenly. Check the GPU count and parallel settings
- Will not start on 8x H200: at the official recipe's 0.85 utilization, the 1,060GB FP8 weights do not fit. Raise the utilization or consider 8x B200 or the NVFP4 build
- Quality is extremely poor: 2-bit degrades heavily. Try 3-bit or higher
Summary
Mistral Large 4 is a multimodal MoE with about 1T total and 49B active parameters, and its weights were released on October 29, 2026. The official checkpoints measure about 1,060.6GB at FP8 and about 610.0GB at NVFP4. For NVFP4, 4x B200 is realistic; for FP8, 8x B200. 8x H200 can hold FP8 but leaves only about 67GB of headroom. A single 512GB Mac Studio cannot hold 4-bit class (about 605-635GB), and consumer GPUs are not realistic. The license is a modified MIT (Mistral Ecosystem Open-Weight License) that allows commercial use but requires a separate contract for Model-as-a-Service businesses, and the context length is 1M tokens. At a million tokens a day, the API costs about $1.3 per day, which makes it the rational choice for most small and midsize businesses. We will add measured BF16, GGUF, and long-context KV cache figures, including Mac and MLX support, as verification progresses.
FAQ
How much VRAM does Mistral Large 4 need?
By the official checkpoint sizes, the weights alone are about 1,060.6GB at FP8 and about 610.0GB at NVFP4. In converted GGUF builds, BF16 is about 2,098.9GB, Q4_K_M about 634.8GB, and Q2_K about 380.7GB. KV cache and overhead come on top. Calculated from config.json, the FP8 KV cache is about 38GB per request at 1M tokens (our own calculation).
Are the weights released yet, and what is the license?
Yes. They were released on Hugging Face on October 29, 2026 (FP8 and NVFP4 builds). The license is the Mistral Ecosystem Open-Weight License, a modified MIT. Commercial and non-commercial use are both allowed, but running a Model-as-a-Service business (offering the model to third parties, for example via API, in a way that lets them control inputs or settings) requires a separate commercial license from Mistral. The license text exempts internal use and use through Mistral's official products.
With 49B active parameters, does it run in 49B worth of VRAM?
No. An MoE model cannot know which experts will be selected next, so in principle all expert weights must stay in memory, and required capacity is set by the total of about 1T. The FP8 checkpoint is indeed about 1,060GB. The 49B active parameters mainly affect generation speed.
Does it run on 4x B200 or 8x H200?
NVFP4 (about 610.0GB) fits on 4x B200 (768GB total) with about 158GB of total headroom. FP8 (about 1,060.6GB) fits on 8x H200 (1,128GB total), but weights take 94%, so the official recipe's 0.85 utilization is not enough and only about 67GB of headroom remains. 8x B200 is the safe choice for FP8. The model card states that NVFP4 targets Blackwell.
Can it run on a Mac Studio (512GB) or an RTX 5090?
A single 512GB Mac Studio cannot hold 4-bit-class GGUF (about 605-635GB); only 2-bit class (Q2_K about 380.7GB, IQ2_XXS about 297.7GB) or 3-bit class (Unsloth's about 423.5GB) fits, with lower quality. Two machines with distributed inference should fit Q4_K_M on paper, but the model card does not mention Metal or MLX, so that is unconfirmed. An RTX 5090 (32GB) is not realistic unless you use extreme CPU offload with a large amount of RAM, and the speed would be far from practical.
Is it cheaper to run it locally or use the API?
For most small and midsize businesses the API is far cheaper. The price in the official docs is $0.70 input and $2.10 output per 1M tokens, so 1M input and 300K output tokens a day is about $1.3. Self-hosting needs a 4x B200-class server and is worth considering only when confidential data cannot leave the company or volume stays very high.
株式会社オブライト
Oflight Inc. is a Tokyo-based IT company providing software development, digital signage, web development, network systems, and IoT/AR/VR technology services.
Related free tools (no sign-up, instant results)
Feel free to contact us
Contact Us