Mistral Large 4 (Le Chonk): API, Licence and Self-Hosting

Mistral Large 4 is Mistral's new 1-trillion-parameter open-weight model, nicknamed "Le Chonk", and since the weights landed on Hugging Face on 29 October 2026 the questions I keep seeing are practical ones. What is the API model ID? How much does a real task cost? Can I build a SaaS feature on it under the new licence? And can I actually run it myself? In this guide I answer each of those from Mistral's own pages, with a typed Python example you can drop into a project and a hardware chart for self-hosting.

What Mistral released, and when

There were two launches a few weeks apart:

• 6 October 2026: public preview, API only. The preview announcement introduced the model as "Unofficially ML4, very officially: le Chonk" and promised weights by the end of the month. The changelog listed it as mistral-large-4 with 50% off launch pricing for two weeks.
• 29 October 2026: open weights and an improved model. The open-weight announcement says three more weeks of reinforcement learning went into this version, and it set new list prices. The Hugging Face repo is public and not gated.

"Le Chonk" is just the nickname for Mistral Large 4, not a separate model.

Mistral Large 4 specs at a glance

The model card also lists function calling, strict JSON schemas and 160+ languages, and recommends temperature=1.0 and top_p=0.95 at every effort level. Only a few experts run per token, which keeps API prices down, but all 1T parameters still have to sit in memory when you serve it.

Mistral API: model ID and reasoning effort

On La Plateforme the model ID is mistral-large-4. Mistral's reasoning docs also use mistral-large-4-0, and they treat the two as the same model. Endpoints listed on the docs model card include chat completions, conversations, agents and batch.

Reasoning is controlled with a root-level reasoning_effort parameter. The docs are strict about the values:

With reasoning on, message.content comes back as a list of chunks (thinking, then text) rather than a plain string, so code that expects a string will break.

A typed Python example

This uses the official mistralai SDK (the reasoning docs say the feature needs version 2 or later; I tested with 3.6.0). The model and effort come from environment variables, so moving between Large 4 and Small 4 is a config change.

"""Call Mistral Large 4 with model and reasoning effort from env vars."""
import os
from typing import Literal, cast

from mistralai.client import Mistral
from mistralai.client.models import TextChunk, ThinkChunk, UserMessage

Effort = Literal["low", "medium", "high"]  # the only levels Large 4 accepts

MODEL = os.environ.get("MISTRAL_MODEL", "mistral-large-4")
_effort = os.environ.get("MISTRAL_REASONING_EFFORT", "medium")
if _effort not in ("low", "medium", "high"):
    raise ValueError(f"Large 4 accepts low, medium or high, not {_effort!r}")
EFFORT = cast(Effort, _effort)

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"], timeout_ms=300_000)


def ask(prompt: str) -> str:
    res = client.chat.complete(
        model=MODEL,
        messages=[UserMessage(content=prompt)],
        reasoning_effort=EFFORT,
        temperature=1.0,  # Mistral's recommended sampling for Large 4
        top_p=0.95,
        max_tokens=4096,
    )
    if res.usage:
        print(f"[{MODEL} {EFFORT}] in={res.usage.prompt_tokens} out={res.usage.completion_tokens}")
    message = res.choices[0].message
    if message is None:
        return ""
    content = message.content
    if isinstance(content, str):
        return content
    # With reasoning on, content is a list: ThinkChunk(s) then TextChunk(s).
    parts: list[str] = []
    for chunk in content or []:
        if isinstance(chunk, TextChunk):
            parts.append(chunk.text)
        elif isinstance(chunk, ThinkChunk):
            pass  # log or drop the reasoning trace; keep it in history for multi-turn
    return "".join(parts)


if __name__ == "__main__":
    print(ask("Summarise the trade-offs of a 1T-parameter MoE model in three bullets."))

I checked this with mypy --strict and ran it against a local mock server: the SDK sent "reasoning_effort": "medium" to /v1/chat/completions, and the parser pulled the answer out of a thinking-plus-text response. I did not make a live paid call.

Mistral Large 4 pricing and cost per task

From 29 October, Mistral Large 4 costs $0.70 per million input tokens, $0.07 per million cached input tokens and $2.10 per million output tokens. The open-weight announcement and the pricing page agree on this. Here it is next to other models on the same Mistral price list:

To make that concrete, take one agent step with 20,000 input tokens and 3,000 output tokens. In the cached case, 15,000 of those input tokens are a repeated system prompt and tool list.

This assumes equal token counts for every model, which is never quite true. Reasoning tokens show up in completion tokens in Mistral's example responses, so high effort costs more than low. Log usage on your own prompts before you pick. I compared other providers' prices the same way in my LLM API cost-per-task guide.

