OpenAI Astra: What the Math Proofs Actually Prove

OpenAI Astra: What the Math Proofs Actually Prove

Two dates tell this entire story, and the gap between them is the only thing worth paying attention to.

October 2025. An OpenAI VP posts that GPT-5 "found solutions to 10 (!) previously unsolved Erdős problems." The tweet gets deleted. Thomas Bloom — the Manchester mathematician who actually maintains erdosproblems.com — calls it "a dramatic misrepresentation." The model hadn't solved anything. It had run a literature search and surfaced papers Bloom personally hadn't catalogued. Demis Hassabis, in public, says "this is embarrassing." Yann LeCun piles on.

August 1, 2026. OpenAI publishes ten results in mathematics and theoretical computer science, produced by an unreleased internal model called OpenAI Astra. Same company. Same claim shape. Ten problems again, which is either a coincidence or the pettiest flex in AI history.

This time there's a GitHub repo.

That repo — openai/ten-proofs — contains Lean 4 formalizations of all ten results, Apache 2.0 licensed, pinned to Lean toolchain 4.32.0 with mathlib. Two commands in the README: lake exe cache get, then lake build All. If it compiles, the math is correct. Not "correct according to OpenAI." Correct according to a proof checker that has no idea who wrote the input and no incentive to be polite about it.

I've spent the last two days reading the coverage, the repo structure, and the reactions from actual mathematicians. I want to walk you through what's verified, what's being spun, and — the part almost nobody is writing about — what this changes for those of us who run AI agent fleets for a living and have to decide, every single day, which of their outputs to trust.

Because the interesting shift here isn't that a model did hard math. It's how the claim was made.

What OpenAI Astra Actually Published on August 1

Let me pin down the facts before anyone's narrative gets near them.

OpenAI released a paper titled "Ten advances in mathematics and theoretical computer science," a 249-page manuscript collection, model-written reasoning walkthroughs, and the Lean certificate repo. The ten results, taken directly from the filenames in that repository:

Eight distinct fields. Not ten variations on one trick.

Astra itself is not released, not priced, and not even finally named. Reporting from The Information — which broke the story before the paper dropped — describes it as a model family built for multi-agent, long-horizon work: several agents coordinating on different parts of one problem, running for hours or days. Sam Altman demoed it to policymakers and regulators in Washington in late July, ahead of the publication. OpenAI hasn't decided whether it ships as GPT-6, as something like GPT-5.7, or as a separate class alongside their Sol, Terra and Luna lines.

And no, it didn't crack a Millennium Prize Problem. OpenAI researcher Noam Brown said so himself: "Sadly, no Millennium Prize Problems (yet)." The parenthetical is doing a lot of work, and he knows it.

Why the Non-Sofic Group Result Is the One That Matters

Nine of these are strong. One is the headline, and it's worth understanding why even if you never touch group theory again.

A group is "sofic" if you can approximate its behavior arbitrarily well using finite permutation systems. Mikhail Gromov introduced the idea in 1999. Here's the uncomfortable part: essentially every group mathematicians work with in practice — all amenable groups, all residually finite groups — is sofic. Nobody could find one that wasn't. Nobody could prove one had to exist either. For 27 years the question just sat there, a hole in the middle of a well-travelled field.

Astra produced an explicit construction of a non-sofic group.

Notice the word construction. Proving something exists is one kind of achievement. Handing over the actual object, written down, checkable, is a different and generally harder one. Thomas Bloom — the same mathematician who publicly dismantled OpenAI's 2025 claim — put it this way: "Maybe not bigger than a proof of unit distance would have been, but in terms of constructions, this is big."

That's the same guy. Ten months apart. That reversal is more informative than any benchmark chart.

Timothy Gowers, a Fields medalist, said he'd recommend one of these proofs for Annals of Mathematics — arguably the most selective journal in the field — without hesitation. Terence Tao responded by sketching a vision he calls "big mathematics": large decentralized collaborations where humans take creative direction and machines handle the derivation load.

