AI Slop Watch: Axiom Math's Bold Plan to Verify Mathematics

It feels like artificial intelligence is cracking a new math problem every week. New papers pour out of labs at machine speed, and a wave of AI slop now washes over mathematics, the one discipline that once prided itself on slow, human certainty. Last month OpenAI released 719 manuscripts claiming solutions to long-standing problems, and researchers discovered that even the computer checks meant to confirm such results can slip (see the follow-up analysis on arXiv). After years of AI slop in art, code, and copy, it is fair to wonder whether math is next; that episode is AI slop at academic scale.

One startup is betting its entire future on the answer. Axiom Math, now valued at $1.6 billion, wants to build a verified foundation that AI agents can lean on as they write software and, eventually, do science. Instead of generating more answers, it manufactures certainty. This article breaks down who Axiom is, what it just formalized, how a fleet of agents did it, and why the company is daring every coding lab in the industry to try the same.

In This Article

1. The Rising Tide of AI Slop in Mathematics
2. Axiom Math at a Glance
3. The Stacks Project: A Library Built by Hand
4. Sixteen Million Lines of Trust
5. The Fleet of Agents That Did the Work
6. The Black Hole at the Center of Math
7. Beyond Math: Verified Foundations for Software
8. Axiom’s Dare to the Coding Giants
References

The Rising Tide of AI Slop in Mathematics

Why certainty is the scarce resource

Mathematics has always had a quality gate. A proof is accepted when other mathematicians can walk through it line by line and find no gap. That process is slow, human, and imperfect, but it has kept centuries of results trustworthy. AI slop breaks the gate not by producing wrong answers, but by flooding it. When a lab drops hundreds of confident, plausible, machine-generated manuscripts at once, the human review layer simply cannot absorb them.

The OpenAI episode made the problem concrete. The company published 719 manuscripts claiming solutions to open problems, and observers noted that even the automated checkers used to vet such work can miss subtle errors. As one critique of AI-generated math put it, checking is the bottleneck, and unchecked confidence is exactly what AI slop looks like inside a theorem. The discipline that built its identity on rigor is suddenly drowning in unvetted volume.

What AI slop actually means in math

In images and blog posts, AI slop means blurry, hollow, low-effort output. In mathematics, the same idea takes a more dangerous form: statements that look true, proofs that look valid, and definitions that quietly disagree with each other. A single inconsistent lemma dropped into a shared library can poison every downstream result that cites it. That is why many mathematicians expect AI slop to reach their journals before it gets caught.

Axiom Math was founded to attack this exact fear. If generation is cheap and verification is expensive, the company reasons, then the real business is verification itself. Building a trustworthy, machine-checked base for mathematical knowledge turns the AI slop flood from an extinction event into an opportunity.

Axiom Math at a Glance

The company betting on proof

Axiom Math is a young company with a very old ambition: write down all of mathematics so precisely that a computer can check it. Founded in March 2025, it is led by CEO Carina Hong, a 25-year-old who dropped out of Stanford’s math PhD program to build it. Her pitch to investors was that the bottleneck in AI progress is not intelligence but trust, and that trust has to be manufactured deliberately to keep AI slop from compounding.

The market listened. In March, Axiom raised a $200 million Series A led by Menlo Ventures, a round that lifted its valuation to $1.6 billion and made it one of the fastest-moving names in applied AI, as tracked on TechCrunch’s running list of new unicorns. For a company whose product is, literally, verified truth, the capital arrives at the perfect moment for the age of AI slop.

Axiom by the numbers

Here is the quick profile of the company before we look at what it actually did.

Item	Detail
Founded	March 2025
CEO	Carina Hong, 25, Stanford math PhD dropout
Series A	$200M, led by Menlo Ventures (March 2026)
Valuation	$1.6 billion
Core bet	Verification, not generation, is the scarce good
Flagship result	Full formalization of the Stacks Project into Lean
Positioning	A verified substrate for AI agents that write software and do science

What makes the story unusual is not the funding total; plenty of AI companies raise large rounds. What makes it unusual is what the money bought. Axiom did not ship a chatbot, an API, or a coding assistant. It ran a fleet of custom AI agents over one of the largest bodies of human mathematics and returned it in a form that no longer requires human faith, which is the strongest known defense against AI slop.

The Stacks Project: A Library Built by Hand

A cathedral raised one brick at a time

The Stacks Project is the reference manual much of modern algebra quietly depends on. Columbia mathematician Johan de Jong started it in 2005 as an open-source encyclopedia of algebra, geometry, and number theory, written to be rigorous, complete, and freely reusable. It ranges from college-level introductions all the way to the most advanced results in the field, with thousands of pages of carefully cross-referenced lemmas, theorems, and proofs.

