OpenAI’s Astra: How AI Reasoning and Lean Verified Ten Math Results

On August 1, 2026, OpenAI published machine-checkable proofs for ten problems in mathematics and theoretical computer science, each open for a decade or more.

One result constructs a non-sofic group, settling a question in group theory that has stood open since 1999. The proofs were generated by an internal model called Astra, and each ships with a certificate that anyone can verify on their own laptop.

Claims like this have appeared before and drawn quick skepticism. An output that looks like a proof is not the same as one you can independently check. Earlier AI math announcements often rested on a plausible chain of reasoning that quietly skipped a step, and no one outside the lab could confirm the gap. The Astra results stand apart because of the engineering that made them verifiable.

This article breaks down that engineering. You will see what Astra actually produced, how its reasoning layer sustains hours of coherent work on a single problem, and why the Lean verification layer changes what the claim is worth.

That pattern applies to any AI system that has to prove its outputs are correct, which is why it matters beyond mathematics.

What Astra Actually Produced

Astra is the internal model OpenAI describes as its next major release, and it generated new results for ten long-standing open problems, spanning fields from high-dimensional geometry and coding theory through group theory and lattice cryptography. The full set of results also disproves Connes’s rigidity conjecture, and resolves several problems from Paul Erdős’s catalog.

From an engineering perspective, the method used to release these results is particularly noteworthy. Alongside a 249-page manuscript, OpenAI published a Lean 4 proof certificate for each result on GitHub. Crucially, the repository reports a "sorry" count of zero, the standard Lean indicator confirming that every step within the proofs has been rigorously verified.

OpenAI also expressed the compute cost in plain terms. The API tokens (units of compute cost) needed to find the ten solutions would run about $2,000 at the API rates for its Sol tier.

Three caveats come first, as the engineering only makes sense against them.

• None of the ten results has cleared formal peer review.
• Human researchers worked with the model to turn its arguments into publishable manuscripts.
• And a Lean certificate confirms that the logic is sound, though it cannot confirm that the formal statement captures what the open problem actually asks. The last check falls to a mathematician.

The Reasoning Layer: Sustaining Long-Horizon Work

Research mathematics is not a single inference. It is hours of exploration, where you follow an approach until it fails, then retreat and try another, holding the whole structure in view the entire time.

This long-horizon coherence is exactly where earlier models broke down, losing track of the argument once a problem stretched across many steps and hours of work.

Astra’s architecture is built to hold a line of reasoning together across that span. It coordinates the work over a long horizon so the system can stay on one problem far longer than a single-pass model manages, exploring and discarding paths without losing the context that makes the next step possible.

The reasoning walkthroughs OpenAI released read more like a careful collaborator’s notebook, selecting a path and discarding unproductive avenues, then updating the approach as the evidence shifts.

A strong model becomes a true research tool only when it extends beyond raw capability to sustain a coherent line of work, efficiently prune bad directions, and persist long after a shorter process would have stalled.

The Verification Layer: Why Lean 4 Changes the Claim

The reasoning layer produces an argument. The verification layer is what makes that argument trustworthy, and it is what separates this announcement from the ones before it.

Lean 4 is a proof assistant, a programming language that forces every step of a mathematical argument into a form a machine can check. Its kernel returns a binary verdict, so a proof either compiles or it does not. When a Lean proof type-checks, it is valid by construction, so the model’s own claims carry no weight in the verdict. This means you can verify the proofs independently without relying on OpenAI’s interpretation. You can download the certificates from the public repository and run them yourself.

This closes the failure mode that undermined earlier AI math claims, the plausible-looking chain that skips over a single unproven step. A "sorry" in Lean marks a gap where a step is asserted but not proven, and a count of zero means every step across the ten proofs is filled in. The compiler will not accept anything less.

What Lean cannot do is judge meaning, and holding that line matters. The kernel confirms that the argument is internally consistent and follows correctly from its premises. It does not confirm that the formalized statement matches the problem mathematicians care about, or that the result is significant. A human reviewer still has to read the formal statement, agree it says what the open problem asks, and weigh what the result means for the field.

