Mistral Large 4 Open Weights: Hardware, License and Cost for Builders

Mistral released the open weights for Mistral Large 4 ("Le Chonk") on October 29, 2026. It is a Mixture-of-Experts model with about 1 trillion parameters, roughly 52B of them active per token, and a 1M-token context window. It ships under a modified MIT license that allows commercial use, but you need a separate license if you sell it as a hosted model service. For most teams the realistic options are Mistral's API ($0.70 per million input tokens, $2.10 per million output) or a cluster of datacenter GPUs. A quantised build runs on four Nvidia B200 or B300 cards, so this is not a laptop model.

Below: what was released, what it takes to run, what the license allows, and how to decide between the API, a third-party host and self-hosting.

What Mistral actually released

The model was first released as a public preview on about October 6, 2026. Mistral then spent roughly three more weeks on reinforcement learning and customer testing before publishing the weights, SiliconANGLE reports. The official announcement calls it an open-weight hybrid instruct-and-reasoning MoE model. It takes multimodal input, speaks 160+ languages and was trained from scratch on European infrastructure. SiliconANGLE says training used 3,800 Nvidia Grace Blackwell GPUs.

The Hugging Face model card has the technical details:

The two active-parameter figures in the coverage (49B and 52B) come from the model card's own split between core layers and embeddings. Neither number is wrong.

Mistral is pitching the model at two jobs: agentic coding and cyber defense. TechCrunch quotes Mistral's VP of Science, Pierre Stock, saying that with open weights, access "can't be cut off by definition." Mistral is selling continuity to enterprises and governments that don't want to depend on a US closed-model provider.

Benchmarks: strong, but mostly self-reported

Mistral's headline claim is that this is the "best open-weight model for coding." Here are the published numbers. The announcement notes that some of them are self-reported.

In Surge's blind human-preference test for code, Mistral says testers preferred Large 4 over GLM-5.3, Kimi K3 and DeepSeek V4.1 Flash. Only Claude Opus 5.5 ranked above it.

Two caveats. First, The Next Web points out that the efficiency and cost claims come from Mistral and its partners, not independent testing. Mistral's claim that it built a frontier-class model with far less capital than rivals is also hard to check. Second, the full technical report is still "coming soon," according to the announcement. Treat the table as a shortlist signal and run your own evals.

The token-efficiency claim matters for cost. If Large 4 really finishes agent tasks with about half the tokens of GLM-5.3, it can cost less per finished task than models with lower per-token prices. You can only check that on your own workloads.

What it takes to run

The hardware reality

The Next Web reports that the quantised version runs on four Nvidia B200 or B300 GPUs. The model card's reference commands for vLLM, SGLang and Transformers all assume 8 GPUs with tensor parallelism (--tensor-parallel-size 8 / --tp-size 8). If you run out of memory, the card suggests lowering --max-model-len or --max-num-seqs.

A rough way to think about the memory, based on weight size alone and not on official requirements:

• FP8 weights: about 1 byte per parameter, so around 1 TB before KV cache. That puts you on an 8-GPU node.
• NVFP4: about half that, which is how it fits on four large-memory Blackwell GPUs.
• The 1M context window costs memory too. Long contexts and high concurrency both grow the KV cache. If you're short on memory, the card's advice to cap max-model-len is the main fix.

Only ~52B parameters are active per token, so generation runs much faster than a dense 1T model would. But every expert still has to sit in GPU memory. MoE models save compute, not VRAM.

Serving stack

The model card recommends vLLM and provides a dedicated Docker image (vllm/vllm-openai:mistral-large-4). Three flags matter:

1. --tool-call-parser mistral and --enable-auto-tool-choice. Tool calling won't parse correctly without them.
2. --reasoning-parser mistral, which separates reasoning tokens from visible output.
3. An optional speculative decoding config ({"method": "dspark", "num_speculative_tokens": 3}) for higher throughput.

SGLang has its own image (lmsysorg/sglang:mistral-large-4), and Transformers support currently needs an install from main. Mistral's announcement also mentions an optimised NVIDIA NIM container and TensorRT-LLM for high-throughput production serving.

Smaller versions are coming, with no dates

According to The Next Web, Mistral expects smaller distilled versions in the coming months, including one that runs on a laptop, but has committed to no dates. If you need local inference on consumer hardware, wait for those.

