Mistral Large 4 Weights Missed Their Date: Oct 31 Checklist

The Short Answer: Don’t Plan Around October 31 Either

Mistral Large 4’s downloadable weights did not arrive on October 27, the date secondary coverage had attached to the release. As of late October 27, the model’s Hugging Face page still read “Upcoming release,” its countdown pointed to October 31 at 15:00 UTC, and its LICENSE file returned a 404 — meaning no license text exists yet to read. Mistral’s own commitment, unchanged since October 6, is only that the weights will drop “end of the month,” with no day and no hour attached.

So here is the direct answer for anyone planning a deployment: October 31 is an estimated date on a placeholder page, not a promise. The wait-list number keeps climbing — 813 people on October 14, 969 by the afternoon of October 27, 973 by that night — but the artifacts have not moved. If your project needs Mistral Large 4 this week, the only way to use it today is Mistral’s hosted API, live since October 6 at a list price of $1.36 per million input tokens and $4.18 per million output tokens. Everything else in this article is the checklist to run before you touch the download when it does land: the license question, the hardware math, and the honest API-versus-weights decision.

I have watched enough “open model” launches to know the pattern. The announcement gets the headlines, the weights get the countdown, and the fine print — the license, the file formats, the hardware bill — arrives last, if it arrives at all. This time the fine print matters more than usual, because Large 4 is a trillion-parameter model. Downloading it is not like downloading a 7-billion-parameter chatbot you can run on a laptop. The checklist below is built to save you from the two expensive mistakes: assuming the license will suit your company, and assuming your hardware can run the model.

What Actually Happened on October 27

October 27 was never Mistral’s date. It was a date reported by Reuters on October 6 and carried by secondary coverage; Mistral itself never confirmed it. DataCamp’s launch tracker likewise records the October 6 preview and the end-of-month weights promise, while carrying the same reported October 27 date that did not materialize. When the day arrived, a check of the primary surfaces at 14:46 UTC showed the same state as the day before: an “Upcoming release” badge, a countdown reading about four days to October 31 at 15:00 UTC, one planned artifact listed, and zero model files served.

That matters for how you read the new date. The Hugging Face card’s October 31 figure carries a tooltip saying the release date “may still change,” and it is labeled a current ETA, not a deadline. Forkast’s same-day check of the repository confirms the state of play — no files, and the LICENSE path still returning a 404 (The Reported Date Arrived and the Weights Did Not). The only vendor commitment on the record remains the October 6 announcement sentence: “We will release the weights by the end of the month, along with more details on the architecture, additional benchmarks, and our post-training methodology.”

There is one more piece of context worth knowing. Mistral has said it is red-teaming the model with cybersecurity leaders, vetted partners, and state authorities, who get access to a version with reduced moderation and expanded cyber capabilities. That work runs on a schedule the public cannot see, and it is a plausible reason a release slips by days. It is not a confirmed reason — Mistral has not said the red-teaming caused any delay — so treat it as context, not an explanation.

The practical takeaway: stop refreshing the countdown as if it were a launch clock. Check three things instead, in this order: whether model files exist, whether a LICENSE file exists, and what that license actually says. The rest of this article walks through each.

What Mistral Large 4 Actually Is (and Isn’t Yet)

Strip away the countdown and here is the confirmed picture. Mistral Large 4 is a natively multimodal mixture-of-experts model — text and image in, text out — with about 1.05 trillion total parameters and roughly 49 to 52 billion active parameters per token, depending on whether you count embeddings and output layers. Mistral’s own announcement and documentation do not fully agree on the active figure, so expect small discrepancies in coverage. It supports 160-plus languages, was trained from scratch on about 3,800 NVIDIA Grace Blackwell GPUs in Mistral’s European data centers, and offers a 1-million-token context window through the API.

What it is not, yet, is an open-weight model in any usable sense. “Open-weight” means the parameter files can be downloaded and run on your own machines. Until files exist, Large 4 is a hosted API product with an open-weight promise attached. That distinction is not pedantry — it decides your vendor leverage, your data path, and your bill. Right now there is exactly one seller, Mistral itself, running on its own European infrastructure. Once weights ship, other hosts can list the model and a price spread can form, the way it has for other open-weight models. Until then, there is no second price to compare against.

For the broader pricing context — how API prices across providers have been moving this month — our October AI API price war breakdown is worth a read alongside this piece. Large 4’s current list price sits in the same band as other large open-weight models, and well above its own launch price: the half-price launch rate of $0.68 input and $2.09 output ended October 20.

