OpenAI turned the hunt for Linux security holes into a factory: 948 working root exploits at $1,279 each. The model was the engine, but the trick was the checker, a test that can't be talked into a yes. "Lean for X" is just the question "what's the checker for X?" This page answers it for taxes, grants and corruption.
Lean is a programming language that checks math proofs line by line. Give it a proof and it says yes or no. It doesn't care how confident the argument sounds or who wrote it. That's why it became shorthand. When people say "Lean for law" or "Lean for taxes," they mean build the thing that can't be fooled, then let the AI guess as much as it wants.
About 10,000 agents worked on the problem for 88 hours. Then a model spent 17 hours translating the proof into Lean. People believed the result because of the Lean check, not because of the agent count.
An OpenAI internal model found ways to make Lean's own checker accept a proof of False. It overflowed a reference counter, and it exploited an old math-library bug. All of it was fixed in v4.33.1. Even the checker needs checking.
No Lean here. In the Linux work the checker was a sandboxed virtual machine. Either the exploit gets root on a stock, hardened kernel or it doesn't. Same idea, different judge.
Lexifina put the US tax code's cross-references and the 2025 Form 1040 math into Lean. That turned up 138 real drafting errors in Title 26. Using the model as an oracle, a search with no tax knowledge rediscovered the known planning moves and turned up 3 that nobody had published.
Each dot is one AI guess, like "this line of code is a bug" or "this vendor looks shady." About 3 in 4 of them are right, which is roughly what OpenAI measured. Flip the switch and watch what happens to your confidence.
This is from OpenAI's own write-up, published Nov 4 and run in mid-October on the newest kernel. The top bar is the whole kernel. From the Analysts row down, bars are to scale with each other. Watch where the money goes. Most of it is spent proving things, not guessing them.
Bug-bounty value at $20K–$70K each comes to $18.9M–$66.3M, or 16–55× the run's cost.
Only 3.1% were bad reasoning. Most of the rest were real bugs that were just hard to trigger in time.
July (GPT-5.6 Sol): 166 exploits. October (new cyber model): 948. The checker didn't change; the guesser got better.
Strip out the kernel and five ingredients are left. Linux scores perfectly on every one. Below, I score our own problems against the same five.
All 40M lines of source sit on the machine, so nothing the AI needs is behind a clerk, a CAPTCHA or someone's memory.
A guess gets tested on demand in a sealed VM. There's no need to wait for an agency, a panel or a court.
A root shell either opens or it doesn't. There's no "arguably."
A successful exploit cost $359 on average to build, so you can afford thousands of attempts.
The kernel doesn't read the AI's explanation. A persuasive wrong answer still fails.
In an early run, 20 of 200 "successful" exploits had reached root through a different bug than the one they were assigned. The checker said yes, but the path was wrong. OpenAI added a second, independent check on the route the exploit took. Verify the path, not just the result. This is exactly what bit our Crown blind test, where post-hoc hits landed on the right org for the wrong reasons.
Each bar is one ingredient: green = we have it, amber = partly, red = missing. The ranking weighs checkability against what the problem is worth to you. Tap a row to see why it scored that way.
Across the tax hive (Oct 19), the museum money engine (Nov 19) and Project Crown (Nov 6–7), the same three walls kept showing up. None of them gets fixed by a smarter model.
For taxes the real yes comes from your CPA or the IRS. For grants it's a review panel, months later. For corruption it's a jury, years later. In none of these can I run the checker myself, so each round of the hive ended up grading itself. That's why your Oct 19 tax run read as "a lot of no." The lanes were judging each other's prose.
Linux ships every line of its source. Corruption evidence sits behind clerk CAPTCHAs (which we won't defeat), records requests and private bank flows. Your tax facts are in your books and your head. Grant decisions are private. The AI can only check what it can see.
In Linux, 3 of every 4 candidates were real, and a false alarm costs some compute. Corruption is rare, and a false alarm costs a reputation. Crown's checklist arm hit 3 of 3 cases but flagged 81% of clean orgs too. With a rare target and no checker, a better model mostly produces more convincing false positives.
OpenAI's 5.6× jump came from a better model pointed at a checker it already had. A better model multiplies whatever checker you have, so with no checker it multiplies zero. For all three of your problems the biggest lever is changing the question into one that can be checked.
Build the judge first.
Then let the AI guess a million times.
Everything OpenAI did downstream (scouts, analysts, 948 exploits) is guessing at scale. It only works because a root shell can't be faked. Our past runs went the other way: lots of smart guessing, with the judging done by the same kind of mind that did the guessing. Here are the three judges I'd build, in order.
Load your books into PolicyEngine-US as the judge, then search every choice you can still make before Dec 31 (timing, retirement accounts, equipment purchases, how income splits). Each idea comes back with a dollar delta the simulator computed, not a paragraph. Lexifina's guess is that the big unpublished savings live in moves between an owner and their entity, which is your situation. The simulator doesn't model entity rules yet, so that layer still goes to your CPA.
Turn every federal and Louisiana/Florida program's eligibility rules into checks, run every org you care about through them, and sort by how few others qualify. This is the PARC win made repeatable.
Use only public bulk data. Each flag pairs two official records that can't both be true, with both cited. It stays quiet about who did what and why. That part belongs to a person.