Mistral Large 4 “Le Chonk” brings enormous scale—but what does that mean for running AI locally?
We compare Le Chonk with Qwen 3.8 Flash Next, looking at total versus active parameters, coding benchmarks, quantization, memory requirements, and CPU/GPU offloading. Why can two huge models have such different prospects on consumer hardware?
From raw weight storage to PCIe bottlenecks and Qwen’s n-gram lookup system, this video explains the practical challenges behind local inference—and how community optimization could change the picture.
Based on the preview information discussed in the video. Architecture details and practical hardware requirements may evolve as weights and inference tools become available.
00:00 Meet Le Chonk 00:29 Mistral Large 4: scale and active parameters 01:10 Mistral’s reported benchmarks 01:43 Qwen 3.8 Flash Next explained 02:06 Comparing total and active parameters 02:40 Coding performance versus compute 03:13 Qwen’s context window 03:31 Can quantization make Le Chonk local? 03:51 Model weight storage explained 04:21 The RTX 5090 memory limit 04:35 Expert offloading and PCIe bottlenecks 05:06 Why Qwen’s lookup system is different 05:32 A more realistic enthusiast setup 05:57 Why 500GB is still enormous 06:11 Workstations and multi-GPU servers 06:26 Preview, weights, and unanswered questions 06:48 Community optimization 07:10 Could Le Chonk become practical locally? 07:45 Which model makes more sense for local AI? 07:55 What could change next
AI Generated·May contain errors
Video Summary
AI Generated
This video discusses Mistral's new \"LeChonk\" (Mistral Large 4) model, a massive 1.05 trillion parameter MoE model designed for professional agentic workflows. It compares LeChonk's architecture and performance with Quen 3.8 FlashNext and analyzes the feasibility of running such enormous models on local consumer hardware like the RTX 5090.
Today we're going to talk about Mistral's brand-new
model, Mistral Large 4,
which they've given the rather appropriate nickname "Le
Chonk."
And that name actually makes a lot of
sense, because this thing is enormous.
We're going to look at what Le Chonk
is, compare it with another very interesting recent
model,
Qwen 3.8 Flash Next, and most importantly,
look at whether models like Le Chonk have
any realistic chance of running on local consumer
hardware,
such as an RTX 5090.
Mistral Large 4 was announced in October 2026
as Mistral's largest and most capable model so
far.
It's an open-weight, multimodal Mixture-of-Experts model with around
1.05 trillion total parameters.
But because it's an MoE model,
it doesn't actually use all one trillion parameters
for every token.
Instead, around 49 billion parameters are active at
a time.
It also supports a context window of up
to one million tokens, includes native vision capabilities,
and Mistral is positioning it heavily around coding,
agentic workflows, cybersecurity, finance, legal work,
and other professional use cases.
Mistral says Le Chonk scores 61.7 percent on
DeepSWE 1.1, 28.3 percent on Terminal Bench 4,
and gets a combined Coding Agent Index score
of 49.8 percent.
On AutomationBench, which measures agents performing real workflows
across applications such as Gmail, Slack,
spreadsheets and Salesforce,
Le Chonk scores 59.9 percent.
So this is clearly intended to be a
frontier-class open-weight model rather than simply another small
model optimized for cheap inference.
And that makes the comparison with Qwen 3.8
Flash Next especially interesting.
Flash Next takes almost the opposite approach.
Qwen 3.8 Flash Next has a 125-billion-parameter main
model, with only around 6 billion parameters activated
per token.
It also contains another 51 billion parameters in
its n-gram embedding system.
So Le Chonk has roughly 1.05 trillion total
parameters and 49 billion active parameters,
while Flash Next has 125 billion main model
parameters, plus 51 billion n-gram embedding parameters,
with only around 6 billion active during normal
inference.
That difference in active parameters is enormous.
Le Chonk is doing something closer to 49
billion parameters worth of neural computation per token,
compared with only around 6 billion for Flash
Next. And yet their coding results aren't dramatically
different.
On DeepSWE 1.1, Le Chonk scores 61.7 percent.
Flash Next scores 58.7 percent.
So Flash Next achieves roughly 95 percent of
Le Chonk's DeepSWE score while activating only about
one eighth as many parameters.
Flash Next also scores 62.5 on SWE-bench Pro,
81.0 on SWE-bench Multilingual, 48.1 on NL2Repo Bench,
73.5 on Toolathlon, 73.9 on CoWorkBench,
and 55.7 on JobBench.
It also has a native context length of
262 thousand tokens, which can be extended to
around one million tokens.
So although Le Chonk appears to be the
more powerful model overall,
Flash Next is an extremely interesting model because
of how much capability Qwen has managed to
extract from relatively little active compute.
And this brings us to local hardware.
At first glance, you might think that quantization
could solve the problem for Le Chonk.
After all, that's exactly what we do with
other large models.
If we take a one-trillion-parameter model and convert
it from 16-bit weights to 4-bit weights,
we reduce the raw weight storage by around
four times.
Unfortunately, when you're starting with one trillion parameters,
even four-bit quantization still leaves you with an
enormous model.
At 16-bit, one trillion parameters would require roughly
two terabytes just for the model weights.
At 8-bit, you're still around one terabyte.
At 4-bit, you're around 500 gigabytes.
At 3-bit, you're around 375 gigabytes.
And even at 2-bit,
you're still looking at roughly 250 gigabytes before
accounting for additional runtime overhead.
So even an RTX 5090 with 32 gigabytes
of VRAM isn't remotely close.
You could potentially put hundreds of gigabytes of
model weights into system RAM and keep only
the active experts on the GPU.
But this creates another problem.
Le Chonk is a Mixture-of-Experts model.
Different tokens can be routed to different experts,
meaning that although only 49 billion parameters are
active for each token,
the system still needs access to the entire
collection of experts.
If those experts are sitting in system RAM
and constantly have to be transferred across PCI
Express
to the GPU, memory bandwidth and data transfer
quickly become the bottleneck.
The model may technically run,
but performance could become extremely slow.
And this is where Flash Next is fundamentally
different.
Flash Next's unusually large n-gram embedding component is
designed more like a massive lookup system.
Those parameters don't behave like hundreds of billions
of conventional neural-network weights
that need to be continuously multiplied on the
GPU.
Large portions of that data can remain in
system memory
and only the information needed for a particular
lookup has to be accessed.
That means quantization and CPU offloading can work
much more effectively.
So a heavily quantized Flash Next running with
something like a 32-gigabyte RTX 5090
and plenty of system RAM is actually a
realistic enthusiast setup.
It might require specialized inference software and careful
memory management,
but people can experiment with it on consumer
hardware.
Le Chonk is in a completely different category.
Quantization absolutely helps.
Turning a two-terabyte model into a 500-gigabyte model
is a massive reduction.
But 500 gigabytes is still 500 gigabytes.
So instead of turning Le Chonk into a
model for a single high-end gaming GPU,
quantization is more likely to turn it from
something requiring massive datacenter hardware
into something that could potentially run on a
very large workstation or multi-GPU server.
And there's another reason we shouldn't draw too
many conclusions yet.
Le Chonk has only just been announced.
Mistral has released the preview through its API,
but the full weights are scheduled to arrive
later in October.
Mistral has also said that more information about
the architecture, additional benchmarks,
and the model's post-training will be released alongside
those weights.
Once developers actually have the model,
we'll start seeing quantizations, inference engines, expert-offloading experiments,
and probably a lot of optimization work.
We've seen repeatedly with large language models
that something which looks completely impractical on launch
can become surprisingly usable six months later once
the community starts optimizing it.
So I wouldn't say Le Chonk will never
run locally.
But based on what we know today,
it's not really comparable to Flash Next from
a local inference perspective.
Flash Next was architected in a way that
makes its enormous nominal parameter
count unusually friendly to offloading and consumer hardware.
Le Chonk is a much larger,
much heavier model whose 49 billion active parameters
give it considerably more computation per token,
but whose roughly one trillion total parameters create
a massive memory problem.
For now, Le Chonk looks much more like
a datacenter or very high-end workstation model.
Flash Next remains the much more interesting choice
if your goal is to run a highly
capable agentic model on your own hardware.
But these are still very early days.
Once Le Chonk's weights are released and inference
developers actually get their hands on it,
we may discover new quantization techniques,
smarter expert caching, better CPU and GPU offloading,
or completely new approaches that make it substantially
easier to run.
So what looks impractical today could look very
different a few months from now.