Question	Lean Verification Answers It	A Human Still Answers It
Does every step follow logically?	Yes, the kernel checks each one	No
Are there hidden gaps in the proof?	Yes, a "sorry" count of zero confirms none	No
Does the formal statement match the real problem?	No	Yes, a mathematician confirms it
Does the result matter to the field?	No	Yes, the community judges significance
Has it passed formal peer review?	No	Yes

Reasoning and Verification as One System

The result depends on the two layers working together. A core model generates the mathematics, while a system architecture built for sustained reasoning holds that work together over many hours. A proof checker then verifies the output. Without the verification, you are left with a claim you cannot check. Without the long-horizon reasoning, the model never reaches a result worth checking.

This generate-and-check approach is a general engineering pattern, and it is the most portable idea in the whole announcement. The generator proposes a candidate, and a formal checker accepts or rejects it against strict rules. Trust rests on the checker, which is deterministic and auditable. The generator can remain probabilistic, because its output has to pass the checker before it counts. The design lets you use a model whose individual outputs you cannot fully trust and yet get a result you can fully verify.

The Nature Machine Intelligence editorial Solutions, challenges and rising tensions in AI and mathematics, published in June 2026, framed the broader problem clearly. Mathematical output can in principle be verified, yet the workflows for checking and independently verifying AI output have not kept pace with how quickly the tools are being used. A system that generates and formally verifies in one pipeline is a direct answer to that gap.

What This Means for AI Systems Engineering

The same structure carries over to engineering problems outside mathematics. Any domain that needs a provably correct answer, where looking convincing is not enough, can pair a generative model with an automated verifier. Formal verification of code checks a program against a specification the same way Lean checks a proof against its premises. The generate-and-verify loop already appears in fields like cryptographic proof and hardware verification, and it extends naturally to any pipeline where a checker can encode the rules of correctness.

Building systems this way is a specific engineering discipline. It requires designing the verifier as carefully as the generator, deciding which parts of a task can be checked automatically and which still need human judgment, and integrating the two into a reliable pipeline. The system-level integration and engineering judgment behind this kind of work are core competencies in the Chartered AI Engineering Professional (CAiEP®), which develops the skill to build production-grade AI systems where reliability is the point. You can follow how these engineering practices are evolving through ARTiBA’s insights on applied AI, and compare credentialing paths across the full range of AI certifications.

The cost figure deserves a careful reading. Roughly $2,000 in tokens produced ten research-level results, though that number reflects the successful runs only and leaves out every attempt that failed along the way. It measures what the successes cost to generate, and it excludes the full price of the research. Even read that narrowly, a figure that low shows how far the cost of machine-assisted reasoning has fallen.

The Limits and the Open Questions

Several questions about the results remain unresolved. Peer review is still pending on the ten, and a formal, refereed process remains the standard the mathematical community expects. Questions of credit and authorship are being worked out, given that the arguments came from the model while humans prepared the manuscripts. Reproducing the process is difficult, since the model that produced the results is not publicly available. Verifying the finished proofs is straightforward by comparison, because the certificates are public.

There is a deeper point beneath the mechanics. Verification guarantees that an argument is correct. It says nothing about whether the result is meaningful or advances the field the way a human research program would. A proof can compile cleanly and say less than it appears to, if the formalization drifts from the question that mathematicians actually care about.

The verification layer is valuable because it separates what a machine can settle from what still requires human judgment. Keeping that separation explicit is what makes the approach trustworthy.

Final Words

For engineers, the architecture is the notable part of this work, more than the mathematical results. A model can now keep a single line of reasoning intact across hours of work on a hard problem, and an automated checker can make the output verifiable by anyone. Together they replace a claim you would have to take at face value with one you can confirm. The mathematics demonstrates the idea, and the pairing of generation with verification is the part that transfers to other work.

If you build reasoning systems, treat the verifier as a first-class component from the start. Decide early what correctness means for your task, encode it in a checker that can accept or reject an output on strict terms, and design the generator to feed that checker. Build it that way, and you get systems whose results you can prove, in a field that has too often asked you to accept them without proof.