OpenAI Solved 10 Decade-Old Math Problems for $200 Each. 9 Days Later, It Called the Model Too Dangerous.

A capability demo with no product attached

OpenAI has not shipped Astra. There is no release date, no API pricing, and no model card. What exists instead is a research artifact: a paper titled “Ten advances in mathematics and theoretical computer science,” a 249-page manuscript, and a GitHub repository of Lean 4 formalizations, all published August 1, 2026. The 10 results span group theory, von Neumann algebras, high-dimensional geometry, quantum complexity, lattice cryptography, and extremal combinatorics. The headline result is an explicit construction of a non-sofic group, closing a question Mikhail Gromov posed in 1999. Two more are old enough to have outlived the mathematicians who originally posed them: a disproof of Connes's rigidity conjecture on von Neumann algebras, open since 1980, and an improved high-dimensional sphere-packing bound that hadn't moved since 1978. The other seven span Ehrhart's volume conjecture, three problems from Paul Erdős's open-problem catalog including problem 183 on multicolor Ramsey numbers, and results in quantum parallel repetition and lattice-based cryptography, each open for at least a decade. OpenAI hasn't published individual ages for those seven, which matters later.

The $200 number, and what it doesn't say

Every outlet covering the announcement ran some version of the same figure: 10 proofs, $2,000 in compute. OpenAI states that's what the tokens cost at Sol API pricing to find all 10 solutions. Divide it out and it's $200 a proof, for questions that beat professional mathematicians for decades. That part checks out as stated. What doesn't check out is how it got repeated: several headlines and social shares read the figure as $2,000 per problem, not the combined total for all 10 — a 10x overstatement of the actual cost, in the direction that makes the achievement look even more expensive and impressive than OpenAI itself claimed.

Two things are missing from even the correct version of the number. First, nobody has published the token counts behind it, OpenAI included, so the $2,000 figure is a vendor-stated total with no line-level audit trail; there is no way for an outside reader to independently reconstruct it. Second, and more consequentially, the $2,000 prices tokens, not people. OpenAI's own writeup says its researchers helped select the 10 problems, guide the model's search, and prepare the reasoning into the 249-page manuscript that accompanies the proofs. None of that human time carries a dollar figure or an hour count anywhere in the announcement. Compute is the cheap, measurable part of what it took to produce this result. The PhDs in the loop are the part nobody is pricing.

Verified math, unverified narrative

The proofs themselves are on firmer ground than the cost figure. OpenAI formalized all 10 results in Lean 4 and posted the certificates to GitHub under an Apache 2.0 license, which means nobody has to take OpenAI's word for the mathematics: a Lean proof either compiles and checks, or it doesn't. Across all 10 files, the repository's “sorry” count, Lean's marker for an unproven gap papered over in the formalization, sits at 0. Every logical step in every proof is machine-checked.

That is a real, independently verifiable claim, and it's a meaningfully higher bar than a lab simply asserting a result is correct. But formal verification checks one thing: that the proof as written follows from its axioms. It does not check whether OpenAI's framing of what the result means, how hard it was, or how autonomously the model reached it, is complete or honest. As of this article's publication, 0 of the 10 results have been through outside peer review. The math is checked. The story around the math is not.

Nine days later, a different kind of flag

That's the cheap-genius half of the story. On August 7, 2026, four days after the math announcement, OpenAI told reporters it can no longer rule out that Astra crosses into “Critical” on its own Preparedness Framework, the internal scale OpenAI uses to gate model releases by risk category. In that framework, “Critical” cyber-capability is defined as a model that can independently discover and develop working zero-day exploits against hardened, real-world systems, or execute a sophisticated cyberattack from a broad objective, without human assistance. For scale, every earlier frontier model OpenAI has evaluated this way, including its own currently-shipping GPT-5.6 Sol, tested out at “High,” the tier below. According to OpenAI, Astra is the first model the company has ever flagged at the Critical threshold.

The practical difference between the two tiers is the difference between “dangerous with expert help” and “dangerous alone.” A High-tier model can meaningfully uplift a skilled attacker who already knows what they're doing. A Critical-tier model, under OpenAI's own definition, needs neither the expert nor the uplift framing: it can run the attack chain by itself. That distinction is also why the response looks different this time. Rather than a model card and a waitlist, OpenAI is expanding internal security around Astra, isolating its testing environment, and running its safety evaluation alongside outside government agencies before any wider release.

The collateral damage is concrete. OpenAI had promised free Astra access to 100,000 researchers and mathematicians, part of the same push that produced the 10 proofs. That rollout is on hold now. The same week the model outdid 27 years of unsolved mathematics, its own maker decided it couldn't yet put it in 100,000 people's hands.

Why the same lab grading its own homework is the actual story

Put the two announcements side by side and the pattern that emerges isn't a contradiction, it's a symptom. A $200-a-proof number that is real but incomplete: it prices compute and omits the humans, the audit trail, and the peer review. A “Critical” safety flag that is provisional but unprecedented: the first of its kind, self-assessed, with the review still in progress. Both claims came from the same company, about the same unreleased model, 9 days apart. Neither one is verifiable by an outside party using OpenAI's published disclosure alone, because in both cases the entity making the claim is also the only entity positioned to check it: OpenAI selected the problems and wrote the manuscript behind the $200 figure, and OpenAI ran the evaluation behind the Critical flag. That's not necessarily bad faith. It's what happens by default when a lab is simultaneously the inventor, the marketer, and the only auditor of its own frontier model, and it's exactly the situation every reader of a benchmark claim, a cost claim, or a safety claim in 2026 needs a habit for handling.

How to check a vendor capability claim yourself

The Lean formalizations are the one part of this story you can verify without trusting anyone's summary, including this one. Cloning the repository and counting “sorry” markers takes under a minute:

git clone https://github.com/openai/ten-proofs
cd ten-proofs
grep -rc "sorry" --include="*.lean" .
# a 0 across every file means no logical step is left unproven

For the cost and safety claims, there's no equivalent command, and that's the point: a token count or an internal eval transcript isn't something an outside party can independently pull. The more durable habit is reading the primary sentence, not the headline built on top of it. When a number divides cleanly by a round unit ($2,000 over 10 proofs), check whether the source stated a total or a per-unit figure before repeating either. When a risk label changes (“High” to “Critical”), check whether the evaluation was run and graded by the same organization making the release decision, and whether an outside body has reviewed it yet. Neither check requires special access. Both take longer than retweeting the number, which is exactly why most people skip them.

What this means if you're evaluating frontier model claims for work

Astra isn't available through any API yet, so there's no routing decision to make on it today. But the underlying pattern, a vendor-reported cost or capability figure that turns out to be technically accurate and directionally misleading once you read past the headline, isn't unique to this announcement. It's the same failure mode behind inflated benchmark deltas, undisclosed provider-side accuracy drift, and cost claims that quietly exclude the most expensive part of the pipeline. If you're making build-vs-buy or model-selection calls off a vendor's own numbers, MegaBrain routes every request through a single gateway with transparent, at-cost pricing across 500+ models, so what you pay per task is a number you can see and audit yourself instead of a vendor-stated figure you have to take on faith. And if you want something checking new model and safety announcements for exactly this kind of gap between the headline number and the primary source, on a schedule, without you having to remember to do it, mhermesruns 24/7 on its own isolated VM and can poll a source feed and flag the next time a vendor's framing and its own disclosed data start telling two different stories.