Mistral Large 4 Isn't Just Another Open AI Model: Here's Why

New AI models drop every week. Most of them are just "hey, we're 2% better on some benchmark you've never heard of." You skim the blog post. You close the tab. You forget the name by Friday. So when I saw "Mistral Large 4" with the nickname Le Chonk, I almost did the same thing. Then I actually read it. And a few things caught me off guard. This model isn't just trying to win a leaderboard. It's built to do work that other AI models will straight up refuse to do. And you get the weights. So you can run it yourself. Let me walk you through it. No jargon, I promise.

First up, what is this thing?

Mistral Large 4: model ID mistralai/Mistral-Large-4-1T-A52B, nickname Le Chonk, is a new open model from Mistral AI.

Here's the quick rundown:

• About 1 trillion total parameters (it's massive)

• About 49B active per token (so it only "turns on" a small piece at a time)

• 1 million token context (it can read a whole book in one go)

• Takes text and images as input

• Trained from scratch in Europe, on Mistral's own hardware

• Speaks 160+ languages

• You can download the weights and run it yourself

That last point is the whole story. Most big models are locked behind an API. This one isn't.

Read article on "How to Deploy FastAPI on Cloudflare Workers"

Why it's different: it does security work other models won't touch

This is the part I really want you to get.

There's a test from Artificial Analysis called the Cyber Index. One of the tasks is simple: find a real bug in real software, prove it exists, and then fix it.

Mistral Large 4 scores 82% on this. Best score anyone has reported.

Now here's the wild part. Claude Opus 5.5 and GPT-6 Astra score near zero on the same test.

Not because they can't do it. Because they refuse.

Read that again.

If you're a security engineer, your job starts with proving a bug is real. You can't fix what you can't reproduce. And if your AI refuses to reproduce it, your AI is useless for the actual work.

Mistral put it well in their own release notes, something like: defending software starts with proving the flaw is real, and that's exactly the kind of work closed models block.

So yeah. This model is built for defenders. And that's a big deal.

Other security numbers

And before you ask: no, it's not a "no rules" model. Mistral says it refuses bad requests more often than any other open model out there. The difference is that you decide the rules, because you control the deployment.

That's the whole point.

Read article on "Scaled a URL Shortener to 1M+ Users"

It can actually see images (and well)

A lot of models claim "multimodal" but really it's just a text model with a camera taped on.

ML4 isn't like that. It uses a proper Pixtral vision encoder. It handles images of different sizes and shapes without squishing them.

What does that mean in practice? It can:

• Read charts and PDFs

• Look at engineering drawings and zoom in

• Scan massive satellite images to find tiny objects

• Double-check visual details before answering

And on one visual test called Dense 200, it scored 42%. Just a hair ahead of GPT-6 Astra at 41%.

An open model beating a closed frontier model at its own game. That doesn't happen every day.

Read article on "Fix ChatGPT-Generated Code Errors"

How it works (short version)

You don't need to memorize this. Just skim it.

ML4 is a Mixture-of-Experts (MoE) model. Think of it like a big team of specialists. For every word it generates, it calls in just a few of them. Not the whole team. Just the right ones.

• 72 layers in the main brain

• 128 experts to choose from, 4 active per token, plus 1 always-on shared expert

• Fancy attention tricks (MLA + a sparse attention indexer) that let it look at the right past tokens without slowing down

• A "draft head" called DSpark that guesses the next few tokens ahead of time. Mistral says this makes it 1.4x to 1.8x faster

In short: it's a huge model, but it's built to be fast. Not just impressive on paper.

Read article on "SvelteKit 3 is here"

Built in Europe, and that matters

This isn't just a marketing line. It's a real thing. ML4 was trained from scratch on 3,800 NVIDIA Grace Blackwell GPUs in Mistral's own European data centers. The preview runs on that same hardware.

Why should you care?

If you're a bank in Germany, or a hospital in France, or a government agency anywhere in Europe, "can this run under our own rules, on our own machines" is not a nice-to-have. It's a legal requirement. And for security work, it's even simpler: losing access to your AI mid-incident is a real risk. If your provider can cut you off during an attack, you have a problem. Open weights fix that.

Read article on "AI Chatbots"

You can actually run it. Day one.

Lots of "open" models are open in name only. You can download them, sure. But good luck serving them.

ML4 works with basically everything from day one:

• Transformers (the usual Python way)

• vLLM (fast serving)

• llama.cpp (local machines)

• TRL (fine-tuning)

• Hugging Face Inference Endpoints

• NVIDIA NIM / Dynamo on Blackwell

Here's what it looks like in the real world:

The wildest part? The 2-bit version runs on a single Apple Mac Studio Ultra with 512GB of RAM. That's a trillion-parameter model running on one machine.

Still wild to me.

Read article on "OpenCode vs Claude Code"

The numbers, honestly

Here's where ML4 actually lands. I'm not gonna pretend it wins everything.

And on a blind human test by Surge AI, real annotators rated it second of five models at 3.74:

1. Claude Opus 5: 4.22

2. Mistral Large 4: 3.74

3. GLM-5.3: 3.60

4. Kimi K3: 3.59

5. GLM-5.2: 3.40

So no, it's not the best model in the world. But it's the best open model outside China by a wide gap. And in cyber work, nothing else is close.

Read article on "Skills for AI"

How to actually try it

Easiest way: llama.cpp

bash

curl -LsSf https://llama.app/install.sh | sh
llama serve -hf ggml-org/Mistral-Large-4-1T-A52B-GGUF:Q2_K

Then open localhost:9931 in your browser. Done.

Python way (Transformers)

python

from transformers import AutoProcessor, AutoModelForMultimodalLM, DistributedConfig

model_id = "mistralai/Mistral-Large-4-1T-A52B"
processor = AutoProcessor.from_pretrained(model_id)

model = AutoModelForMultimodalLM.from_pretrained(
    model_id,
    distributed_config=DistributedConfig(tp_size=8, ep_size=8),
)

Run it with torchrun --nproc-per-node 8 script.py.

vLLM (faster, needs Blackwell GPUs)

bash

vllm serve mistralai/Mistral-Large-4-1T-A52B-NVFP4 \
  --tensor-parallel-size 8 \
  --enable-expert-parallel \
  --max-model-len 131072

That's the short version. Full flags are in the Hugging Face post.

Yes, you can fine-tune it

This part surprised me too. TRL has day-one support for LoRA fine-tuning. You can train a 1T model on a single 8×B300 box.

python

from trl import SFTConfig, SFTTrainer
from peft import LoraConfig

trainer = SFTTrainer(
    model=model,
    args=SFTConfig(packing=True, max_length=4096, learning_rate=1e-4),
    train_dataset=dataset,
    peft_config=LoraConfig(r=16, lora_alpha=32,
        target_modules=r".*language_model.*\.(q_proj|k_proj|v_proj|o_proj)"),
)
trainer.train()

Mistral's example trains the model to reason in whatever language you ask for. Which is a nice demo of the 160+ language support.

You can also use ML4 to generate training data for a smaller model. That's often the smarter move in production anyway.

Stuff to know before you deploy

Not everything is sunshine. Here's the fine print.

• It's big. You can't run this on your laptop. Minimum is a beefy Mac or a multi-GPU rig.

• The license has a catch. It's the Mistral Ecosystem Open-Weight License (an MIT spin-off). You can use it commercially. But if you want to sell it as a service, you need a separate deal with Mistral.

• You can't turn reasoning off. You can set it to low, medium, or high. But "none" still means high. So you always pay the reasoning cost.

• Recommended settings: temperature 1.0, top_p 0.95. Those are vendor defaults. Your setup may differ.

• Token efficiency is good. Mistral says the model hits its 48% coding score using 47% fewer tokens than GLM-5.3. Basically tied output, less compute. That adds up fast in real bills.

The short version

Five things that make ML4 different:

1. It does security work other models refuse: 82% on reproduce-and-patch vs near zero for the big closed models.

2. It sees images properly: 42% on Dense 200, just ahead of GPT-6 Astra.

3. It's built to be fast: MoE + smart attention + a draft head for speed.

4. It's European: trained and hosted in Europe, under European law, with open weights.

5. You can actually run it: transformers, vLLM, llama.cpp, fine-tuning, all on day one.

That's why "Le Chonk" isn't just another open model. It's a statement: open weights can do things closed APIs won't.