Mistral Large 4 now has downloadable weights. That adds a procurement question to the quality evaluation: where will all the experts live, and how consistently will the infrastructure be used? Sizing a deployment from its roughly 52B active parameters would leave much of the memory bill unaccounted for.

This October 29 update replaces our October 6 preview analysis. The preview announcement and the weight release describe different checkpoints. We ran the arithmetic below locally; we did not run inference or GPU benchmarks.

Two budgets: computation and resident weights

The released model card describes a roughly 1T-parameter MoE with 49B active per token, or 52B including embeddings and output layers. These are different accounting scopes. Neither active count is the full deployment size.

A router selects experts for one token, and the next token may need different ones. Keeping the complete model on GPUs requires space for all those weights. Offloading can reduce GPU residency, but transfer stalls and batching then become separate evaluation variables. Active parameters help explain arithmetic work; they do not determine latency on their own.

Here is a planning lower bound rounded to one trillion weights. GB uses decimal units. These are calculations, not observed checkpoint sizes or supported deployment configurations.

Assumed storage Weights alone Ceiling after dividing by 80GB
2 bytes/weight 2,000GB 25
1 byte/weight 1,000GB 13
0.5 byte/weight 500GB 7

The final column is not a usable GPU count. It excludes quantization metadata, layers kept at higher precision, KV cache, buffers, framework overhead and parallelism constraints. A four-bit format does not put every tensor into exactly half a byte per weight. Check the card's FP8 and NVFP4 serving guidance and hardware support before adding operating headroom.

A cheap token is only one part of a cheap result

On October 29, the official pricing page lists $0.70 input, $2.10 output and $0.07 cached input per million tokens. Save the pricing snapshot used for a decision instead of mixing it with preview discounts.

Save this original example as budget.mjs and run node budget.mjs with Node.js 18 or newer. Its hypothetical inputs are 20,000 input and 2,000 output tokens per attempt, no cache, a $10,000 monthly all-in hosting budget, 100,000 monthly attempts and 80% success. It makes no API or GPU calls.

const inputTokens = 20_000, outputTokens = 2_000;
const apiPerAttempt = (inputTokens * 0.70 + outputTokens * 2.10) / 1e6;
const monthlyHosting = 10_000;
const attempts = 100_000;
console.log(`API per attempt: $${apiPerAttempt.toFixed(4)}`);
console.log(`API at 80% success: $${(apiPerAttempt / 0.8).toFixed(5)} per success`);
console.log(`Hosting at 80% success: $${(monthlyHosting / (attempts * 0.8)).toFixed(3)} per success`);
console.log(`Equal-cost attempts: ${Math.ceil(monthlyHosting / apiPerAttempt)}`);

Local execution output:

API per attempt: $0.0182
API at 80% success: $0.02275 per success
Hosting at 80% success: $0.125 per success
Equal-cost attempts: 549451

With equal success rates and token volumes, the totals meet at roughly 550,000 monthly attempts. Nothing in this calculation proves the hosted hardware can serve that volume within a latency target. A real comparison must include retry tokens, cache hits, tools, operations and incident response, with a separately measured success rate for each deployment. Failed attempts still cost money.

Pin the evaluation along with the checkpoint

The separate Artificial Analysis evaluation displays an Intelligence Index v5.0 score of 26 for high reasoning effort. We inspected the evaluator's page; we did not reproduce the result. An aggregate index and the fix rate on your repository measure different things.

A more direct adoption test is a set of issues with known acceptance tests. For example, compare the preview and released checkpoints on 20 shareable tasks with the same tools, time limits and harness. This is a proposed evaluation, not a completed run.

Condition to pin or record Mistake it prevents
Revision, inference engine and quantization Treating a model name as an identical executable
Reasoning effort and output limit Comparing cheaper thinking as if quality were equal
Tests plus human diff acceptance Counting syntactically valid edits as shippable fixes
p50/p95 time and concurrency Extrapolating an idle server's speed to production
Total spend including failures / accepted results Letting a low token price hide retries

Twenty tasks can expose integration failures. They are not enough to establish a definitive model ranking. Keep the success counts and failed cases alongside any average.

Availability leaves licensing and operations to resolve

The shipped license is the Mistral Ecosystem Open-Weight License. It includes an internal-use exception and a separate commercial agreement condition for Model-as-a-Service businesses. Describing it as ordinary MIT or unrestricted commercial use would erase that distinction. Compare the actual service, affiliates and delivery model against the text.

Owning the weights creates choices about data paths and customization. Low-volume teams may favor the API; organizations with data-transfer restrictions or consistently high utilization have stronger reasons to evaluate hosting. Start with full-weight memory, cost per accepted task and the licensing conditions for the planned service. Only then can weight availability become a demonstrated operating advantage.

For more background, see active parameters in MoE and cost per successful task.

The published paid course below connects to defining task acceptance and tool execution in an agent harness. It is not a Mistral GPU-serving course. The final course link is promotional.