The License Question: The One Thing That Decides Everything

This is the section most coverage skips, and it is the most important one. A model download without a license is a file you cannot legally deploy in production. Here is what we know about Mistral’s licensing precedents, and what remains unknown for Large 4:

• Mistral Large 3 (December 2025): released under Apache 2.0, a permissive license. It remains the largest Mistral model with downloadable weights today.
• Devstral 2, Mistral Medium 3.5, and the Timestral family: released under a Modified MIT license. The modification matters enormously. The license grants standard MIT rights, then withholds them from any company (or employer) whose global consolidated revenue exceeded $20 million in the preceding month, derivatives included, unless Mistral grants a separate commercial license.
• Mistral Large 4: the documentation card’s license badge reads only “Open.” No license text has been published. The LICENSE path on the Hugging Face repository returns a 404.

That $20 million gate is the question every self-hoster needs answered before downloading. If Large 4 repeats the Modified MIT terms, it is permissive for individuals, startups, and researchers — and effectively a negotiated commercial license for larger companies. If it moves to Apache 2.0 like Large 3, it is broadly usable. If it does something else entirely, precedent will not help you. You cannot know which until the file exists, and you should not build a business plan on a guess.

Your license checklist (run this the hour files appear)

1. Open the LICENSE file itself, not a blog summary of it. Read the revenue threshold, if any, and whether it is measured monthly or annually.
2. Check whether derivatives and fine-tunes inherit the same terms — this decides whether you can ship a tuned version to customers.
3. Check for use restrictions: some model licenses restrict specific domains or require attribution in a particular form.
4. Check the commercial-use clause separately from the redistribution clause. A license can allow one and restrict the other.
5. If your company’s revenue is anywhere near a threshold, get the answer in writing from your own counsel or from Mistral before you deploy, not after.

One more honest caveat: license terms for a model this size sometimes arrive alongside the weights, and sometimes trail them by days. If the weights land and the license does not, the correct move is to wait. Downloading files you cannot legally use is not progress.

The Hardware Math: A Trillion Parameters Is Not a Download, It’s a Data Center Decision

Here is where enthusiasm meets arithmetic. In a mixture-of-experts model, the router picks different experts for every token, so every expert has to stay resident in memory. Active parameters decide speed; total parameters decide memory. Large 4’s 1.05 trillion total parameters set the memory bill, and it is large.

Third-party estimates (not Mistral’s figures — Mistral has published no official file sizes) put the weights alone at roughly 2.1 TB at BF16 precision, about 1.05 TB at FP8, and roughly 560 to 630 GB at 4-bit quantization, before any memory for the KV cache (Mistral Large 4 hardware requirements). At FP8, that is the capacity of an 8-GPU server such as 8× B200 or 8× MI300X. A single 24 GB or 32 GB gaming card cannot run this model — even the smallest published quant estimate, around 210 GB, is far beyond one card, and offloading experts to system RAM does not shrink them, since the router can call any expert at any time.

That reality check eliminates most home setups. A 512 GB Mac Studio could, by memory capacity alone, hold the smallest quants, but only if MLX or llama.cpp support for the model exists, which is not confirmed. A PC with 24 GB of VRAM and 128 GB of system RAM totals 152 GB — short of even the smallest quant before KV cache. For those machines, the API is the way to use Large 4, not the weights.

The break-even test: API vs. self-hosting

An independent analysis of the FP8 case put it sharply: an 8× B200 node rented at roughly $53.52 per hour would need to sustain about 7,100 output tokens per second all month to beat Mistral’s preview API price. Most teams do not have that concurrency. The honest conclusion from that math: the open weights matter most as an option that caps vendor leverage, and they pay off in cash terms mainly for organizations that already run GPU clusters.

Run your own version of this test before you commit:

1. Take your actual monthly output-token volume from the last 90 days, not your hoped-for volume.
2. Multiply by $4.18 per million (output) plus $1.36 per million (input) at list price.
3. Compare against the full rented cost of an 8-GPU node for the same month, including idle time — GPUs you rent but do not use still bill.
4. Add engineering time for deployment, updates, and incident response. Self-hosting is not free labor.
5. If the API wins by less than 2×, stay on the API. The flexibility is worth more than a thin saving.

Small teams and solo builders should read that test as permission to stop feeling behind. Using the API is not a compromise version of using Large 4 — for most workloads, it is the rational version. The weights matter to you mainly as insurance: if Mistral raises prices or changes terms later, a downloadable model gives you an exit. That insurance has value even if you never exercise it.

API vs. Weights: The Decision Table

