Local AI Advisor
All posts

Mistral Large 4's weights are out: what a 1-trillion-parameter model costs to run

Mistral's 1-trillion-parameter model is now downloadable — but its weights alone need roughly a terabyte of memory.

By Ray, Your Local AI Advisor5 min readlocal-llmnew-modelsai-news

Mistral released the weights for Large 4 on October 29, 2026, closing the promise it made when it previewed the model on October 6. The model, nicknamed "Le Chonk," is now downloadable from Hugging Face, and Reuters reports the released version is an upgrade over the preview after testing with governments and corporate users. If you have been waiting to run Europe's biggest open-weight model yourself, the door is open. The catch is the size of the door: this model needs a server room, not a desk.

Flat illustration of a large server rack with a few glowing modules beside a small desktop computer, with a download arrow above the rack

What actually landed

Large 4 is a mixture-of-experts model with about 1 trillion parameters in total, of which 49 billion are active for each token (52 billion counting the embedding and output layers). For each token, a router picks 4 of 128 expert networks, plus one shared expert, so most of the model sits idle on any given step. That is the whole point of the design: a very large pool of knowledge with a per-token cost closer to a mid-sized model.

The model card lists a 1-million-token context window, text and image input with text output, and fluency in more than 160 languages, including every official language of the European Union. It also ships with an embedded DSpark speculative-decoding draft head, which Mistral says measured up to 1.9x higher throughput than serving the target model alone, with actual gains depending on hardware and workload. Reasoning effort is adjustable per request (low, medium, high), and the model supports function calling and strict JSON schema output, which matters if you want it driving tools rather than just chatting.

Two official checkpoints are published: FP8 and a quantized NVFP4 version that Mistral says keeps the same performance with a smaller footprint and faster inference, aimed at Blackwell GPUs and served through vLLM or SGLang. Community GGUF builds from Unsloth and the llama.cpp team are also listed, so llama.cpp users are not left out.

The memory math, honestly done

Here is the number that decides everything else. The weights alone, before any memory for the conversation itself, work out like this: 1.05 trillion parameters at 1 byte each (FP8) is about 1,050 GB, and at half a byte each (NVFP4) is about 525 GB. Real serving needs more on top of that for the KV cache and serving overhead, so treat these as floors, not totals.

Bar chart comparing Mistral Large 4's weights-only memory: about 1,050 GB in FP8 and about 525 GB in NVFP4, against a dashed line at 128 GB for a DGX Spark's total memory

Put that next to real machines and the picture is plain. A DGX Spark tops out at 128 GB of unified memory, which covers roughly a quarter of the NVFP4 weights and none of the FP8 ones. A 24 GB consumer graphics card holds about 2% of the FP8 checkpoint. Even a 4-bit community build is still around half a terabyte of file to store and load. Mistral's own vLLM example uses 8-way tensor parallelism, which is a way of saying: spread this across eight GPUs.

So no, this is not a model you download onto your laptop this weekend. It is a model for a multi-GPU server, a rented cluster, or an organization that already runs that kind of hardware. If that is not you, the practical routes are the Mistral API, which serves it as mistral-large-4, and the official demo gallery, which Mistral says runs on the API with a small shared free budget per visitor for the first week of the release. Try it there before spending anything on hardware.

The license changed, and it matters

Large 3 shipped under Apache 2.0. Large 4 does not. It is released under the Mistral Ecosystem Open-Weight License, which Mistral describes as a modified version of the MIT license for both commercial and non-commercial use — with one condition that matters: operating a model-as-a-service business requires a separate commercial license from Mistral.

For most readers, that condition will never apply. Running the model inside your own company, fine-tuning it, and building products on top of its outputs are all within the license's stated scope. But if your business plan is to host Large 4 and sell access to it, you need a separate deal. Read the license text on the model page before building anything commercial on it, and do not assume Large 3's Apache terms carry over.

The benchmark picture, with the usual caution

Mistral's model card reports two headline results. On the Artificial Analysis Coding Agent Index, Large 4 scores 48%, effectively tied with the leading open-weight model, GLM-5.3, while using 47% fewer tokens per task on average. On the Artificial Analysis Intelligence Index v5, it scores 26, which Mistral notes is the highest among western open-weight models — while also noting that leading open-weight models from China score higher on that aggregate index.

Both numbers come from Mistral's own card, so treat them as the vendor's case, not an independent verdict. The encouraging part is that the weights are now public, which means independent evaluators can test the exact checkpoint instead of the preview. Expect those third-party numbers in the coming weeks, and judge the model on them.

What this changes for you

If you run a home lab or a single GPU, this release changes little today. The honest move is to try Large 4 through the API or the free demo budget, and watch for what the open ecosystem does next: smaller distilled versions, cheaper quantized builds, and independent benchmarks on the final weights. The pattern from past giant releases is that the runnable version arrives months after the giant one, and it is usually the one worth installing.

If you run servers, the release is immediately useful: an open-weight model with frontier-class coding and cybersecurity claims, a 1-million-token context window, and a supported vLLM recipe you can deploy today, under a license that permits commercial use inside your own organization.

And if you are still deciding what hardware to buy for local AI, this is a useful reality check. The biggest open models keep growing, but the models that actually run on your machine are the small and mid-sized ones. Start with /check to match a model to the machine you already own, and let the trillion-parameter class stay on servers until a distilled version earns a place on your desk.

Sources