AI Agents Are Now Doing Original Mathematics — and Rebuilding Software From Binaries

The week in agentic capability

Two results landed in the same news cycle in May 2026, and together they mark a shift that is easy to miss if you read them as separate model upgrades. The first is a week-long agent run that formalized a deep theorem in algebraic geometry into roughly 600,000 lines of Lean, at an estimated cost of $135,000 US dollars in tokens. The second is a benchmark that every model once failed outright, now resolving 18.5% of its tasks.

Neither number is the story on its own. The story is that both came from documented, reproducible pipelines: a plan, an orchestrator, sub-agents, and a price tag. Agent systems are crossing from assistance into autonomous production work, and the receipts are public.

The formalization effort comes from Resolution, an AI safety startup previously known as Sequent, working on statistical learning theory. Its team autoformalized Hironaka’s resolution of singularities, a foundational result in algebraic geometry, and published the method alongside the result.

The second result is ProgramBench, a benchmark released in May 2026 that asks systems to rebuild real software from nothing but a compiled binary and its documentation. At release, every tested model scored 0% resolved. The current top entry, Claude Opus 5.5 running at the benchmark’s “xhigh” effort setting, posts 18.5% resolved and 70.5% almost.

One is a research artifact measured in lines of verified proof. The other is an engineering gauntlet measured in passing test suites. What they share is the shape of the work: long-horizon, plan-driven, and executed largely without a human in the inner loop.

Inside the formalization effort

The pipeline Resolution describes is refreshingly concrete. A researcher worked with agents to produce two plans: a high-level, human-interpretable plan, and a detailed 112-page plan broken into atomic steps following existing literature. An orchestrator agent then executed that plan, spinning up agents to do pen-and-paper mathematics, write Lean, and handle support functions such as progress checks.

Notably, execution required little scaffolding beyond the initial plan and agent skills distilled from earlier internal autoformalization work. That detail matters for anyone building their own pipelines. The leverage sat in the plan and the reusable skills, not in an elaborate harness. It is the same lesson emerging across the coding-agent ecosystem, where curated skill libraries are doing as much for agent reliability as raw model quality. The patterns catalogued in Five Open-Source Skill Libraries That Turn Coding Agents Into Real Engineers map closely onto what Resolution built in-house.

The economics are equally concrete. The run took about a week and consumed on the order of 100 billion input tokens, 90% of them cache reads, plus about 300 million output tokens. Resolution’s published estimate puts total spend at $135,000 US dollars. Output: about 600,000 lines of Lean.

That cache-read ratio is the quiet hero of the budget. Without aggressive prompt caching, the same run would have cost multiples of that figure.

Why resolution of singularities matters for learning theory

Resolution of singularities is not an arbitrary flex. The team says the work “lays the groundwork for further automated research into the relationship between loss landscape geometry and generalization.”

The library is already in use. Resolution reports it is being applied to extend parts of singular learning theory, a framework that studies how models generalize through the geometry of their loss landscapes. That includes work on better understanding sampling, which the team says informs how models learn, a phenomenon it calls “patterning.” In other words, the formalization is not a trophy sitting on a shelf. It is infrastructure that other research is now building on, days after it was produced.

That feedback loop is the part worth watching. When a formalized library becomes a dependency for new theory, the cost of the original run stops being an expense and starts being an amortized capital investment.

The industrialization-of-mathematics claim

Resolution’s own framing is ambitious: “We expect the coming industrialization of mathematics to make possible a new, rigorous science of research automation.”

Strip away the rhetoric and there is a testable claim underneath. If a week of agent work priced like a small grant can produce a verified library of this scale, then the marginal cost of formal verification falls far enough to change what gets formalized. Proofs that were previously too laborious to mechanize become candidates. And once research automation itself is formalized and measured, it becomes a science rather than a craft.

The cost curve also reframes the $135,000 figure. That is not a rounding error, but it is within reach of a single well-funded lab, and it is the kind of number that falls predictably as caching improves and models get more token-efficient. The interesting question is not whether the next run is cheaper. It is what becomes worth attempting when it is.

ProgramBench: the rebuild-from-scratch test

ProgramBench, detailed in the arXiv paper “ProgramBench: Can Language Models Rebuild Programs From Scratch?”, sets a harder task than code completion. Systems receive only a compiled program and its documentation and must reconstruct the software itself.

The 200 tasks span language interpreters (PHP, Lua, tinycc), databases (DuckDB, SQLite), media and compression utilities (FFmpeg, zstd, xz), and developer tools (ripgrep, fzf, jq). These are not toy programs. Rebuilding a SQLite-compatible database or an FFmpeg-compatible media toolchain from observed behavior and docs requires inferring enormous amounts of undocumented semantics.

From zero to real progress

At release, the benchmark was a wall. Every tested model scored 0% resolved, meaning all tests pass. The best system at release, Claude Opus 4.7, managed 0% resolved and 3% almost, where almost means more than 95% of tests pass.

The current result comes from a later model, Claude Opus 5.5 at xhigh effort, with 18.5% resolved and 70.5% almost. That is a genuine crossing of a threshold that once looked absolute.

Import AI’s author reads the trajectory plainly: ProgramBench should be saturated by the end of 2027, defined as a very high resolved score, though a noise ceiling may prevent a strict 100%. The same prediction extends to 2027 as the year large amounts of software get built end-to-end autonomously by AI systems.

Caveats and open questions

The enthusiasm deserves calibration on three fronts.

First, reproducibility. Resolution’s disclosure of token counts and cache-read ratios is exactly the kind of reporting more agent papers should include. A 90% cache-read share means the run is sensitive to how caching is priced and configured, so anyone hoping to replicate the result should expect their bill to depend heavily on infrastructure choices, not just model choice.

Second, the “almost” column. A 70.5% almost score means most attempts pass more than 95% of tests. That sounds like near-success, but the long tail of failing tests is where the hardest semantics live. Systems that get 95% of a database engine right may still be unusable for real workloads.

Third, saturation claims. A benchmark with a noise ceiling complicates any prediction of when it is “done.” The gap between 18.5% and a very high resolved score is where most of the remaining difficulty sits, and progress there may not be linear.

There is also a governance question that grows louder as pipelines like these become routine. Resolution’s run dispatched sub-agents for a week with minimal human oversight in the inner loop, exactly the operating mode that stresses the assumptions behind human review, a tension explored in Human-in-the-Loop AI Is Broken: Hugging Face Researchers Say Safeguards Push People Out. And when many agents operate in parallel, coordination failures become a real risk, as the incidents documented in When AI Agents Talk Behind Our Backs: Inside the 2026 Agent Collusion Incidents make clear.

The binding constraint has moved

For the past two years the question was which model writes better code or proves better lemmas. Resolution’s run and ProgramBench’s climb both suggest the answer increasingly lies in pipeline design: how you decompose the work, how you cache, how you verify progress, and how much you are willing to spend before you call it done. Resolution’s leverage came from a human-interpretable plan, a detailed atomic-step plan, an orchestrator dispatching specialized sub-agents for math, code, and progress checks, and a small set of distilled skills. None of that is exotic, and all of it is portable.

The same logic applies to what gets built next. If Resolution’s Lean output is already feeding singular learning theory, the pattern will repeat in other fields: a verified artifact that others import rather than rebuild. Tracking which libraries exist and what they depend on is becoming a research skill in its own right.

The models set the ceiling. The pipeline decides whether you get anywhere near it.