The licence, explained for SaaS builders

Large 3 and Small 4 are Apache 2.0, according to Mistral's models overview. Large 4 is not. It uses the Mistral Ecosystem Open-Weight License, a modified MIT licence. In short:

• You can use, copy, modify, fine-tune, distribute and sell the model and derivatives, as long as you keep the copyright and permission notice.
• If you or an affiliate "operates a Model as a Service business", you need a separate commercial licence from Mistral before any commercial use.
• "Model as a Service" means giving third parties inference or post-training access "in a manner that allows such third party to exercise meaningful control over the inputs, parameters, or training data".
• It excludes "end-user products with model capabilities solely embedded within specific features or harnesses" and "mere relaying of requests to models hosted by others".
• The MaaS condition does not apply to internal use.

If you only call Mistral's API, you are using Mistral's service under its normal terms instead.

Can you self-host Mistral Large 4?

Yes, but only with serious hardware. The FP8 repo adds up to about 1.06 TB of files on Hugging Face, and Mistral publishes an NVFP4 version for Blackwell GPUs. The vLLM recipe lists the setups that have been validated:

Mistral's model card gives a Docker command for vLLM:

docker run --runtime nvidia --gpus all \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -p 8000:8000 --ipc=host \
  vllm/vllm-openai:mistral-large-4 \
  --model mistralai/Mistral-Large-4-1T-A52B \
  --tensor-parallel-size 8 \
  --tool-call-parser mistral \
  --reasoning-parser mistral \
  --enable-auto-tool-choice \
  --gpu-memory-utilization 0.85

The checkpoint includes a built-in draft head for speculative decoding. You switch it on with --speculative-config '{"method": "dspark", "num_speculative_tokens": 3}' in vLLM or --speculative-algorithm DSPARK in SGLang. Mistral says this gives up to 1.9x more throughput.

Can I run it on a Mac?

Only for experiments. The Hugging Face launch post says the 2-bit GGUF quants run on a single Apple Silicon Ultra machine with 512 GB of unified memory, and measured Q2_K on an M3 Ultra at about 90 tokens per second for prefill and 15 tokens per second for generation. That is fine for testing prompts, not for a client's production app.

Mistral's model card itself recommends the API "if local serving is subpar". For most freelancers and small SaaS teams, that is the answer: use the API or OpenRouter, and keep self-hosting for clients who must keep data on their own hardware.

Mistral Large 4 benchmarks, with caveats

These are all Mistral's own claims from the open-weight announcement and model card. The full technical report has not been published yet.

• Artificial Analysis Coding Agent Index: 48%, "effectively tied" with GLM 5.3 while using 47% fewer tokens per task.
• Terminal-Bench 4.0: 41%, 13 points up on the preview.
• FrontierCode 2.0 (Cognition, private): 19.7%, the top open-weight score in Mistral's chart.
• Artificial Analysis Intelligence Index v5: 26. Mistral calls this "the highest among western open-weight models" and admits the leading Chinese open-weight models score higher. Hugging Face describes it as the fifth-best open-weight model on that index.
• Surge Code blind human preference: preferred over GLM 5.3, Kimi K3 and DeepSeek V4.1 Flash, behind only Claude Opus 5.5.

So Large 4 looks strong for coding and agents among open-weight models, but not clearly ahead of GLM 5.3 on general reasoning. My Kimi K3.1 Pro guide covers another open-weight rival.

When to pick Mistral Large 4

• Pick Large 4 for coding agents, tool-heavy workflows, long documents (1M context), or EU-language work, when you want an open-weight model you could self-host later.
• Pick Small 4 for classification, extraction, routing and short chat replies. It costs about a quarter as much per step in the example above and is Apache 2.0.
• Compare with GLM 5.3 if you need the top open-weight general reasoning score. It costs twice as much per token on Mistral's price list.
• Self-host only if a client must keep data on their own 8-GPU Blackwell, H200 or MI350X node.

Before switching production traffic, here is the checklist I follow:

• Set MISTRAL_MODEL and MISTRAL_REASONING_EFFORT in config, never in code.
• Start at medium, and raise to high only for agent and coding steps that need it.
• Parse chunked content, and keep thinking chunks in multi-turn history.
• Log prompt_tokens and completion_tokens per request for a week before you compare costs.
• Run 20 to 50 real prompts against Large 4 and Small 4 before choosing.
• Read the licence's Model as a Service section if you plan to self-host for customers.

For Google's latest model, my Gemini 4 Carbon vs Argon guide answers the same questions.