Mistral Large 4: Open Weights, Real Cost-Per-Task Math

By Lazar Milicevic · Published October 31, 2026 · 10 min read

You're running agents on a frontier API and the invoice keeps climbing, or you're eyeing open weights but can't tell whether "63% cheaper" holds up on your workload. Mistral just released the weights for Large 4 ("Le Chonk"), and the headline number is real but narrow. Here's what the data says, what it doesn't, and how to test it on your own jobs before you commit.

What actually shipped (and what the 63% means)

Mistral published the open weights for Mistral Large 4 on October 29, 2026, under a custom license. The preview launched October 6; weights were originally planned for October 27 and slipped two days after roughly three more weeks of reinforcement learning (VentureBeat).

The "63% lower cost-per-task" comes from Artificial Analysis. On their Intelligence Index, one task cost $5.54 with the preview and $2.06 with the released model. That's the whole source of the 63%.

Three things to hold onto:

1. It's a drop versus Mistral's own preview, not versus competitors.
2. It applies to Intelligence Index tasks, not coding-agent tasks, and not your tasks.
3. Capability barely moved. The index score went from 25 to 26 (Intelligence Index v5). This is an efficiency release, not a capability leap.

The savings come from two compounding changes: API rates roughly halved, and the model uses fewer tokens per task.

One caveat on pricing: Artificial Analysis confirms these rates, but Mistral's own pricing pages and OpenRouter may lag or show different numbers during the rollout. Check the current pricing page before you build a budget around them.

Halving the price while cutting output tokens by 39% looks like it should explain the 63%, but simple multiplication implies a larger drop than the published figure. The sources don't explain the gap, so treat the 63% as the published figure and don't try to reconstruct it yourself. The point for you: both levers matter, and the token lever is the one you can influence with prompting and reasoning-mode choices.

Where it sits: top open model outside China, not top open model

The "top open model outside China" claim is accurate but narrow. Large 4 scores one point above Muse Spark Open on Artificial Analysis's evaluation. But seven open-weight models score higher globally. It's six points behind DeepSeek V4.1 Flash 1017 and GLM-5.3 (VentureBeat).

And "cheaper than before" is not "cheap." Other open models may be cheaper per task, and some score higher, but I couldn't confirm their per-task figures, so check Artificial Analysis directly for the current numbers.

So when does Large 4 make sense?

• Jurisdiction or procurement rules that steer you away from Chinese-origin models. This is the real reason the "outside China" framing matters. It's a policy constraint, not a quality ranking.
• Data residency: you can run it privately (more below).
• Coding-agent token efficiency: see the next section.

If none of those apply and you only care about score per dollar, the benchmark data points to other open models being stronger. That's an honest answer, and it's the reason to benchmark on your own work instead of trusting a leaderboard position.

The coding-agent angle

In Artificial Analysis's coding-agent assessment, Large 4 ranks second among open-weight entries: 48 versus GLM-5.3's 49. The interesting part is tokens: roughly 8.5M per task versus 15.9M for GLM-5.3 (VentureBeat).

Near-identical score at about half the tokens is the pattern that matters for agent loops, where the bill scales with how much the model talks. Remember the earlier caveat: the $2.06 figure is Intelligence Index, not Coding Agent Index, so don't multiply this token ratio into a dollar claim without pricing both models yourself.

Vendor claims need discounting here. Mistral reports Terminal-Bench 4.0 up 13 points to 41% versus the preview, with output tokens down 30% (Mistral). But Artificial Analysis's own assessment shows 25% on Terminal-Bench 4.0. The two use different software and settings. Both numbers can be true; neither tells you what happens in your repo. Use them to decide it's worth testing, not to decide it's good.

The license: free to use, with one trap

The model ships under the Mistral Ecosystem Open-Weight License, a modified MIT license. You can use, modify, fine-tune and commercialize it. Businesses running a Model-as-a-Service offering need a separate commercial license from Mistral (Mistral).

There's no revenue threshold. Whether you need a commercial agreement depends on whether you or an affiliate operate a model-as-a-service business, subject to specific exceptions (VentureBeat).

Practical read for the audience here:

• Using it inside your own product or automations: generally the intended use case.
• Reselling raw inference (an API wrapper, a hosted-model product): that's the MaaS line. Get a commercial license.
• Agencies running it for clients: the grey zone. If you're delivering workflows, you're probably fine; if you're essentially hosting a model endpoint clients call directly, read the license text and ask Mistral. I'm not a lawyer and this isn't legal advice. Read the license itself.

Three ways to run it

At public launch, the options include Mistral Studio and API, OpenRouter, Vibe Code, Microsoft Foundry (with private Azure deployment options), and Nvidia-hosted endpoints with an optimized NIM container (VentureBeat). Or download the weights from Hugging Face and deploy with vLLM or SGLang (Mistral).

For a small team, the decision tree is short:

On self-hosting, be realistic about scale. The model is about 1.05 trillion total parameters with a 1M-token context. Active parameters are quoted as 52B by Artificial Analysis and the Hugging Face repo name (A52B), and as 49B in most coverage; Mistral's listing explains 49B counts only per-token activity while 52B includes embeddings and output layers. Either way, active parameters set compute per token, but you still need memory for the full trillion-parameter model. Open weights don't mean cheap to run: the infrastructure is a real cost. I've seen aggregator estimates of monthly self-hosting cost floating around, but their assumptions aren't verified, so I won't quote them. Price your own GPU quote against your own request volume.

