Mistral Large 4 Locally: 1 Trillion Parameters, the Memory It Takes and the Licence

Mistral released the weights of Mistral Large 4 on 29 October 2026, three weeks after a public preview on its API. It is a Mixture-of-Experts model with about 1.05 trillion parameters, a 1-million-token context and image input, and Mistral calls it “our largest and most capable model to date”. The predecessor, Mistral Large 3, shipped under Apache 2.0. This one does not.

This guide covers the files, which machines can hold them, what runs the model today, and what the new Mistral Ecosystem Open-Weight License allows. BFWR has not run the model. File sizes are read from the Hugging Face repositories, hardware fits are arithmetic against the BFWR hardware database, and the one speed figure is a labelled estimate from memory bandwidth, not a measurement.

Quick answer

• Size: 1.05T parameters, about 52B active per token. Mistral’s own checkpoint is FP8 at 1,060.6 GB; its NVFP4 version is 610.1 GB.
• Smallest download: unsloth’s 1-bit GGUF at 233.0 GB. The practical single-machine route is a 2-bit file of 298 to 338 GB on a 512GB Mac Studio.
• Software: llama.cpp supports it from build b11998 (30 October). vLLM and SGLang need Mistral’s special Docker images, mlx-lm support is still an open pull request, and Ollama offers it only as a cloud model.
• Licence: free to use, modify, fine-tune and sell, except that a business offering the model itself as a service needs a separate commercial licence from Mistral. There is no revenue threshold.
• The API: $0.70 per million input tokens and $2.10 per million output tokens from 29 October, which is almost exactly the half-price sale rate the preview carried.

What Mistral Large 4 is

Mistral’s model card describes it as a “1 trillion-parameter natively multimodal Mixture-of-Experts model with 49 billion active parameters per token (52 billion including embeddings and output layers)”. Its documentation is more precise: “It features 52B active parameters and 1.05T total parameters, and a 1.6B vision encoder.” The model card’s title adds the nickname Le Chonk.

From config.json and the card:

• Layers and experts: 72 layers. The first is dense; the other 71 each hold 128 routed experts, of which 4 are active per token, plus 1 shared expert.
• Attention: multi-head latent attention (a compressed key-value cache, rank 512) with a sparse-attention indexer that selects 2,048 tokens, and some layers share their cache with an earlier layer.
• Context and inputs: 1,048,576 tokens; text and images in, text out.
• Reasoning: three effort levels, low, medium and high, with high as the default. The ggml-org notes add that “Reasoning cannot be turned off.”
• Speculative decoding: a built-in DSpark draft head proposes three tokens at a time.

The numbers are consistent: the BF16 GGUF’s 2,098.9 GB implies 1,049B parameters in the language model, and summing the config’s active parts gives about 52.4B per token.

The weights released on 29 October are not the preview model. Mistral’s release post says: “Today, we’re releasing the weights of this improved Mistral Large 4.”

How big are the files?

Sizes are in GB (one billion bytes), summed from each repository’s file listing on 1 November.

There is no official BF16 release: Mistral published FP8, and ggml-org calls its 2.1 TB BF16 file a “Lossless upcast of the FP8 release”, so it holds nothing the 1,060.6 GB original lacks. The GGUF files keep the vision encoder in a separate 3.4 GB mmproj file, and the MLX conversions drop it: “This is a text-only conversion. The vision encoder and the DSpark draft head are not included.”

Mistral’s NVFP4 card says “NVFP4 targets Blackwell GPUs (B200 / B300 / GB200 / GB300), which have dedicated hardware for the format.”

Which machines can hold it

Adding 10 GB to each file for the cache and runtime, and comparing that with GPU-usable memory in the BFWR hardware database (on Macs, the default 75% of RAM):

• Up to 338 GB (1-bit, IQ2_XXS, 2-bit MLX): a 512GB Mac Studio, M5 Ultra or M3 Ultra, at its default 384 GB GPU limit.
• 378 to 424 GB (UD-Q2_K_XL, Q2_K, UD-IQ3_XXS): the same 512GB Mac Studios with the GPU limit raised. Our Mac VRAM optimizer explains how.
• 459 to 493 GB (the other 3-bit files): on a 512GB Mac these leave about 9 to 43 GB for macOS and everything else. Too tight to plan around.
• 4-bit and above (578 GB and up): no single machine in the BFWR database. This is server territory.