None of this has been through formal peer review yet. Mathematicians have read preprints and reacted; that's not the same as refereeing. Hold that thought, because it matters less than you'd expect, and I'll explain why in the next section.

What Is Formal Verification, and Why Does It Make OpenAI Astra's Claims Checkable?

Formal verification means writing a mathematical proof in a language a computer can mechanically check, step by step, with zero interpretive leeway. Lean 4 is that language here. Every definition, every inference, every lemma gets reduced to a chain the compiler either accepts or rejects. There is no partial credit and no benefit of the doubt.

The mechanism that makes this bulletproof is a keyword: sorry. In Lean, sorry is the escape hatch you write when you want to skip a step and come back to it — it tells the compiler "trust me on this one." Any proof containing a sorry is not a proof. It's a sketch with a hole in it.

The openai/ten-proofs repository reports a sorry count of zero.

Sit with what that does to the epistemics. In October 2025, evaluating OpenAI's claim required you to either trust a VP's tweet or personally know enough about Erdős problems to check. In August 2026, evaluating the claim requires elan, a Lean toolchain, and about as much effort as building any mid-sized open-source project. You don't need a PhD. You don't need to trust OpenAI. You don't even need to understand the mathematics.

That is a genuinely different category of claim, and it's the actual news.

Now — a real caveat that the excited coverage keeps skipping. Verified is not the same as understood. Lean will happily confirm that a proof is valid without any human being able to say why it's true. Outside mathematicians have already had to write "digested" versions of these arguments to make them legible. A machine-checked proof nobody comprehends advances the literature but not necessarily the field's understanding, and those are different currencies.

Google DeepMind has been working this same territory, which is worth flagging because the coverage has been weirdly OpenAI-shaped. AlphaProof took silver-medal performance at IMO 2024. AlphaProof Nexus, released in May 2026, combined LLM reasoning with Lean verification and evolutionary search borrowed from AlphaEvolve — prover subagents sampling from a shared population of proof sketches, with rating agents scoring them head-to-head into Elo rankings. It autonomously solved nine open Erdős problems and proved 44 OEIS conjectures. Same verification bar. Less press.

Two labs, independently, landed on the same architecture: generative search plus a mechanical verifier. That convergence is the signal. Not the announcement.

Where the $2,000 Number Falls Apart

Every headline ran with it: ten decades-old problems, solved for about $2,000 in compute. It's a fantastic number. It's also the softest claim in the whole announcement, and I'd rather you hear the problem from me than find out later.

OpenAI's actual wording is careful in a way that should make you tilt your head: the tokens used "would cost roughly $2,000 at Sol API rates."

Two things are buried in that sentence.

First, Astra is unreleased and unpriced. That figure isn't Astra's cost. It's a counterfactual — what that token volume would have cost if you'd bought it at a different model's published rates. It's a unit-conversion exercise dressed as a receipt.

Second, and more important: the number counts only the wins. Ten proofs succeeded. We have no idea how many runs failed, how many problems Astra attacked and lost, or how much compute those attempts consumed. There's no walkthrough of the failures. There is no denominator.

I want to be fair here — that's not fraud, it's how every capability announcement in this industry works. But if you've ever run a large agent job and watched your token spend, you know exactly how much the denominator matters. My successful Claude Code runs are cheap. My total spend is not, because the failed and abandoned and re-prompted runs don't disappear from the bill just because they don't make it into the writeup.

Report your winners' cost and you can make almost any workflow look free.

What This Looks Like From Inside an Agent Fleet

Time for the part I can actually speak to first-hand, and the part where I need to be straight with you about what I can't.

I have not tested OpenAI Astra. Nobody outside OpenAI has. It's unreleased, and I'm not going to write you a fake hands-on review of a model I have no access to — that's the exact failure mode that produced the October 2025 mess in the first place. What I do have is a year of running multi-agent setups every working day: Claude Code agent fleets across client projects, parallel agents isolated in git worktrees, and the agent teams playbook I've been refining for months. Astra's described architecture — multiple specialized agents, coordinating over long horizons on one problem — is the thing I already live in, just at a scale I'll never afford.

