# OpenAI Astra: Ten Open Math Problems Solved with Machine-Checkable Proofs Bold claims are cheap in AI, so the interesting part of OpenAI's latest announcement is not the headline. It is the receipt attached to it. OpenAI says an internal version of its next major model, Astra, produced solutions to ten open problems in mathematics and theoretical computer science, each unsolved for at least a decade, and it shipped every proof in a form a computer can check line by line. **You do not have to trust the lab, the model, or a reviewer. You can run the proofs yourself.** The company published a [249-page manuscript](https://cdn.openai.com/pdf/ten-proofs-oai.pdf) laying out the arguments in human-readable form, along with a separate set of reasoning walkthroughs in which the model narrates how it approached each problem. Alongside those sit machine-checkable certificates on GitHub. For software engineers, the natural question is what an AI that proves abstract conjectures has to do with building software. The answer is in the architecture, and it maps onto some of the hardest problems in our field. This article walks through what Astra did, how the proofs are verified with the [Lean](https://lean-lang.org/) proof assistant, the long-horizon design that lets a model stay on one problem for hours, and what that capability means for large-scale engineering work. ## What Astra actually achieved The results were announced in an OpenAI post titled ["Ten advances in mathematics and theoretical computer science."](https://openai.com/index/ten-advances-in-mathematics/) These are not textbook exercises. They are long-standing open questions across fields like group theory, geometry, coding theory, quantum complexity, and lattice cryptography. ### The ten advances publication The post lays out ten distinct results. The headline is the **first explicit construction of a non-sofic group**, which settles a question that had stood open since Mikhail Gromov introduced the concept of soficity in 1999. Nearly every group mathematicians use in practice is sofic, and for 27 years nobody could show whether a non-sofic one existed. Astra built one. Other results include a disproof of Connes's rigidity conjecture from 1980, a proof of Ehrhart's volume conjecture, three resolved Erdős problems, and the first improvement to the general upper bound on high-dimensional sphere-packing density since 1978. ![A screenshot of the OpenAI blog post title, "Ten advances in mathematics and theoretical computer science," with the text highlighted.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/925c7835-828c-4190-e61b-fb55321eb300/lg1x =1280x720) OpenAI's head of mathematics research, Sebastien Bubeck, confirmed the results on X and called them "beautiful." Thomas Bloom, the mathematician behind erdosproblems.com, called the batch "big news." What makes these different from ordinary model output is the kind of work involved: exploring a large logical space, discarding dead ends, and constructing an argument that holds from the first assumption to the last. ### Why this announcement came with so much evidence OpenAI had good reason to be careful this time. In October 2025, then-vice president Kevin Weil posted that GPT-5 had solved ten previously unsolved Erdős problems. The claim drew attention and was quickly walked back. Bloom, asked to verify it, found that the model had not proved anything new. It had surfaced existing solutions from the mathematical literature that he simply had not catalogued. Weil left OpenAI in April 2026. ![A screenshot of a news article or tweet showing the retracted claim about GPT-5 solving Erdős problems.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/4131c790-8652-4a21-4563-62fcf774c200/lg2x =1280x720) That episode set the standard for this one. A claim of genuine discovery needs proof anyone can check, not a plausible-looking argument that quietly skips a step. So instead of publishing a paper and waiting months for peer review, OpenAI provided proofs in a format a machine can verify. ## Trust, but verify: formal proofs with Lean The most important part of the announcement is that the results are verifiable without trusting OpenAI. The proofs are written in a language whose kernel either accepts an argument or rejects it, with nothing in between. ### What a proof language does At the center of this is [Lean](https://lean-lang.org/), a functional programming language and proof assistant built for formalizing mathematics. If you write software, the analogy is direct. Lean is like a compiler for logic. You write mathematical statements and their proofs as code, and a small trusted core called the kernel checks every step for consistency. Just as a compiler refuses to build code with a syntax error, Lean fails if a proof contains a logical gap or an invalid step. If the code builds, every step from the axioms to the conclusion is valid, with no hidden assumptions and no room for ambiguity. It is the same instinct behind writing tests rather than trusting that code works because you wrote it. You let an impartial machine decide. ### How the proofs were generated and checked The workflow OpenAI described is a collaboration between the model and human mathematicians, designed for rigor. It runs in four stages. First, Astra works on the problem, sometimes for a long time, and produces the core insight and strategy for a proof. Then human mathematicians write that strategy up as a traditional, readable manuscript so it can be communicated to the wider community. Next, the model translates the manuscript into the strict formal syntax of Lean. Finally, Lean's kernel checks the formalization, and if it accepts the proof without errors, the result is formally verified. ![A diagram illustrating the four-step verification process: Astra writes argument -> Humans write it up -> Astra formalizes in Lean -> Lean's kernel checks it.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ae93c329-8898-4698-9fa4-261cf962a300/lg2x =1280x720) The design is clever because it shrinks what you have to trust. You do not need to trust OpenAI or the Astra model. You only need to trust the small, well-understood Lean kernel. The proofs are open-source artifacts you can download and run yourself. ![A view of the open-source GitHub repository `openai/ten-proofs`, showing the `.lean` files available for public inspection.](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/5c26939a-1efc-423c-d339-6dd08d46d700/md1x =1280x720) The certificates live in the [openai/ten-proofs](https://github.com/openai/ten-proofs) repository, a standard Lean 4 project using mathlib and Lake, with each result in a named module like `NonSoficGroup.lean` and `ConnesRigidity.lean`. The repository's count of unproven placeholders is zero, so every step across all ten formalizations is checked. One caveat is worth keeping in view: **Lean-verified is not the same as peer-reviewed.** The certificates prove each formalized argument is valid, but the community still has to agree the formalized statement is the one that matters, and none of the ten results has cleared a journal yet. ## Built for endurance: long-horizon reasoning Solving one of these problems is not a single-shot task. It means exploring countless dead ends, holding a lot of context in memory, and keeping one coherent line of reasoning going over hours or days. This is a long-horizon task, and it is exactly what earlier models struggled with. Astra appears to be built for it. ### The coherence problem If you have ever had a long, complex conversation with a chatbot, you have felt coherence drift. Early on it is sharp and on-topic. As the context fills up, the model forgets earlier decisions, loses the thread of the goal, and starts repeating itself or contradicting what it said before. That is a serious barrier for hard problems. Picture writing a large application. You start with a clear plan, but after hours the volume of context, all the class definitions, function signatures, and state logic, becomes overwhelming, and you forget a decision you made earlier and introduce a bug. Models hit a digital version of the same wall. A long proof is the strictest possible test of coherence, because there is no test suite to catch a slip. One incoherent step invalidates the whole argument. ### A root agent and its subagents The capability behind Astra's endurance appears to be an agentic architecture. Rather than one monolithic model doing everything at once, the system coordinates several agents. OpenAI has not fully detailed how that coordination works, so treat the outline below as an illustration of the pattern rather than a description of Astra's internals. A root agent sits at the top and behaves like a chief architect. It takes the high-level problem, say proving a sphere-packing bound down to the Cohn-Elkies threshold, and decomposes it into smaller sub-tasks, such as the individual lemmas the proof needs. It delegates those to subagents, each a capable model given a focused, constrained problem, and they can work in parallel. When the subagents return their results, the root agent synthesizes the pieces into a single coherent proof. ![A flowchart diagram showing a "Root agent" at the top, branching out to three "Subagents," which then converge into a "Final answer."](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/59011699-5374-4e9a-dcc3-1987128d9e00/lg1x =1280x720) The strength of this divide-and-conquer approach is that no single agent's context has to hold the entire problem. Each subagent worries only about its slice, while the root agent manages strategy and makes sure the pieces fit. ### The cost of coordination This architecture is not a free lunch. Coordinating multiple agents adds its own complexity, often called coordination overhead. Every time the root agent defines a task, hands it off, and integrates the result, there is a computational cost. For tightly coupled problems that need constant feedback, that overhead can make the system slower, and small errors passed between agents can compound into a wrong answer. For problems that decompose cleanly, like many proofs or large refactors where modules can move independently, the approach pays off. Astra's success on these ten problems shows that for the right class of problem, the gains from splitting the work outweigh the cost of coordinating it. ## Why this matters for software engineers Proving theorems is impressive, but the underlying capability, sustained and coherent reasoning over a long horizon, maps directly onto the hardest problems in software. The same design that keeps a model focused on a proof for days applies to the long-running tasks that define real engineering work. ### From proofs to large-scale refactoring Consider rewriting a large legacy codebase from one language to another. It is a classic long-horizon problem: thousands of files, tangled dependencies, and architectural consistency that has to hold over weeks or months. A system built like Astra could approach it in stages. A root agent analyzes the codebase, maps the modules and their dependencies, and defines sub-tasks like rewriting the HTTP parser, refactoring the core runtime loop, or generating bindings between old and new components. Subagents then work those tasks in parallel, each on a specific module. As they finish, the root agent integrates the new code, runs the tests, and checks that the pieces work together. That is a step beyond code completion. It is automated, large-scale architecture and implementation aimed at work that today takes a team of senior engineers. The same shape applies to architectural migrations like moving from a monolith to microservices, end-to-end feature implementation from a product spec, and deep bug hunts that span an entire system. ### The economics of machine reasoning OpenAI put the total compute for the successful runs that solved all ten problems at roughly **$2,000** at the API rates for Sol, one of its current models. That number is startling for novel results, though it covers only the successful runs, not the many failed attempts, and not the cost of building and training the model. The real research bill is far higher. Still, the direction is clear. When a compute run in this range produces results that might take a team of researchers years, the economics of science and R&D start to shift. On the limits, OpenAI researcher Noam Brown noted that the model did not crack any Millennium Prize Problems, at least not yet. ### An amplifier, not a replacement This kind of news always raises the question of whether AI is about to replace mathematicians, and by extension engineers. That framing misses what is actually happening. The model is proving conjectures posed by humans, using theories built over more than a century of human work, inside a system designed and trained by people, on a corpus written by mathematicians. It is not working in a vacuum. Astra is better understood as an amplifier of human intellect than a substitute for it. It can take on the tedious, large-scale work and open up problem spaces that were too vast to navigate before, which frees people to focus on strategy, judgment, and what the results actually mean. The release also lands at a tense moment for that relationship. The International Mathematical Union endorsed the Leiden Declaration on AI and Mathematics this year, which raises concerns about how AI labs use published research and sidestep peer review, and OpenAI cited it in the announcement while acknowledging that the mathematical ideas came from the model. ## Final thoughts Astra is a pivotal marker in how AI reasoning is developing, and it rests on three things working together: a capable core model, a rigorous verification layer built on Lean that makes the results independently checkable, and an agentic architecture that lets the system divide and conquer long-horizon problems that broke earlier models on coherence. For engineers, this is a preview of where the tools are heading. The next generation looks less like a co-pilot suggesting the next line and more like an autonomous system you can point at a large, messy project and trust to plan and execute it. Pointing something at a legacy codebase and saying "refactor this" is no longer science fiction. Keep two honest caveats in mind as this gets scrutinized over the coming months. **The proofs are Lean-verified but not yet peer-reviewed**, and questions of authorship and credit are still being worked out. Astra itself is unreleased, so its practical limits will only become clear once the wider community can put it to work.