The 256GB claim

Unsloth writes that its 233 GB 1-bit file “should fit on 256GB RAM including a Mac Studio or 2x NVIDIA DGX Sparks”, counting total memory rather than GPU memory. On our numbers neither holds it as configured. The 256GB Mac Studio gives the GPU 192 GB by default; you would have to raise that to about 243 GB of the 256 GB. Two DGX Sparks have 110 GB of GPU-usable memory each in our database, 220 GB together, less than the file. The same goes for two 128GB RTX Spark laptops. Treat 1-bit on 256 GB as a squeeze at best, and 512 GB as the real entry point.

Servers

vLLM’s recipe lists validated setups: a 4-GPU GB300 tray with NVFP4, 8 GB300s, 8x B300, 8x B200 with NVFP4, and 16 H200s with FP8. It adds that “FP8 needs ~128 GiB of weights per GPU on 8 GPUs, NVFP4 ~76 GiB.” AMD’s Instinct MI350X is validated with a ROCm image, and AMD publishes its own 577.9 GB MXFP4 build for that series. An 8x H100 server, at 80 GB per card, cannot hold the FP8 weights.

How fast, roughly

In ggml-org’s IQ2_XXS file only the routed experts are 2-bit; attention, the indexer, the shared experts and the embeddings stay at Q8_0. By our arithmetic each token still reads about 29 GB of weights from the 298 GB file. Using the formula our tokens-per-second guide explains (bandwidth × 0.65 ÷ active GB), that is an estimated ceiling of about 18 tokens per second on the M3 Ultra (819 GB/s) and 27 on the M5 Ultra (1,200 GB/s). These are estimates, not measurements; new architectures often run well below the ceiling. Unsloth says DSpark speculative decoding gives “about 2x decode speed at batch 1”, which is its claim, not ours.

Running it

• llama.cpp: support was merged on 29 October in pull request #31376, and the first release that contains it is b11998. ggml-org’s card gives llama serve -hf ggml-org/Mistral-Large-4-1T-A52B-GGUF:IQ2_XXS. Unsloth’s guide uses llama-server with a 32K context, DSpark with -md dspark-Mistral-Large-4-1T-A52B-Q8_0.gguf --spec-type draft-dspark --spec-draft-n-max 3, and vision with --mmproj mmproj-BF16.gguf.
• vLLM and SGLang: Mistral recommends vLLM, but support is not in a vLLM release. The card uses Docker images, vllm/vllm-openai:mistral-large-4 and lmsysorg/sglang:mistral-large-4, and the model pull request is an open draft whose description says: “This PR is not meant to be merged as is; generic pieces are being upstreamed in separate PRs.” vLLM’s latest release, v0.32.0, is from 18 October.
• MLX: the mlx-community conversions were made with mlx-lm pull request #2018, which was still open on 1 November, so a plain pip install -U mlx-lm may not load them yet. Their card reports that for the 2-bit version “Peak memory was about 338 GB in a short generation test.”
• Ollama: the library lists only mistral-large-4:cloud, which runs on Ollama’s servers. There is no local tag.
• LM Studio: its model catalogue listed no Mistral Large 4 entry on 1 November; support depends on its bundled llama.cpp runtime reaching b11998.

Mistral’s repositories are not gated.

Security defaults

llama-server listens on 127.0.0.1 by default. Mistral’s server recipes do the opposite: the vLLM command publishes -p 8000:8000, which exposes the port on every network interface, and the SGLang command passes --host 0.0.0.0. Neither sets an API key. Unless the network is isolated, publish the port as -p 127.0.0.1:8000:8000, bind to 127.0.0.1, and put authentication in front of it.

The licence: no revenue line, one business model

Mistral Large 3 was Apache 2.0. Mistral Large 4 uses the new Mistral Ecosystem Open-Weight License, which the licence itself calls “a modified version of the MIT license”. It grants the right to “use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Model” and to “run, deploy, further train or otherwise modify the Model and create derivative works from it”. As with MIT, copies must carry the copyright and permission notice.