Notice what is missing from the table: “download on day one and figure it out.” Day-one downloads of a trillion-parameter model, with an unknown license and unconfirmed runtime support, are how teams burn a week. The patient path is faster in practice.

The Pre-Download Checklist (Save This)

When the weights do land — whether October 31, later in the month, or beyond — run this list in order before you spend a dollar on hardware or a minute on deployment:

1. Confirm files exist. A Hugging Face page with a download button is not the same as complete, checksummed files. Verify sizes and hashes against Mistral’s announcement.
2. Read the LICENSE file. See the license section above. No license, no production deployment.
3. Confirm the file format. Check whether the release ships in safetensors, GGUF, or another format, and which runtimes (vLLM, SGLang, llama.cpp, MLX) support it on day one.
4. Confirm the context story. The API offers 1 million tokens of context. Self-hosted context depends on the release configuration and your KV cache budget — do not assume parity.
5. Check the benchmark question. Mistral’s own figures (61.7% on DeepSWE v1.1, 28.3% on Terminal-Bench 4 in its announcement coverage) are vendor numbers. Wait for independent runs before choosing Large 4 over a model you already run.
6. Price the full node, not the download. The weights are free to download; running them costs an 8-GPU node, power, and engineering time.
7. Plan the fallback. Keep your API integration working in parallel until the self-hosted setup has run cleanly for two weeks. Never cut over on launch day.

If any of steps 1 through 3 fail, the correct status for your project is “blocked,” and you should say so plainly to stakeholders. A blocked status with a named blocker (missing license, missing runtime) is a professional answer. A deployment built on assumed terms is not.

What to Do While You Wait

Waiting does not have to be idle. Three things are worth doing this week:

First, if you have not already, run a real workload against the API and measure it. Token counts, latency at your concurrency, and output quality on your tasks — not benchmarks from a launch blog. That measurement is what makes the break-even test real, and it stays useful whether you end up on the API or on your own hardware.

Second, if you are evaluating frontier models generally, read the pricing context. Our GPT-6.1 Terra computer-use guide for small business covers a model that changed the cost math for agent workloads this same month, and comparing its pricing against Large 4’s $1.36/$4.18 list will sharpen your sense of where the market sits.

Third, set a check routine instead of a vigil. Check the Hugging Face repository and Mistral’s announcement page once a day, and check the LICENSE path specifically. The signal that matters is not the countdown number — it is the appearance of files and a license. When both exist, the checklist above turns into a project plan. Until then, the API is the product, and it is a good one to evaluate on its merits.

Frequently Asked Questions

When will Mistral Large 4’s weights actually be released?

Mistral’s only commitment is “end of the month” (October 2026). The Hugging Face page shows October 31, 2026 at 15:00 UTC as a current ETA, with a note that the date may still change. Treat October 31 as an estimate, not a deadline, and verify by checking for actual model files rather than watching the countdown.

What license will Mistral Large 4 use?

Unknown. No license text has been published, and the repository’s LICENSE path returns a 404. Mistral’s recent precedent includes Apache 2.0 (Large 3) and a Modified MIT license with a $20 million monthly revenue gate (Devstral 2, Medium 3.5, Timestral). Do not assume either applies to Large 4 until the file is published.

Can I run Mistral Large 4 on a gaming PC or Mac Studio?

Almost certainly not in any practical sense. Third-party estimates put the weights at about 1.05 TB at FP8 precision, requiring an 8-GPU server class machine. A single 24–32 GB card cannot hold even the smallest quant estimates. A 512 GB Mac Studio could hold small quants by capacity alone, but only if runtime support for the model exists, which is unconfirmed.

How much does the Mistral Large 4 API cost?

The current list price is $1.36 per million input tokens and $4.18 per million output tokens. A half-price launch promotion ($0.68/$2.09) ended October 20, 2026. Until third-party hosts can offer the model after weights ship, Mistral is the only seller, so there is no competing price to compare.

Is the October 27 date a delay?

Not in the strict sense. October 27 was a date reported by Reuters and carried by secondary coverage; Mistral never confirmed it. The miss is real news — the weights did not arrive on the widely reported date — but it is a miss against a reported date, not against a vendor promise. The vendor promise remains “end of the month.”

Should a small business self-host Large 4 when weights land?

Usually no, at least not first. Unless you already run GPU clusters or sustain very high, steady token volumes, the API is cheaper once hardware rental, idle time, and engineering effort are counted. The weights are most valuable as leverage and insurance: they give you an exit if API terms change, even if you never run them yourself.