Leanstral 1.5 proves the old rules of AI pricing don't apply to math

For years, the conventional wisdom in automated theorem proving was simple: you get what you pay for. Systems like Seed-Prover and Aleph Prover delivered strong results because they burned compute, sometimes 10 H100-days per problem, and often relied on natural-language guidance from a larger LLM. The verification horizon: why verifying coding agents…

Mistral AI's Leanstral 1.5 upends that logic. Released under an Apache-2.0 license and available as a free API endpoint, the model uses only 6 billion active parameters out of 119 billion total. Despite its modest footprint, it saturates the miniF2F benchmark (100% on both validation and test sets), solves 587 out of 672 PutnamBench problems, and achieves a new state-of-the-art on the FATE-H (87%) and FATE-X (34%) abstract algebra benchmarks. AI models can't stop thinking out loud. That's both…

But the more instructive metric is cost. Leanstral 1.5 runs at approximately $4 per solved problem on PutnamBench. Seed-Prover 1.5 in its high setting costs an estimated $300 or more per problem. Aleph Prover comes in at $54.68. The gap is not incremental. It is an order of magnitude, and in Seed-Prover's case, nearly two orders of magnitude. Cognition's new coding agent scores near frontier…

A three-stage training grind

Leanstral 1.5's performance did not come from a single architectural innovation. The training pipeline is a deliberate three-stage sequence: mid-training on a large corpus of formal mathematics, supervised fine-tuning on proof and code-agent trajectories, and reinforcement learning using a method the team calls CISPO (context-invariant stable policy optimization).

The RL phase operates across two environments. In the multiturn setting, the model receives a theorem statement and must prove or disprove it through an iterative loop: submit a proof attempt, receive Lean compiler feedback, refine. In the code-agent environment, Leanstral 1.5 acts like a developer, editing files, running bash commands, querying the Lean language server for goal types and errors, and persisting through multiple rounds of context compaction. Your AI agent passed the test by accident. Now there's…

That second mode is what sets Leanstral 1.5 apart from earlier provers. Rather than treating proof search as a single-shot generation problem, the model learns to navigate a full proof-engineering workflow, building auxiliary lemmas, refactoring partial proofs, and maintaining coherence across long horizons. The AVL tree time-complexity proof, for instance, consumed 2.7 million tokens across 22 compactions before arriving at a complete O(log n) bound for insertion and deletion.

The cost-performance frontier bends

The test-time scaling curve released with the model tells a clear story. On PutnamBench, Leanstral 1.5's Pass@8 climbs monotonically from 44 problems solved at a 50k token budget to 587 at 4M tokens. Performance does not plateau; it keeps rising as the model is allowed to reason longer, edit files, and revise. Your AI model says it can read 1 million tokens. It's…

The implication is that the model's ceiling is not yet known. Existing comparisons with systems operating under different conditions, Goedel-Architect with natural-language guidance, Aleph Prover at much higher per-problem cost, become less relevant as Leanstral 1.5's budget increases. The model is not just cheaper; it is scaling more efficiently.

Bugs the tests missed

Benchmark scores matter, but the more practical signal comes from Leanstral 1.5's code-verification pipeline. The team built an automated workflow: Aeneas translates Rust code into Lean, Leanstral infers user intent and generates correctness properties from the code, then attempts to prove each property, and if all proofs fail, it tries to prove the negation instead. The subtle trap waiting for AI agents in production

Across 57 repositories, the pipeline flagged 47 violated properties, of which 11 pointed to genuine bugs. Five of those had not been reported on GitHub before. One example: an overflow in the sign function for zigzag decoding of the datrs/varinteger library. On input Std.U64.MAX, the expression (value + 1) wraps around, causing crashes in debug mode and silent data corruption in release mode, exactly the kind of edge case that fuzzing and testing routinely miss.

The finding underscores a broader shift. Formal verification has long been considered too expensive and impractical for everyday codebases. Leanstral 1.5 does not eliminate the cost, but it lowers the barrier enough that automated bug discovery becomes feasible at scale. At $4 per problem, running a verification pass on a mid-size Rust crate is no longer a research project; it is a reasonable CI step.

The FLTEval benchmark goes open source

Alongside the model, Mistral AI released FLTEval, a benchmark based on real pull requests from the Fermat's Last Theorem repository, as open source. Leanstral 1.5 lifts pass@1 on FLTEval from 21.9 to 28.9 and pass@8 from 31.9 to 43.2, surpassing Opus 4.6's 39.6 at one-seventh the cost. The gap over open-source models three to ten times larger is widening. Meta AI's open-source bet just broke the business model…

What it means for the field

Leanstral 1.5 does not claim to have solved formal verification. The model still struggles with problems that require deep mathematical creativity or domain-specific knowledge not present in its training data. But it demonstrates that the cost barrier, not the technical barrier, has been the bigger constraint on adoption. A mathematical proof that general AI is a myth:…

At $4 per problem, with an Apache-2.0 license and a free API, Leanstral 1.5 makes formal verification accessible to projects that would never have considered it before. The model will not replace human mathematicians or proof engineers, but it changes the calculus of when automation makes sense. And in a field where compute budgets have been the primary gatekeeper, that is a meaningful shift.