The change is clause 2: “If the Licensee or any of its affiliates operates a Model as a Service business, the Licensee must enter into a separate commercial license with Mistral before using the Model or its derivative works for any commercial purpose.”

“Model as a Service” is defined narrowly. It means “giving a third party access to the Model or its derivative works for inference or post-training by any means (for instance via API or hosted endpoints), in a manner that allows such third party to exercise meaningful control over the inputs, parameters, or training data.” Two things are excluded from that definition: “end-user products with model capabilities solely embedded within specific features or harnesses”, and “mere relaying of requests to models hosted by others”. Clause 3 then exempts “internal use of the Model or its derivative works, defined as any use that does not make the Model or its derivative works available to third parties”, and use through Mistral’s own products.

On this text:

• Running it yourself or inside your company is allowed, commercially or not.
• A product with the model built into a feature, such as a coding tool or a support assistant, is outside the restriction.
• Fine-tuning is allowed, but offering API access to the fine-tune counts as Model as a Service, because derivative works are covered.
• Selling raw API access needs a deal with Mistral at any company size, and once you or an affiliate run such a service, the licence is needed before any commercial use of the model, not only the API. Compare Muse Spark Open, whose similar clause applies only above US$20 million in group revenue.

There is no attribution line, no usage policy attached, no territorial exclusion and no outputs clause. The open question is what counts as “meaningful control”, which the licence does not define. This is a reading of the published text, not legal advice.

Is it worth running locally?

Mistral’s card itself says: “For optimal performance, we recommend using the Mistral AI API if local serving is subpar.” On 29 October Mistral set the price at $0.70 per million input tokens, $0.07 for cached input and $2.10 for output. During the preview, Mistral’s documentation page (as archived on 9 October) listed a sale price of $0.68 input and $2.09 output against an original $1.36 and $4.18. The half-price sale has, in effect, become the regular price: the page on 1 November shows $0.70 and $2.10 with no sale label.

For scale, the 256GB M5 Ultra Mac Studio, which cannot hold even the 1-bit file at default settings, was $9,499 in AppleInsider’s price guide on 11 October. At $2.10 per million output tokens, that buys about 4.5 billion output tokens from Mistral’s API, which serves the full model, not a 2-bit squeeze. The local case is the usual one: data that must stay on your own machine, or a 512GB Mac Studio you already own. Our API pricing calculator runs the comparison for your own volumes.

Easier models in this class: GLM-5.3-Flash (321B, MIT licence) and DeepSeek V4.1-Flash-1017, which can leave part of its weights on the SSD.

FAQ

Can Mistral Large 4 run on one computer?

Yes, at 1- or 2-bit, on a Mac Studio with 512GB of memory. The 3-bit files need the GPU memory limit raised, and the 4-bit and FP8 versions need a multi-GPU server.

Can I use it commercially?

Yes, including in products you sell, as long as the copyright notice travels with any copies. Only a business that offers the model or a derivative of it as a service, with customers controlling the inputs or parameters, needs a separate commercial licence from Mistral.

Is Mistral Large 4 on Ollama?

Only as mistral-large-4:cloud, which runs on Ollama’s servers. To run it locally, use llama.cpp b11998 or later with a GGUF file.

Related guides and tools

• Meta Muse Spark Open locally, the other giant open release of October
• DeepSeek V4.1-Flash-1017 locally
• How to run GLM-5.3-Flash locally
• Open model directory, including the frontier models too large for the main list

Sources

• Mistral Large 4 on Hugging Face (model card, config.json and LICENSE) and the NVFP4 version
• Mistral preview announcement (6 October), weights release post (29 October) and model documentation
• ggml-org GGUF files, unsloth GGUF files and unsloth guide
• mlx-community 2-bit conversion
• llama.cpp pull request #31376 and vLLM pull request #64534
• vLLM recipe for Mistral Large 4
• Ollama library tags

Updated 1 November 2026. File listings, the licence text, prices, the Ollama listing and llama.cpp, vLLM and mlx-lm support status were read on that date; the preview sale price is from Mistral’s documentation page as archived on 9 October. Hardware fits and the speed estimate are computed from the BFWR hardware database.