Mistral Leanstral 1.5: Formal Verification Just Became a Sellable Service.
Mistral released Leanstral 1.5, and it just opened a consulting service category that has been theoretically possible for 20 years but practically impossible without a PhD in mathematical logic.
Leanstral generates proofs in Lean 4, a formal verification language. You describe what a function should do (in English or in code), Leanstral generates a proof that the function actually does it. Not "the function passes 50,000 test cases." A mathematical proof. Your sorting algorithm terminates. Your access control logic is sound. Your cryptographic library doesn't leak timing information.
For the last decade, security consultants have been saying "you should formally verify your critical code." The response was always "that costs $500K and requires hiring a specialized mathematician." Now you can generate proofs in an afternoon.
What Leanstral actually does
Lean 4 is a proof assistant, a language where you write both code and proofs that the code is correct. A proof might establish that a function terminates (it doesn't infinite-loop), that it returns the type it claims, that it doesn't have off-by-one errors, or that a cryptographic operation doesn't leak secrets through timing.
Writing proofs in Lean manually requires understanding formal logic, type theory, and the Lean language itself. It's a skill that takes months to develop.
Leanstral automates it. You describe the problem (natural language + code), Leanstral generates the Lean proof. The breakthrough is that the automation is good enough to be useful for real code.
Example: you have a financial contract that calculates loan interest. You write a function. Leanstral generates a Lean proof that the function correctly implements your interest calculation formula, never overflows, and handles edge cases (zero-balance accounts, negative interest rates, etc.) as specified.
The proof is mathematically sound. It's not a test. It's evidence that the code works as promised.
Why this matters: regulatory bodies just acquired a new weapon
For the last five years, finance has been moving toward "explainability": the requirement to explain how an algorithm made a decision. Formal verification is the inverse: proof that the algorithm does what you say it does.
The SEC, FERC (for critical infrastructure), and FDA (for medical devices) are all moving toward requiring evidence of correctness for code that affects safety or capital. Formal verification proofs are that evidence.
Right now, the bar is "we ran integration tests and a penetration test." Starting in 2027-2028, expect regulators to ask "do you have formal proofs of correctness for your critical systems?"
The company with Lean proofs is defensible. The one with test coverage is liable.
The new consulting service
Here's the service you can sell:
Formal Verification Audit: $15K–$50K engagement. You identify the critical functions in a codebase (access control, payment processing, encryption, compliance logic). You run Leanstral against specs of what those functions should do. You deliver proofs that can be shown to auditors, regulators, or in litigation.
Formally Verified Financial Logic: $30K–$100K per function. You work with a fintech client to formally specify their interest calculations, fee algorithms, or risk models. You generate and validate Leanstral proofs. You deliver proof artifacts that can be included in regulatory filings.
Cryptographic Proofs: $20K–$80K engagement. You work with security teams to formally verify that encryption implementations don't have side-channel leaks (timing, power consumption, cache access patterns). Leanstral generates proofs.
Compliance-Critical Code: $25K–$150K per system. You formally verify the code that determines access control, audit logging, or data classification. The proof becomes part of your compliance certification.
These aren't theoretical. Regulators in finance already ask for this. As of 2026, you can actually deliver it.
The honest catch
Not every function needs formal verification. Network handlers, UI logic, business logic: these work fine with testing. The cost/benefit doesn't make sense.
But the code that moves money, guards secrets, or proves compliance? That code should be formally verified. And now you can sell that as a service without hiring a mathematician.
Leanstral isn't perfect. It can't verify every property of every function. Performance optimization, for instance, is hard to specify formally (you need to know the target platform, the compiler, the CPU). But for functional correctness ("does this code implement the spec") Leanstral is genuinely good.
The catch is that you need to be able to write the spec. If your client says "we want this verified" but can't articulate what "correct" means, Leanstral can't help. Your job is to interview the client, extract the spec, run Leanstral, and interpret the results.
What to do this week
- Read through Lean 4 basics. You don't need to write proofs manually, but you need to understand what the proofs mean.
- Identify which of your clients have code that moves money or guards access.
- Read Mistral's Leanstral documentation and run it on a toy spec (write a simple function, describe what it should do, generate a proof).
- Reach out to your most security-sensitive clients and say: "I can now formally prove your critical code is correct. Here's what that means."
The market for this doesn't exist yet, but it's about to. The regulatory winds are moving toward proof-of-correctness. You can be ahead of them, or you can watch a specialized firm win the category.
Author
Lukas
@lukcombinator