So here's the pattern I recognize, and it's the one nobody's writing about.

METR — the evaluation nonprofit that tracks how long a task an AI can complete — publishes two numbers, and the gap between them is where every agent fleet actually lives. In their Time Horizon 1.1 report from January 2026, the strongest models they assessed hit roughly 16–20 hours on the 50% horizon and 3–4 hours on the 80% horizon. Same models. Same suite. (METR themselves caution that estimates above 16 hours are unreliable because the task suite starts saturating up there.)

Read those two numbers again.

At a coin-flip success rate, an agent can chew through most of a working day. At a rate you'd actually accept in production, you get an afternoon. The doubling trend is real and fast — METR measures post-2023 doubling at about 131 days under the updated methodology — but the reliability gap doubles right along with it. Capability and trustworthiness are not the same curve.

This is my entire operational reality, compressed into two numbers. When I dispatch four agents in parallel against a refactor, I'm not managing their capability. I'm managing the distance between what they can attempt and what they can be relied on to finish correctly. Every workflow I've built that survived contact with a real client deadline exists to close that gap.

Which brings me to the thing I actually took from the Astra announcement.

The Verifier Gate: The Habit Worth Stealing From This

OpenAI didn't solve the trust problem by making a better model. They solved it by ending the chain in something that can't be argued with.

That's a design pattern, and it's portable. It's the discipline I've been building toward for a year without having a clean name for it, and Astra gave me one. For every agent task, before I dispatch anything, I ask one question:

What's the lake build for this?

Meaning: what is the cheap, mechanical, non-negotiable check that says this output is correct — one that doesn't involve me reading the diff and vibing? If I can't answer, I'm not running an agent workflow. I'm running a plausible-text generator with a git remote, and I've made myself the bottleneck.

Here's how that maps in practice:

1. Typed code — tsc --noEmit, PHPStan, mypy. Types are the closest thing most of us have to a proof checker, and they're sitting right there unused in half the projects I audit. An agent that can't produce type-clean output has not finished.
2. Tests written before the agent runs, not after. If the agent writes both the implementation and its tests, you've verified nothing. It'll happily write a test that asserts its own bug. Write the assertion first, then let the agent chase green.
3. Schema validation on every boundary. Zod, Pydantic, Laravel form requests. Agents are extremely good at producing JSON that looks right and is subtly wrong in the fourth field.
4. Actual HTTP calls, not described ones. The single most common failure I see: an agent reports an integration works because the code reads like it works. Make it curl the endpoint and show you the status code.
5. Migrations run against a scratch database. Never against anything real, ever — but never merely reviewed by eye either. Idempotent, transaction-wrapped, and executed somewhere disposable first.
6. A second agent that only criticizes. This one's cheap and disproportionately effective. One agent implements, a separate agent with a clean context reviews against the original requirement. It catches the class of error where the implementer quietly redefined the task halfway through.

Notice what's common to all six: none of them require me to be smarter than the agent. They require the check to be mechanical. That's the whole lesson from the Lean repo, scaled down to a working developer's Tuesday.

If you'd rather have someone build this kind of verified agent pipeline into your stack rather than assemble it yourself, that's a good chunk of what I do — you can see the work at fiverr.com/s/EgxYmWD.

The uncomfortable corollary: an agent's confidence is decoration. It carries no information about correctness. I've watched Claude Code declare a task complete, in a tone of total assurance, with a build that doesn't compile. Not because the model is bad — because "sounding finished" and "being finished" are produced by different mechanisms, and only one of them is being optimized. The verifier isn't there because the model is unreliable. It's there because confidence and correctness are orthogonal, permanently, at every capability level.

That's exactly why the Astra announcement lands and the 2025 one didn't. Nothing about the second announcement asks you to believe OpenAI. That's the innovation.

What I'm Not Buying Yet

Let me flag the parts of this story where the coverage is running ahead of the evidence, because several of them are circulating as fact.