Columbia number theorist Peter Woit, who has chronicled the project for years on his blog, says there is “nothing else really comparable” to it. He places the Stacks work in the lineage of the famous Bourbaki books, the secret seminar that tried to rebuild mathematics from set-theoretic foundations in the twentieth century. Where Bourbaki wrote by hand for decades, this library grew as a collaborative, version-controlled, openly licensed organism, page by page, proof by proof.

Why interconnection makes it fragile

The Stacks theorems are chained together like a family tree. Lemma 17.4 supports Theorem 22.9, which supports a construction three chapters later, which a working algebraist cites tomorrow. Formalizing such a body is not merely translating prose; every connection has to survive the move. Drop a single link and the genealogy collapses into AI slop: confident statements with no inheritance.

Axiom’s team admits they were not sure the beast could be tamed. The Stacks library had spent twenty years under human stewardship, and the thought of pointing a fleet of language-model agents at it sounded less like engineering and more like defacing a monument. Choosing this test case was itself a statement about how seriously the company treats the AI slop threat.

Sixteen Million Lines of Trust

How formalization works

The method is called formal verification. A proof is rewritten as code in a language such as Lean, and a proof assistant checks the code line by line against the rules of logic. If every line passes, the result is not “probably correct” or “reviewed by three experts”; it is logically sound, machine-verified, and immune to the quiet mistakes that let AI slop slip through human eyes.

Axiom announced on a Wednesday that its fleet of AI agents had translated roughly 7,654 pages of the Stacks Project into about 16 million lines of computer-checked Lean code. The company described it as one of the largest bodies of mathematics ever formally verified, and the scale genuinely is hard to overstate: sixteen million lines, every dependency intact, every theorem still pointing at the lemmas it needs, and no room for AI slop to hide.

Formal versus informal: two ways to trust a proof

The table below contrasts the traditional human process with the machine-checked one Axiom is industrializing.

Dimension	Informal (traditional) math	Formal (machine-checked) math
Who checks	Other mathematicians, reading prose	A proof assistant, checking code
Standard of trust	Social consensus, “no one found an error”	Logical soundness, mechanically enforced
Speed	Months to years of peer review	Seconds to re-run checks, hours to write formal proofs
Failure mode	Subtle errors survive, retracted papers	Cost and tedium of writing proofs
Vulnerability to AI slop	High: plausible text passes tired eyes	Low: unchecked claims simply do not compile

What the scale actually looks like

Put the three numbers of the moment side by side and the shift in effort becomes visible: the raw paper, the checked code, and the wave of unverified manuscripts now hitting mathematics at once.

OpenAI manuscripts claimed in one batch: 719

Stacks Project pages formalized: 7,654

Machine-checked Lean lines produced: ~16,000,000

Those same pages in human-read prose: 7,654 (trust still manual)

The 2,000-to-1 ratio between prose pages and Lean lines is the price of certainty – and the reason no one attempted this by hand, or bothered to filter out AI slop at this scale before.

The Fleet of Agents That Did the Work

Loose hierarchy, busy agents

Axiom did not send a single giant model through the Stacks volumes one page at a time. It deployed a fleet of agents over a loose hierarchy. Ashvin Swaminathan, a member of Axiom’s technical staff, described how the work organized itself: the agents were finding tasks for themselves and identifying things they could work on in parallel, with humans setting direction rather than assigning tickets.

The company also trained its own models for mathematics, something Hong says most other verification startups have not done. Early on, an in-house Lean expert taught the agents what she called a human sense of taste: which proofs were elegant, which definitions belonged together, which shortcuts would rot later. Over time, the agents began picking up that taste on their own, which is precisely how a workforce learns to reject AI slop before it lands.

Why vibe coding nearly broke the beauty

None of this was smooth. The theorems of Stacks hang together like a family tree, and Axiom was unsure the exercise could preserve that structure at all. Hong put the tension plainly: things that are big and things that are delicate in life just don’t go together. The team wanted theorems to stay consistent and not paradoxical, definitions that did not fight with each other across thousands of pages.

“We were not sure if vibe coding would be able to preserve the beauty of Stacks,” Hong said. Vibe coding, the practice of letting models generate code that merely works, is the software cousin of AI slop: output that compiles today and corrodes tomorrow. The agents had to do better than that, holding every dependency in a 16-million-line web intact while moving through mathematics no human had time to read.

“Things that are big and things that are delicate in life just don’t go together… We were not sure if vibe coding would be able to preserve the beauty of Stacks.”
– Carina Hong, CEO of Axiom Math

The Black Hole at the Center of Math

The region no one had mapped

