Mistral Large 4 weights: the license, the hardware, and when to self-host instead of calling an API

The Mistral Large 4 weights are free to download, modify, fine-tune and build products on, with one catch: if you run a model-as-a-service business, you need a separate commercial license from Mistral. Running them means holding about 610 GB of weights in memory for the NVFP4 build, which needs Blackwell GPUs, or 1.06 TB for FP8.

Mistral released the weights on October 29, 2026, three weeks after the model's public preview. This guide reads the license text clause by clause, lists what each checkpoint weighs, and does the cost arithmetic that decides whether self-hosting beats the API. Prices and sizes are as of October 30, 2026.

What the Mistral Ecosystem Open-Weight License allows

The license is one page, and it is a modified MIT license. The LICENSE file grants the right to use, copy, modify, merge, publish, distribute, sublicense and sell the model, and to run, deploy and further train it, "without restriction", subject to three conditions.

• Keep the notice. The copyright and permission notice must travel with every copy.
• Model-as-a-Service needs a deal. If you or any affiliate "operates a Model as a Service business", you must sign a separate commercial license with Mistral before using the model or its derivatives for any commercial purpose.
• Two carve-outs. The requirement does not apply to internal use, meaning use that does not make the model or derivatives available to third parties, or to use of the model through Mistral's official products.

The license defines Model as a Service as giving a third party access to the model or a derivative for inference or post-training, by API or hosted endpoint, in a way that lets them exercise "meaningful control over the inputs, parameters, or training data". It excludes end-user products with model capabilities "solely embedded within specific features or harnesses", and the mere relaying of requests to models hosted by others.

Can I use Mistral Large 4 commercially?

Yes, for most teams. Mistral's announcement says the model is free to use, modify, fine-tune and commercialize, and the model card repeats that the license covers both commercial and non-commercial use. The table below is our plain reading of the clauses, not legal advice.

Two details trip people up. The test is about control: an endpoint that only returns answers inside a fixed feature is different from one where the customer picks parameters or trains on their own data. And the trigger covers affiliates, so a company with a hosted-inference arm should not assume its other teams are outside the clause. If your case sits between rows, the license points to Mistral's contact form for commercial terms.

Is Mistral Large 4 open source?

It is open-weight, and by the Open Source Initiative's definition it is not open source. The Open Source Definition says a license "must not restrict anyone from making use of the program in a specific field of endeavor", and a ban on running a hosted-model business is exactly that kind of restriction. TechCrunch's coverage calls it open source, but Mistral itself says "open-weight", and Hugging Face describes the license as "an MIT derivative that establishes limitations for model-as-a-service offerings".

For compliance work, note that the Hugging Face repo is tagged license: other, not mit. If your legal team keeps an allowlist keyed on license identifiers, this model will not match the MIT entry and needs a manual review.

How big are the Mistral Large 4 weights?

Mistral Large 4 is a mixture-of-experts model, which means only some of its parameters run for each token but all of them must sit in memory. The model card lists 1 trillion total parameters, 49 billion active per token (52 billion counting embeddings and output layers), 128 routed experts with 4 active plus 1 shared, a 1M-token context window, and text-plus-image input with text output. Mistral's docs give the total as 1.05T plus a 1.6B vision encoder.

The model is a hybrid instruct-and-reasoning model with low, medium and high reasoning effort, and high is the default. Hugging Face's launch post notes that reasoning cannot be switched off, so setting reasoning effort to none still runs high.

Sizes come from the file listings of the Hugging Face repos, and the FP8 and NVFP4 figures match the vLLM recipe. A download this size is a logistics task: at a sustained 1 Gbit/s, the FP8 repo alone takes about 2.4 hours, and you need free disk for it.

Can you run Mistral Large 4 locally?

Yes, on two very different budgets: a node of eight data-center GPUs for the full-quality checkpoints, or one machine with 256 GB or more of unified memory for a heavily quantized GGUF. No single consumer GPU is in the picture, because even the smallest quant in the table is 233 GB.

Mistral Large 4 FP8 vs NVFP4

The NVFP4 build is the practical data-center choice if you own Blackwell hardware. Its model card says it has a smaller memory footprint, faster inference and the same performance as FP8, and that it targets B200, B300, GB200 and GB300 GPUs. The vLLM recipe puts the weights at roughly 76 GiB per GPU across eight GPUs for NVFP4, against roughly 128 GiB per GPU for FP8, and measured NVFP4 at 1.09 to 1.18 times faster per token at tensor-parallel 8 without speculative decoding.

The FP8 build is for hardware that lacks the NVFP4 format. The recipe lists validated setups: 8x B300 (NVFP4 and FP8), 8x B200 (NVFP4), one or two GB300 trays, 2x 8 H200 for FP8, and 8 AMD Instinct MI350X GPUs. Do the memory sum before you buy: an 8x H100 node has 640 GB of GPU memory in total, below the 1.06 TB FP8 checkpoint, and the NVFP4 build targets Blackwell, not Hopper.

Mistral Large 4 vLLM setup

The model card recommends vLLM for production serving and also documents SGLang, Transformers and llama.cpp. It gives a Docker route: pull the vllm/vllm-openai:mistral-large-4 image, pass the model name mistralai/Mistral-Large-4-1T-A52B, set tensor parallelism to 8, and add the Mistral tool-call and reasoning parsers, which it says are required for tools and for separating reasoning from the answer. The NVFP4 repo adds one more flag, an FP8 KV cache type, that it says that checkpoint needs.

