Mistral just shipped one of the most capable open-weights reasoning models of the year, and it is aimed squarely at formal correctness. Leanstral 1.5, announced on July 2, 2026, is a free Apache-2.0 code agent built for Lean 4, the proof assistant used to verify mathematics and software down to the last logical step. It saturates the miniF2F benchmark, solves 587 of 672 problems on PutnamBench, and on the FLTEval verification suite it surpasses Anthropic's Opus 4.6 at roughly one-seventh the cost. For builders, the headline is not the theorem proving. It is that a 119B-parameter model with only 6B active weights now runs as an autonomous, file-editing agent you can download and self-host for nothing.
What Leanstral 1.5 Actually Is
Leanstral 1.5 is a mixture-of-experts model: 119B total parameters, 128 experts, 4 active per token, and about 6B activated on any given forward pass. That sparse design is why a model this large can serve fast and cheap. It accepts a 256k-token context and takes both text and images as input. The full weights are published on Hugging Face under Apache-2.0, which means you can run it locally, fine-tune it, and ship it inside a commercial product with no strings attached.
The specialization is Lean 4, a functional language and interactive theorem prover. A Lean proof either compiles or it does not, so there is no room for a plausible-sounding hallucination to slip through. That verifiable-by-construction property is exactly what makes the model interesting beyond the math community: the same discipline that proves a theorem can prove that a function has no edge-case bugs.
The Numbers: How Leanstral 1.5 Benchmarks
Mistral trained the model in three stages: mid-training, supervised fine-tuning, and reinforcement learning with CISPO. The results land at or near state of the art across the standard Lean evaluations. On miniF2F it hits 100 percent, effectively retiring the benchmark. On PutnamBench, a set of competition-grade problems, it clears 587 of 672. The cost story is the part builders should read twice.
| Benchmark / Metric | Leanstral 1.5 | Reference point |
|---|---|---|
| miniF2F | 100% (saturated) | Prior open models below 70% |
| PutnamBench | 587 / 672 solved | Most systems solve double digits |
| FATE-H | 87% (new SOTA) | Previous best lower |
| FATE-X | 34% (new SOTA) | Previous best lower |
| FLTEval Pass@1 | 28.9% | Prior run 21.9% |
| FLTEval vs Opus 4.6 | Beats it | ~1/7th the cost |
| Cost per PutnamBench problem | ~$4 | Seed-Prover ~$300+ |
The FLTEval comparison matters most for tooling decisions. Mistral's own FLTEval harness measures long-horizon verification work, and beating a frontier closed model there at a fraction of the price is the kind of gap that changes what a small team can afford to run in a loop.
How It Works as a Coding Agent
The framing Mistral uses is telling: "Leanstral operates like a developer in a raw filesystem: it edits files, runs bash commands, and uses the Lean language server to inspect goals, errors, and type information in real time." This is not a single-shot prompt-to-proof model. It is an agent that lives in a working directory and iterates against a compiler. Here is the loop it runs:
- Read the goal. The agent inspects the open proof state or the target property through the Lean language server, the same interface a human uses in their editor.
- Write a candidate. It edits the proof or code file directly rather than emitting text into a chat window.
- Compile and read the error. It runs the build, then parses the exact type errors and unsolved goals the Lean server returns.
- Repair and repeat. It patches based on real compiler feedback and loops until the file compiles clean, giving a machine-checked guarantee at the end.
Because it speaks the Lean language server protocol, it slots into the same tooling humans already use. Community bridges such as the Lean LSP MCP server expose that interface to any MCP-aware agent, so you can wire Leanstral into an existing agent stack rather than adopting a bespoke runtime.
What This Enables for Builders
Even if you never write a line of Lean, the release points at a shift worth tracking. The most striking practical result was not on a math benchmark: pointed at real codebases, Leanstral 1.5 discovered 5 previously unknown bugs across 57 repositories it was tested against, and Mistral shipped a SafeVerify fork to sandbox that kind of autonomous verification. Formal methods have always been the gold standard for correctness and the slowest thing to adopt because writing proofs is expensive. A cheap, open, agentic prover collapses part of that cost.
For a small team, that means verification can move from a research luxury to something you actually run in CI. The pattern echoes what we saw with Mistral's broader coding push in Mistral Vibe and the local-first performance work in mistral.rs: open weights plus agentic tooling plus low cost, aimed at builders who want to own their stack instead of renting an API.
How to Try Leanstral 1.5 Today
You have three ways in, from zero setup to full control. First, the fastest path is the free playground and hosted API: the endpoint is named leanstral-1-5, and the full parameters live in the Mistral model card. Second, for local work, pull the weights from Hugging Face and serve them with any MoE-capable inference runtime. Third, to use it agentically, connect it to a Lean project through the language server so it can edit, compile, and repair on its own. Start with a single small theorem or one property on a function you already trust, watch the compile-and-repair loop run, and decide from there whether it earns a slot in your pipeline.
Frequently Asked Questions
Is Leanstral 1.5 really free to use commercially?
Yes. The weights are released under Apache-2.0, one of the most permissive open-source licenses. You can run, modify, fine-tune, and embed the model in a commercial product without a separate license fee. There is also a free hosted endpoint for testing before you self-host.
Do I need to know Lean 4 to benefit from it?
To use the theorem-proving features directly, yes, some Lean familiarity helps. But the broader signal, an open agentic model that verifies correctness against a compiler and finds real bugs, matters to any developer thinking about machine-checked guarantees in their workflow.
How does it compare to Anthropic's Opus 4.6?
On the FLTEval formal-verification benchmark, Leanstral 1.5 surpasses Opus 4.6 at roughly one-seventh the cost. That is a domain-specific result: Opus is a general-purpose frontier model, while Leanstral is specialized for Lean 4 proof work, so the comparison holds for verification tasks rather than general reasoning.
What hardware do I need to run it locally?
Because it is a mixture-of-experts model with only about 6B active parameters per token, it serves far faster than its 119B total size suggests. You still need enough memory or offloading to hold the full weights, so plan for a capable multi-GPU workstation or a quantized build for smaller setups.
What does "saturating miniF2F" actually mean?
miniF2F is a standard benchmark of formalized math competition problems. Scoring 100 percent means the model solves the entire test set, so the benchmark can no longer distinguish top systems and the field will need harder evaluations to measure further progress.
Can it find bugs in ordinary code, not just prove math?
Yes. In testing it surfaced 5 previously unknown bugs across 57 repositories by verifying properties formally. The same compile-and-repair loop that proves a theorem can prove that a function behaves as specified, which is where the practical software value sits.