Formal mathematicians have a running complaint: when you survey what humanity has machine-checked so far, the map has a huge blank in it. Swaminathan named the blank directly. When you look at what has been formalized in mathematics, he observed, there is this huge black hole, and that black hole covers algebraic geometry, the dense thicket of modern geometry that underpins large parts of number theory and physics.

The Stacks Project is precisely the canonical text of that territory, which is why Axiom chose it. The company’s answer to the old complaint came in four words: well, now they do. Algebraic geometry, the most intimidating blank on the formalization map, is now covered by millions of lines of Lean that a proof assistant accepts, and AI slop cannot hide inside a corpus that refuses to compile.

Why coverage compounds

The deeper point is that formalized mathematics behaves like software rather than like essays. Once a lemma exists in checked form, every future agent and library can import it forever. Terence Tao, the Fields Medalist who has become the field’s most influential voice on formalization, captured the compounding effect: the more formalized proofs you have, the more formalized proofs you can make.

Swaminathan drew the same conclusion for machines: agents can read our code, understand it, and build new infrastructure on top of it, and the Lean formalization is now the substrate that agents can build upon. That is the strategic prize in the fight against AI slop. A community drowning in slop produces claims; a verified substrate produces load-bearing knowledge. Every agent that builds on Stacks-in-Lean starts from ground that cannot quietly be wrong.

Beyond Math: Verified Foundations for Software

The same idea already secures chips

Formal verification is not a mathematics fetish; it is industrial practice. The same idea is used to certify chip designs, where a handful of missing transistors can cost a fab billions, and practitioners argue that these fundamentals remain non-negotiable even in the new verification revolution. When the price of being wrong is catastrophic, companies pay to have machines prove correctness.

Software has lagged hardware, but the gap is closing. In France, researchers working with Lean formalized the exact rules of the country’s family-benefits system and, in doing so, surfaced real bugs in the software that computes benefits for millions of households. The paper describing the work is on arXiv, and its moral is uncomfortable: hidden defects were not caught by decades of testing but were caught the moment someone wrote the rules down precisely enough to check.

Why AI-written code makes this urgent

Developers have always wanted bug-free, security-hole-free code, and have always had to compromise. Artificial intelligence makes the compromise far more expensive, because agents now write an ever-growing share of the world’s code, and unreviewed agent output is where AI slop becomes an outage, an exploit, or a recall. Verification research is increasingly pitched as the hot new answer to the AI safety crisis, and AI slop in a deploy pipeline costs far more than AI slop in a blog post.

Axiom’s bet is that future software will rest on verified foundations the way skyscrapers rest on bedrock. The mathematical library is the first floor; the checked specifications and proof infrastructure built on top are the second; the agents that write, test, and evolve software while calling on those libraries are the tenants. If the substrate is AI slop, every tenant inherits the rot. If the substrate is machine-checked, agents can move fast precisely because the floor cannot give way.

Axiom's Dare to the Coding Giants

The reusable-library argument

Hong’s core claim is that agents cannot grow knowledge unless the ground beneath it is well built. You want agents to have a reusable library for them to build on and keep pushing the frontier, she argues, and if you slop drop in bad engineering choices at the beginning, it becomes very hard for them to grow that boundary. Sloppy foundations are not a neutral starting point; they are a tax that compounds every time an agent builds on them. In Hong’s telling, AI slop is an engineering debt that never amortizes.

That is why Axiom frames the Stacks result less as a curiosity and more as infrastructure. A verified mathematical base is the most demanding stress test available: the most interconnected, most delicate, most prestige-laden body of knowledge humanity has. If agentic verification can carry that across without turning it into AI slop, the same pipeline can plausibly handle a company’s codebase, a hospital’s protocols, or a government’s benefit rules.

The challenge itself

Hong is explicit that she wants rivals to try. “I openly challenge all the coding companies to work on formalization at this scale,” she said. The dare lands hardest on the coding labs whose assistants already write enormous volumes of code without proofs attached. Those labs optimize for generation; Axiom is betting the market will eventually pay for certainty, and that the two strategies will collide over the fate of AI slop.

There is a reasonable skeptic’s column too. Lean expertise is scarce, formalization costs remain brutal, and machine-checked does not mean machine-understood; a checked theorem can still be the wrong theorem about reality. And Axiom must still prove a business, not just a library. But the direction of travel is hard to dispute, especially for readers already watching how the math community absorbs OpenAI’s advances, why agents cheat in math benchmarks, and how fast results like the refutation of the exponential time hypothesis move through the field. The slop problem and the verification business are growing up in the same decade.

If Axiom is right, the outcome of the AI race will not be decided by who generates the most confident text, but by who first surrounds generation with checks strong enough to trust. Mathematics, the oldest discipline, may end up as the newest battleground against AI slop.