Ten math problems that sat open for a decade or more. One unreleased model. About $2,000 in API tokens.
That is the headline from OpenAI's August 2026 research release, and it is easy to dismiss as hype until you look at what they actually shipped: a 249-page manuscript, reasoning walkthroughs, and Lean 4 proof certificates in the openai/ten-proofs repository with zero unproven placeholders.
I build agent systems for clients, not pure math research. But this release changed how I think about verification in AI workflows. The interesting part is not "AI solved math." It is that OpenAI chose machine-checkable formal proofs as the trust layer, and priced the whole run at pocket-change compute.
What Astra actually produced
OpenAI credits an internal version of Astra, its next frontier model, with the underlying mathematical reasoning. Human researchers turned model output into publishable manuscripts. Astra then formalized each result in Lean 4.
The ten results span group theory, sphere packing, coding theory, arithmetic circuit complexity, and Erdős problems:
| Result area | What changed |
|---|---|
| Group theory | First explicit construction of a non-sofic group |
| Analysis | Disproof of Connes's rigidity conjecture |
| Sphere packing | Improved asymptotic upper bounds reaching the Cohn-Elkies threshold |
| Coding theory | Exponentially stronger bounds for binary and spherical codes |
| Complexity | New lower bounds for computing the permanent with arithmetic circuits |
| Erdős catalog | Progress on problems 146, 180, and 183 |
Some of these questions were untouched for 30 years. The breadth across fields matters as much as any single result. One lucky strike is noise. Ten verified results in one release looks like a repeatable capability.
Why Lean 4 changes the trust model
LLM math has a credibility problem. Models hallucinate steps, skip logic, and sound confident while being wrong. Peer review catches errors eventually, but slowly.
Lean sidesteps that. Lean is a proof assistant: every logical step must compile. If the proof builds, the theorem holds under Lean's axioms. No hand-waving.
OpenAI published certificates you can verify without trusting their press release:
# Clone openai/ten-proofs, then: lake exe cache get lake build All
Individual modules build separately too (lake build SpherePacking, lake build NonSoficGroup, and so on). The repository uses only three standard Lean axioms. The sorry count is zero across all ten formalizations.
That is the guardrail I want more agent systems to copy. Not "trust the model output." Run the checker.
The $2,000 number is the real story
OpenAI priced the token spend at GPT-5.6 Sol API rates: about $2,000 for all ten solutions, roughly $200 each.
That figure is not the full research cost. Humans still reviewed, wrote papers, and ran the formalization pipeline. But it frames frontier reasoning as a budget line item. At $200 per open problem, theorem discovery starts looking like a batch job any funded lab could run.
Research scientist Noam Brown noted the model used a relatively modest test-time compute budget, with larger reasoning budgets still available. OpenAI has not released Astra publicly, so you cannot replicate the exact run today. You can replicate the verification: clone the repo and build.
For operators like me, the pricing metaphor transfers. When verification is cheap and automated, the constraint shifts from "can we afford the compute?" to "can we design the check?"
How this connects to Astra's cyber pause
A week after the math headlines, OpenAI flagged Astra for a different reason. Internal evals suggested the same model family might hit Critical cybersecurity capability under its Preparedness Framework. I wrote about that separately in OpenAI hit the brakes on Astra.
Same model, two lenses. Math proofs with public Lean certificates on one side. Paused agentic cyber work on the other. The pattern is capability outpacing our release and verification playbooks.
What I would steal for production agents
Pure math is not my day job. But the release encodes three practices worth copying in applied AI:
1. Machine-checkable outputs. When an agent produces code, SQL, or config, run the compiler, linter, or test suite before you trust it. Lean is the extreme case. Your CI pipeline is the practical one.
2. Publish the certificates. OpenAI put proofs on GitHub under Apache 2.0. In client work, that means versioned artifacts, not just chat logs. If the agent claims it fixed a bug, the PR diff and green tests are the certificate.
3. Price the run. The $2,000 figure forces a conversation about unit economics. What does one verified agent task cost you? If you cannot answer that, you are flying blind on margins.
Useful references:
The honest caveat
Lean proofs verify formal correctness under Lean's logic. They do not replace peer review of whether the formalization matches the mathematical question humans care about. OpenAI says the results need further human mathematician review.
The smart framing is neither "AI conquered math" nor "just hype." Verifiable AI reasoning reached the research frontier. The guardrail that makes it credible, machine-checkable proof, is exactly what makes it worth paying attention to.
If you are wiring agents into production systems and want help designing verification layers that actually catch failures, book a free discovery call. I would rather spend an hour on your test harness than on another benchmark leaderboard.