A field guide · for Johnny · November 20, 2026

Lean × anything.

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.

2,308 guesses 1,724 proven real 948 root shells $1.21M total 10 new attack techniques
SCROLL
01 · The word you keep hearing

Lean is a judge that can't be charmed.

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.

SEPT 8 · MATH

Navier-Stokes, checked in Lean

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.

AUG 24 · THE JUDGE GETS TESTED

OpenAI's model attacked Lean itself

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.

NOV 4 · LINUX

The checker was a root shell

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.

NOV 10 · TAXES

Someone already did "Lean for taxes"

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.

02 · Show me

Same AI, with and without a checker.

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.

checker = runs the guess for real
0
guesses
0
proven real
0
thrown out
Every dot that gets through has been proven. You can hand the pile to anyone, whether that's a maintainer, a CPA or a reporter, and they don't have to trust the AI.
03 · How OpenAI actually did it

Five rooms, one rule: prove it or drop it.

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.

The haystackLinux kernel
0 lines of code—
Scoutswhere can a normal user reach?
0 targets · 7% of the code$3,426
Analystsread it, make a guess
0 candidate bugs · 12 hrs$316,549
Triagecrash it in a sealed VM
0 reproduced CHECKER$73,330
Screencould this reach root?
0 root candidates$44,194
ExploitDevget a root shell, hardened box
0 unique root exploits CHECKER$775,929
Humansreview, then send patches
root cause + crash + exploit + patch, bundledpeople
COST PER ROOT EXPLOIT
$1,279

Bug-bounty value at $20K–$70K each comes to $18.9M–$66.3M, or 16–55× the run's cost.

GUESSES THAT WERE WRONG
3.1%

Only 3.1% were bad reasoning. Most of the rest were real bugs that were just hard to trigger in time.

BETTER MODEL, SAME SETUP
5.6×

July (GPT-5.6 Sol): 166 exploits. October (new cyber model): 948. The checker didn't change; the guesser got better.

04 · The recipe, minus the Linux

The checker had five properties. That's the whole secret.

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.

1

Whole world in the box

All 40M lines of source sit on the machine, so nothing the AI needs is behind a clerk, a CAPTCHA or someone's memory.

2

Run it yourself

A guess gets tested on demand in a sealed VM. There's no need to wait for an agency, a panel or a court.

3

Clear yes / no

A root shell either opens or it doesn't. There's no "arguably."

4

Cheap per try

A successful exploit cost $359 on average to build, so you can afford thousands of attempts.

5

Can't be sweet-talked

The kernel doesn't read the AI's explanation. A persuasive wrong answer still fails.

20/200
THE PART EVERYONE SKIPS · "USING THE WRONG 0-DAY"

Right answer, wrong reason.

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.

05 · Where the trick transfers · ranked

Your three instincts, plus six more, scored on the five.

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.

in boxrun ityes/nocheapcan't fool
06 · Why we hit walls

We didn't hit a dumb-model wall. We hit three missing-checker walls.

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.

01The verdict lives in a person

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.

02The world isn't in the box

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.

03Rare targets, expensive mistakes

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.

07 · What would actually move it

Better model, different model, different data, or different question?

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.

Better model
Different model
Different data
Different question
Taxes
LOW
The math isn't the hard part. The model was never what blocked us.
HIGH
A tax simulator as the judge. PolicyEngine-US is open source and matched Lexifina's Lean model on 4,993 of 5,000 households.
MED
Your Jan–Oct books, turned into a structured household-plus-entity record.
HIGH
Stop asking "what deductions exist?" and start asking "which of the 200 choices open to me before 12/31 lowers the number the simulator prints?"
Grants
LOW
Writing quality isn't the bottleneck. Finding money nobody else can apply for is.
MED
Turn each program's eligibility rules into code checks, the way Lean checked the tax code's cross-references.
HIGH
Bulk data instead of searches: Grants.gov's XML export, SAM assistance listings, and USAspending award history, which shows how many others actually win each program.
HIGH
Stop asking "will she win?", which can't be checked. Ask "is she one of only five orgs that can legally apply?" That is the PARC pattern, and it's checkable.
Corruption
LOW
Intent can't be proven from public data, so a smarter model just tells a better story.
MED
Entity-matching and graph tools (same address, same officer, same phone) instead of an LLM's gut read.
HIGH
Bulk files with no CAPTCHA: FL corporate SFTP, EMMA bonds, 990 e-file XML, county deed bulk. Add a set of labeled past convictions to test against, our own version of kernelCTF.
HIGH
Stop asking "who's corrupt?" Ask "where do two official records disagree?" Each finding then comes with a certificate, and a human reporter supplies the intent.
08 · The one-line version

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.

    Sources
  1. OpenAI, "A thousand fewer paths to root" (Nov 4, 2026): every pipeline number on this page
  2. Leonardo de Moura, Postmortem for the Kernel Soundness Bug Hunt (Aug 24, 2026)
  3. BrainDetox explainer of Lexifina's Lean tax-code post (Nov 10/16, 2026): secondary source, original not yet read
  4. "Closing the Loop: Formally Verified Law as a Reward Signal" (arXiv, June 2026)
  5. OpenAI Navier-Stokes announcement (Sept 8, 2026), as summarized in our Sept 29 thread
  6. Our own runs: tax hive (Oct 19), NELCM money engine (Nov 19), Project Crown Experiment A (Nov 6)
Built by Clause · Nov 20, 2026 · simple shapes, no libraries, one file