If you run short of GPU memory, the card says to lower the maximum context length or the number of concurrent sequences. It also warns that "if local serving is subpar", the Mistral API gives the best performance, which is a fair hint that tuning a trillion-parameter deployment takes effort. The checkpoint ships a built-in speculative-decoding draft head, and Mistral reports up to 1.9x more throughput with it, depending on hardware and workload.

Running a GGUF on one big-memory machine

For a single workstation, the route is llama.cpp with a GGUF quant. Hugging Face's launch post says llama.cpp supported the model on day one, and Unsloth publishes its own dynamic quants. According to Unsloth's guide, its smallest 1-bit quant of about 233 GB should fit on a 256 GB machine such as a Mac Studio or two NVIDIA DGX Sparks, and the 4-bit class needs about 630 GB of combined RAM and VRAM. Its rule of thumb is that total memory should exceed the file size, with room for the OS, the KV cache and runtime buffers.

The cards we read publish no tokens-per-second figures for these desktop setups, and 1-bit and 2-bit quantization costs accuracy that Unsloth measures on its own benchmarks. Treat a local GGUF as a way to evaluate the model on your data, and test it on your own prompts before you build on it. The Hugging Face hub hosts every checkpoint named here, and Upfynd lists 275 tools in LLMs & AI Infrastructure as of October 2026 if you need other serving options.

Self-host or call the API: the cost arithmetic

The API is the cheaper way to use Mistral Large 4 unless you can keep a GPU node busy. Mistral's pricing is $0.70 per million input tokens, $0.07 per million cached input tokens and $2.10 per million output tokens, with a 1M context window. The same model is also available through Mistral Studio, OpenRouter and Microsoft Foundry, according to the announcement.

Now the self-hosted side. Lambda's pricing page lists an 8x NVIDIA B200 instance at $6.69 per GPU per hour as of October 30, 2026, which is $53.52 an hour or about $38,500 for a 720-hour month, before storage and engineering time. To match the API's $2.10 output price, that node would need to produce about 25.5 million output tokens an hour, roughly 7,080 tokens per second, around the clock.

The published throughput is well under that. The vLLM recipe reports 209.8 output tokens per second per GPU at 8k input with 32 concurrent requests, on GB300 hardware. Across eight GPUs that is about 1,680 tokens per second, or 6.0 million tokens an hour, which at the B200 rental price works out to roughly $8.86 per million output tokens. The mixed hardware makes this an estimate, not a benchmark, and the recipe's best short-input figure, 766 tokens per second per GPU in a disaggregated setup, would bring the same node near $2.43 if it applies per GPU across all eight. Even then you would pay more than the API's $2.10 and carry the operations yourself.

So the case for self-hosting is rarely price. It is one of these:

• Data control. Prompts, code and logs never leave your network, which Mistral's announcement frames as sovereign AI, with partners like Booz Allen citing data-residency requirements.
• Security work that closed APIs refuse. Hugging Face argues that open weights put the usage policy and the deployment under the user's control, and that API-dependent teams can lose access mid-incident.
• Fine-tuning. Open weights let you train on proprietary data, as Mistral's announcement and Hugging Face's TRL section both describe.
• A saturated, steady workload. If your traffic would keep eight GPUs near full for most of the day, the arithmetic above starts to close the gap.

Skip self-hosting if your load is bursty, your team has no one who has tuned vLLM or SGLang on multi-GPU nodes, or the main goal is only to avoid depending on one vendor, since the model is also offered through Microsoft Foundry and OpenRouter.

Mistral Large 4 vs GLM-5.3 for coding: the published numbers

Every coding figure for Mistral Large 4 so far is vendor-reported or comes from benchmark runs Mistral cites, and the sources disagree with each other in places. Mistral's announcement says the model scores 48% on the Artificial Analysis Coding Agent Index, effectively tied with GLM-5.3 while using 47% fewer tokens per task. It also reports 41% on Terminal-Bench 4.0, taking the lead among open-weight models. Hugging Face's launch post lists 28.3% on Terminal-Bench 4 and 49.8% on the Coding Agent Index, so the two pages do not use one harness or one snapshot.

On general ability the model card is candid: Mistral Large 4 scores 26 on the Artificial Analysis Intelligence Index v5, the highest among western open-weight models, while the leading open-weight models from China score higher on that aggregate. Hugging Face adds that it ranked fifth among open-weight models on the index as of October 29, 2026.

GLM-5.3 is a different size and carries its own license. Its Hugging Face metadata counts about 753 billion parameters and tags the license as glm-5.3, so read that text before assuming the same terms. For a coding decision, run both models on a sample of your own repositories. Upfynd's AI Coding Tools category lists 246 products as of October 2026, many of which let you swap the underlying model.

What to do next

Start with the API, not the download. Point a coding agent or evaluation script at Mistral's endpoint or OpenRouter, run your own tasks at the medium and high reasoning levels, and record tokens per task, because that number drives both the API bill and the GPU count. If the results justify it, price the node using the figures above and your own utilization.

If you do self-host, send one question to Mistral through the license's contact form before launch whenever your product exposes the model to outside users in more than a fixed feature. And if you ship something built on these weights, you can list it on Upfynd for free.