Mistral Large 4's 1T Weights Are Out. Serve It as an API to Others and You Need a License

• Book: Ship It — the pragmatic startup tech stack
• Also by me: Thinking in Go (2-book series) — Complete Guide to Go Programming + Hexagonal Architecture in Go
• My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools
• Me: xgabriel.com | GitHub

---

A trillion-parameter model you can download is now sitting on Hugging Face. Mistral published the weights for Mistral Large 4, the model it calls "Le Chonk", and The Next Web reported the release on October 29, three weeks after the API preview went out on October 6.

The weights are free to use, fine-tune and sell products on. There is one exception, and it is the one most likely to catch a developer building on top of it: if you run the model as a service for other people, the license wants a separate commercial deal with Mistral first.

What shipped

The model card describes a mixture-of-experts model with about 1T total parameters and about 52B active per token. The card explains the two numbers you will see quoted: 49B active in the experts, 52B once embeddings and output layers are counted. It has 128 routed experts, 4 active per token, plus one shared expert.

The rest, from the card and Mistral's docs page:

	Mistral Large 4
Context	1M tokens
Input	text and images (output is text)
Reasoning	reasoning_effort low, medium, high (default)
Weights	FP8 weights (per the repo's tags), plus an NVFP4 checkpoint for Blackwell
API price	$0.70 in, $0.07 cached in, $2.10 out per 1M tokens
License	Mistral Ecosystem Open-Weight License

The card also lists native function calling and strict JSON schema output. Mistral's announcement says it is "natively fluent in 160+ languages" and points you to vLLM, SGLang, an NVIDIA NIM container, TensorRT-LLM, OpenRouter and Microsoft Foundry.

A trillion parameters, downloadable, with a license tag attached.

The license line that matters

Mistral calls the license "a modified MIT license." Its key clause, Section 2, says that if you or any of your affiliates "operates a Model as a Service business," you "must enter into a separate commercial license with Mistral before using the Model or its derivative works for any commercial purpose" (license text).

The definition is the part to read twice. Model as a Service means "giving a third party access to the Model or its derivative works for inference or post-training by any means (for instance via API or hosted endpoints) in a manner that allows such third party to exercise meaningful control over the inputs, parameters, or training data."

Two things are carved out of that definition: "end-user products with model capabilities solely embedded within specific features or harnesses," and "mere relaying of requests to models hosted by others." Section 3 also exempts "internal use of the Model or its derivative works."

Read together, the clause sorts most setups into three buckets. Running it on your own GPUs for your own team is internal use. A product where the model sits behind a fixed feature, like a summarise button, looks like the "embedded" exclusion. An endpoint where your customers send their own prompts and pick their own parameters is the case the clause targets. A fine-tune you expose that way is a "derivative work" and lands in the same place. The clause also covers your affiliates, so a sister company that sells inference changes the answer for you. This is my reading of the text, not legal advice. If your product sits anywhere near the line, ask Mistral or a lawyer before you ship.

Calling it vs hosting it

If you just want to try it, the API is the cheap door. At Mistral's list price of $0.70 in and $2.10 out per million tokens, and with the model listed on OpenRouter, you can point an existing OpenAI-style client at it before you think about hardware.

Self-hosting is a different budget. The model card's vLLM and SGLang server commands both use 8 GPUs with tensor parallelism. According to The Next Web, the quantised version runs on four Nvidia B200 or B300 GPUs. Rough arithmetic explains the gap: at FP8, one byte per parameter, a trillion parameters is on the order of a terabyte of weights, while a 4-bit checkpoint like NVFP4 is roughly half a byte per parameter, around 500 GB. Both figures come before any KV cache.

The card's vLLM recipe starts a container with Mistral's tool-call and reasoning parsers switched on:

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

Once it is up, it speaks the OpenAI chat format. The card recommends temperature=1.0 and top_p=0.95 at every effort level, and sets effort per request:

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-Large-4-1T-A52B",
    "reasoning_effort": "medium",
    "temperature": 1.0,
    "top_p": 0.95,
    "messages": [
      {"role": "user", "content": "Explain MoE routing."}
    ]
  }'

I haven't run either command myself. The docker command is the card's vLLM recipe. The request is adapted from the card's examples and its recommended sampling settings.

Per-token billing on one side, an 8-GPU node on the other.

The benchmark numbers are Mistral's

Mistral's announcement puts Large 4 at 41% on Terminal-Bench 4.0, up 13 points from the 28% the preview scored, with 30% fewer output tokens. The Next Web lists GLM-5.3 at 40% on the same test. On the Artificial Analysis Coding Agent Index, Mistral says it scores 48%, "effectively tied" with GLM-5.3 while using 47% fewer tokens per task on average. In the Surge Code human-preference test, Mistral says raters ranked it behind only Claude Opus 5.5 among the models evaluated.

These are vendor-reported, and the preview's own scores moved a lot in three weeks of extra training. Treat them as a reason to run your own test. The token-efficiency claim is the one worth checking on your own tasks, because at $2.10 per million output tokens, a model that writes fewer tokens per job can move your bill as much as the list price does.

Mistral also flags a risk in its own post. It says it observed the model refusing black-box attacks against live targets, but sees "a potential for uplift to conduct real attacks," and is adjusting guardrails. If you host the weights yourself, Mistral's API-side guardrails are not in your path. Your own filters are.

What to do this week

1. Try it through the API first. Pay per token to find out whether the model is good at your tasks before you price GPUs.
2. Read Sections 2 and 3 of the license before you put it behind any endpoint someone else can call.
3. If you self-host, start from the model card's vLLM or SGLang command and keep its parsers. The card uses --tool-call-parser mistral with --enable-auto-tool-choice for function calling, and --reasoning-parser mistral to separate reasoning from the answer.
4. Re-run your own eval set at low, medium and high effort. Token counts are part of the result.

Would you self-host a 1T model for internal use, or is the API price low enough that the question doesn't come up?

---

If this was useful

The call this release forces on a small team, rent per token or own the hardware, is the same call you make for the database, the queue and the deploy target. Ship It is my book about those choices: hosting, deploys, payments, auth, CI/CD and monitoring, picked for a team without a platform department. If you are deciding where a model like this fits in your stack, that is the context it gives you.

I also build Hermes IDE, a free, source-available desktop app (BSL 1.1, macOS, Windows and Linux) that runs Claude Code, Codex, OpenCode and other coding agents side by side, each on its own branch and worktree. Weigh that mention with the fact that it is my project. It's on GitHub.

Comments

[Dean Lee]

The break-even arithmetic on that 8-GPU node illustrates why the licensing restriction matters.

At 70 cents in and two dollars and ten cents out per million tokens, a blended workload runs roughly a dollar thirty per million. A dedicated eight-GPU box typically leases around twenty thousand dollars a month on standard cloud contracts. To match that API bill, an internal deployment needs to clear roughly fifteen billion tokens every month under constant load.

Internal agent or engineering traffic rarely runs flat. Real usage drops outside working hours, often landing at a fifteen to twenty-five percent utilization rate. In standard infrastructure planning, teams hedge fixed capacity costs by exposing surplus headroom to external users.

Section 2 shuts that hedge down. By requiring a separate commercial deal to sell model-as-a-service access, Mistral forces an internal self-hoster to absorb the entire downtime variance alone. When idle capacity cannot be monetized off-peak, the effective cost per completed token on leased iron blows past the API price unless baseline demand is flat across twenty-four hours.