For most solopreneurs and teams under ten people, the answer is the hosted API. Self-hosting is a decision you earn by having a privacy requirement or volume that makes the GPU math work.

Reasoning modes: your biggest cost knob

The released model offers three reasoning modes (low, medium, high), where the preview had only none and high. The scores quoted above, including the 26, are for high reasoning.

That matters because output tokens are priced at $2.10 per million versus $0.70 for input, and reasoning inflates output. Artificial Analysis measured the average of 82,000 output tokens per task on its index run, so check which reasoning setting that figure reflects before assuming it applies to you. A routine extraction or classification job probably doesn't need high reasoning, and dropping to low or medium is the first thing I'd test.

I've come across a claim that turning reasoning off cut costs dramatically. It comes from a small test on the preview version and hasn't been verified on the final model, so I won't treat it as established. The direction is plausible; the magnitude is unknown. Measure it yourself.

Here's a minimal harness to compare modes on your own jobs. It assumes an OpenAI-compatible endpoint (OpenRouter or similar) and that your provider exposes a reasoning-effort setting; check the provider docs for the exact parameter name and model ID.

import json, time
from openai import OpenAI

client = OpenAI(base_url="openrouter.ai api_key="YOUR_KEY")

MODEL = "mistralai/..."  # check the provider's current model ID
# Verify current rates on the pricing page before trusting these:
PRICE_IN, PRICE_OUT = 0.70 / 1e6, 2.10 / 1e6

def run(job, effort):
    t0 = time.time()
    r = client.chat.completions.create(
        model=MODEL,
        messages=job["messages"],
        extra_body={"reasoning": {"effort": effort}},  # param name varies by provider
    )
    u = r.usage
    cost = u.prompt_tokens * PRICE_IN + u.completion_tokens * PRICE_OUT
    return {
        "effort": effort,
        "output": r.choices[0].message.content,
        "cost": cost,
        "latency": time.time() - t0,
    }

jobs = json.load(open("my_real_jobs.json"))  # 30-50 real examples
results = [run(j, e) for j in jobs for e in ("low", "medium", "high")]

Then score each output against a pass/fail check you wrote before looking at results. Which brings us to the method.

How to benchmark a model on your own workload

Leaderboards tell you which models deserve a trial. They can't tell you which one is cheapest for your jobs that still passes. Here's the process I use, and it fits in an afternoon.

1. Collect real jobs. Pull 30-50 actual inputs from your workflow: real emails, real invoices, real support tickets. Not synthetic ones.

2. Define pass/fail first. Write the acceptance check before running anything. For extraction, that's field-by-field match against a hand-labeled answer. For drafting, a short rubric. For routing, exact-match on the label.

3. Run the candidates. Include your current model as the baseline, Large 4 at two reasoning levels, and one or two cheaper models. The earlier comparison suggests the cheaper rivals are worth including.

4. Compute cost per passing task, not cost per task. A model that's half the price but fails 30% of jobs and triggers retries or human review isn't cheaper.

def cost_per_passing_task(results):
    total_cost = sum(r["cost"] for r in results)
    passed = sum(1 for r in results if r["passed"])
    return total_cost / passed if passed else float("inf")

5. Add grounding checks for anything customer-facing. Large 4's hallucination rate fell from 41% to 28% on AA-Omniscience v1.1, tying Muse Spark Open. That's a relative improvement on one benchmark. It is not evidence the model is safe to put in front of customers unattended; Artificial Analysis lists the model's accuracy as relatively low (26%). For anything that states facts to a customer, retrieve from your own data, require citations to it, and verify before sending.

6. Re-run when prices move. The preview-to-final price drop shows how fast these numbers change. Keep the harness; re-run it quarterly.

One trap to avoid: don't mix benchmark series. Preview-era numbers on secondary sites may come from an older Artificial Analysis index version than the v5 figures used here (25/26 points, $5.54/$2.06). Check which index version any figure comes from, and don't put figures from different versions in the same spreadsheet.

A decision framework

Rather than a verdict, here's how I'd route the decision:

• You have a "no Chinese-origin models" or EU-sovereignty requirement → Large 4 is a leading candidate. Benchmark it against other non-Chinese options. On sovereignty, note that owning the weights doesn't remove dependence on the hardware you run them on.
• You only care about score per dollar → test the cheaper, higher-scoring open models first; the published numbers favor them.
• You run coding agents with long loops → the token efficiency (8.5M vs 15.9M per task against GLM-5.3 at near-equal score) makes Large 4 worth a real trial, priced on your own task.
• Low volume, no privacy constraint → stay on a hosted API and don't over-engineer. Self-hosting is a later problem.
• Customer-facing factual output → whichever model you pick, add retrieval and checks. The model choice doesn't remove that requirement.

How BizFlowAI approaches this

I'm a senior engineer who builds AI automations for solopreneurs and small teams, and I try to treat model choice as something you measure on real workloads rather than something you read off a leaderboard. The harness above is the same idea in miniature: run your real jobs, define pass/fail up front, and pick the cheapest model that still passes.

Work with BizFlowAI

If you'd rather have this built for you, that's what we do: production AI automation for solo founders and small teams — agents, integrations, and document pipelines that actually ship.

Request a free discovery call — 30 minutes, we map the highest-ROI automation in your workflow. No pitch deck, just engineering.

More guides like this on the BizFlowAI blog.