The license: modified MIT, with one important exception

The weights ship under the Mistral Ecosystem Open-Weight License, which the model card describes as a modified MIT license. In practice:

• Allowed: commercial and non-commercial use, modification, fine-tuning, and shipping products built on the model.
• Needs a separate commercial license from Mistral: running a Model-as-a-Service business, meaning you sell access to the model itself.

The boundary matters if you're building a product. A SaaS app that uses Large 4 internally to power a feature, such as a code review bot or a support agent, looks like ordinary commercial use. An inference API, or a platform whose main offer is "call Mistral Large 4 through us," looks like Model-as-a-Service. The public summaries don't spell out the edge cases, so read the full license text in the Hugging Face repo before you launch. If you're anywhere near the line, ask Mistral.

It is also an open-weight license, not an OSI open-source one. You get the weights and broad rights to use them, but not training data or full reproducibility.

API vs. host vs. self-host: how to choose

Pricing and where it's available

The official announcement lists API pricing per million tokens:

Coverage disagrees here. The Next Web's launch-day article said API pricing had not been published, and quoted Stock arguing that per-token rates mislead when a model needs fewer tokens per job. Mistral's own page now shows the figures above. Check the current price list before you commit a budget.

According to Mistral, the hosted model is available on Mistral Studio, the Mistral API, OpenRouter, NVIDIA-hosted endpoints and Microsoft Foundry. Foundry catalog listings can trail announcements, so confirm the model appears in your Azure region before you plan around it.

A quick cost sanity check

Suppose a coding agent product uses 2 billion input tokens and 400 million output tokens a month. At list prices:

• Input: 2,000 × $0.70 = $1,400
• Output: 400 × $2.10 = $840
• Total: about $2,240 a month, before any cache discounts

Agent loops resend a lot of the same context, and cached input is priced at a tenth of fresh input, so a good caching setup can cut the input line a lot. Reasoning tokens count toward output: the model card notes that max_completion_tokens includes reasoning tokens. The default effort is high, so test whether medium or low holds quality on your simpler calls.

Now compare self-hosting. Four GPUs running around the clock is about 2,920 GPU-hours a month (4 × 730), and an 8-GPU node is about 5,840. Multiply that by the hourly B200/B300 rate you're actually quoted, then add engineering time for serving, monitoring and upgrades. At startup scale the API usually wins. To run your own numbers, put your real traffic into the LLM API Cost Calculator, and use the Token Counter to measure how big your prompts really are.

When self-hosting makes sense

The real reason to self-host is control, not lower per-token cost. As Stock put it to TechCrunch, a published model can't be withdrawn or have its terms changed under you. If your product would break should a provider deprecate a model, that guarantee is worth paying for.

The cybersecurity angle, and what to check

Mistral is pushing hard on defense use cases. The announcement reports 96.6% refusal of malicious cyber requests and 97.1% resistance on the B3 agent security benchmark. Mistral also says that after the preview it saw the model refuse black-box attacks on live targets but still saw potential uplift for real attacks, so it is changing its guardrails. A specialised cyber variant is in preview for vetted design partners only.

For builders, this cuts two ways. A strong, locally runnable model for vulnerability discovery and patching suits internal security teams. It also means safety tuning is the only control you get: once you self-host, there's no provider-side moderation layer. If you put Large 4 behind an agent with shell or network access, add your own guardrails: least-privilege credentials, sandboxed execution, allowlisted tools and logged actions. The model card's own advice to keep tool sets small and well-defined also limits how much damage an agent can do.

What to do now

1. Run your own evals through the API before buying hardware. Use 50–100 real tasks from your product and compare quality and total tokens per task against your current model. Token efficiency is the claim most worth checking.
2. Test all three reasoning levels. high is the default and the most expensive. Many routing, extraction and formatting calls may do fine on low.
3. Read the license before you ship. Pay special attention to the Model-as-a-Service clause if your product exposes the model in any form.
4. Watch for the technical report and independent benchmarks. Mistral says the report is coming. Third-party results on Terminal-Bench and the coding indexes will show whether the self-reported lead holds.
5. Wait for the distilled models if you need local inference. Laptop-class versions are promised but undated.

If you're shipping a product built on open-weight models, you can list it in the LaunchBoosts AI tools directory or browse AI coding assistants to see what other teams are building on this generation of models.