"Agent one." I've seen this term attached to Astra in secondhand summaries — the idea that OpenAI has hit some named tier of autonomous, multi-day agent capability. I searched for it specifically and found nothing in the primary reporting. Treat it as unsourced until someone can point at an OpenAI document. The underlying claim — long-horizon multi-agent work over hours or days — is in The Information's reporting. The label isn't.

The name and the timeline. "Astra" is tentative. There's no release date, no pricing, no API. Anything you read about GPT-6's launch window is speculation, and I've written before about how much of the GPT-6 discourse is unsourced. Nothing here changes that.

The Washington demo framing. Altman demoing to Treasury and Commerce officials before publishing is a real event, and it's also a policy move as much as a scientific one. A capability demo in front of regulators, days before a review framework lands, is doing more than one job. Read it accordingly.

The attribution question is genuinely unsettled. OpenAI argued that claiming human authorship would "misrepresent both the system's contribution and the nature of genuine human intellectual work" — so they credit Astra. Meanwhile they also acknowledge that OpenAI researchers helped prepare the papers and formalize the proofs, and that the company takes responsibility for accuracy. Both things are in the same announcement.

And this lands in a room that is already tense. The Leiden Declaration on Artificial Intelligence and Mathematics, published June 2026 and endorsed by the International Mathematical Union, was signed by Terence Tao, Peter Scholze, Kevin Buzzard and Scott Aaronson among others. Over a thousand signatures on day one. It warns about AI companies using published mathematical research without consent, bypassing peer review, and eroding proof and attribution as community norms. It was presented at the International Congress of Mathematicians in July — weeks before this announcement.

So the field's most credentialed people simultaneously called one of these proofs Annals-worthy and signed a declaration warning about exactly this dynamic. Both reactions are correct. Which is what makes it interesting rather than simple.

What Actually Changes for a Working Developer

Realistic version, no acceleration fan fiction.

Nothing changes this quarter. You can't use Astra. Your stack is the same today as it was last week. Anyone telling you to restructure your workflow around an unreleased model is selling something.

The verifier discipline changes right now, and it's free. Every point in the six-item list above works with tools already in your project. It's the single most useful thing in this article and it costs you an afternoon of setup. Adding a type gate and a pre-written test suite to an agent workflow is the difference between agents that save you time and agents that generate review debt.

The 50/80 gap is your planning number, not the headline capability. When you scope agent work, scope to the 80% horizon. Assume the model reliably handles the smaller unit and needs a checkpoint. Building on the 50% number is how teams end up with four hours of unreviewable output and a deadline.

Watch for the verification bar spreading beyond math. Formal verification works in mathematics because math is fully formalizable. Most software isn't. But the pattern — generative search paired with a mechanical checker — already applies to type systems, property-based testing, and schema contracts. It's also showing up in security, where the debate over AI-discovered vulnerabilities is stuck on the exact same problem: unverifiable claims from labs with an incentive to make them. That fight ends the same way this one did, or it doesn't end.

And keep your eye on the capability trend, not the announcement cadence. I've argued before that practical AGI arrived quietly and by the labs' own numbers, not with a press release. This fits that shape. A model nobody can use produced results that will be in the literature for decades, and the most consequential detail was a sorry count of zero.

The Only Thing I'd Ask You to Remember

Go back to the two dates.

October 2025: a claim, a deleted tweet, and a mathematician spending his weekend explaining to the internet that a literature search is not a proof.

August 2026: a claim, a repo, and two commands that let anyone on earth with a laptop settle the question without asking permission.

The model got better in between. Sure. But the model getting better is the least interesting thing that happened, because models get better every quarter and it never once made a marketing claim more trustworthy. What actually changed is that OpenAI stopped asking to be believed and started shipping something falsifiable.

That's available to you, today, on whatever you're building. Not the frontier model — the posture. Every agent output you can't mechanically check is an October 2025 tweet. Every one you can is an August 2026 repo.

So: what's the lake build for the thing you're shipping this week? If you can't name it in one sentence, that's the work.

Let's Work Together

Looking to build AI systems, automate workflows, or scale your tech infrastructure? I'd love to help.

• Fiverr (custom builds & integrations): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise solutions): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (security services): xcybersecurity.io