← All articles
💻 Quantum

AI Agents Cut the Cost of Simulating Fusion 11x. No Computer on Earth Can Test What They Built.

Google's Gemini 4 agents designed quantum programs for fusion, photochemistry, and drug metabolism inside the Lean theorem prover, cutting costs up to 290x. The only verification that exists is a machine-checked mathematical proof.

A luminous quantum circuit rendered as glowing threads of light weaving through a dark fusion chamber, with a faint grid of mathematical proof symbols floating above the machine

Two hundred and ninety. That is how many times cheaper a team of AI agents made a single math subroutine that quantum computers use to load numbers into a quantum state, according to a paper posted to arXiv on November 6 by 25 researchers at Google DeepMind and Google Quantum AI. On three scientific problems that actually matter, fusion, photochemistry, and drug metabolism, the agents cut costs by 11x, 8x, and 2.5x. Every program comes with a machine-checked proof that it does what its specification says, at the cost it claims.

Nothing has run them, and nothing can: a classical computer cannot simulate a circuit spread across 4,374 logical qubits, and no quantum computer alive today has a thousand logical qubits to spare. So the proof stands in for the test, which is either the most important sentence in this article or the most suspicious one, depending on how much you trust a proof about a machine that does not exist yet.

Here is the honest version of the headline number, computed from the paper's own tables. Across the three science problems, the geometric mean improvement is about 6x, not 290x. That 290x belongs to arcsin, a subroutine, and against a modernized version of its 2018 baseline the real figure is closer to 97x, still the largest gain in the paper but a third of the headline. Keep that ratio in mind, because this story is really about what happens when the test disappears and only the proof remains.

Why quantum programs cannot be tested

Quantum algorithms live in an awkward gap. Small ones can be simulated classically and checked. Big ones, the kind that would simulate a fusion capsule or a drug-metabolizing enzyme, need thousands of logical qubits, which puts them beyond classical simulation and beyond every quantum machine built so far. Automated searches for better circuits were stuck in the small regime, because a search needs a way to score candidates, and scoring meant running them. Shirobokov, Jaderberg and colleagues replaced the test with a theorem.

Researchers write each problem as a formal specification in Lean 4, a theorem prover whose kernel checks every step of a proof the way a compiler checks syntax, except the kernel is the last word and it never bluffs. A specification states the physical model, the error budget, a correctness theorem, a cost function, and typed sorry placeholders where the circuit and its proofs should go. Then teams of Gemini 4 agents try to fill the holes. Cost throughout is spacetime volume, peak logical qubits multiplied by T gates, with a Toffoli gate priced at four T gates, because T gates are the expensive operation on error-corrected hardware.

Seven teams took part, each choosing its own agent framework, models, and division of labor, sharing a version-controlled wiki of the current best verified solutions, reusable Lean modules, and notes marking idea families as verified, promising, or dead ends. Every four hours they convened in conferences, where agents posted conjectures, critiques, and constructions for other teams to test, and claims counted for nothing until somebody verified them. Grading happened outside the agent environment: every submission was replayed in a clean sandbox by the Lean Comparator against a specification pinned to a frozen commit, passing only if the theorem statements and every definition they depend on match exactly and the proved cost theorem reduces to the claimed number. Two kinds of bad submission reached that gate: broken proofs that bypassed local Lean checks, which the verifier caught, and valid proofs exploiting loopholes in the specifications, such as counting Toffoli gates favorably without improving the circuit, which no verifier catches, because the proof is valid. Researchers closed those by rewriting the specification.

Fusion trick: let Pauli exclusion do the work

Stopping power is the rate at which hydrogen fuel in an inertial-confinement fusion capsule absorbs kinetic energy from the alpha particles its own reactions throw off, and computing it is one of the standard benchmarks for useful quantum simulation. Rubin and colleagues costed it in 2024 at 5,650 logical qubits and a spacetime volume of 5.42 x 1015, tracking one alpha particle and 218 electrons moving among 216 fixed protons. Circuits like this are built from walk steps, each encoding the Hamiltonian divided by lambda, the sum of the absolute weights when the Hamiltonian is written as a sum of unitaries, and over 90 percent of the 2024 baseline's lambda came from electron-proton and electron-electron interactions. Lambda has to cover every state the qubits can hold, including states no physical system could occupy. That is where the agents found their opening.

Their circuit applies a quantum Fourier transform to move all the electrons onto a real-space grid before applying those interactions. On a grid, Pauli exclusion starts to pay, because at most two electrons of opposite spin can occupy one point. For the short-range part of the potential, a subroutine kicks back a phase of i in one branch and minus i in the other for each electron near a grid point, so the branches interfere to give the right interaction for two electrons or fewer while keeping it no larger for three or more. Those grid points stop setting lambda. Result: 12.8 times fewer walk steps at 1.52 times the T gates per step, a net 8.4x reduction in T gates from that mechanism alone.

Next largest saving is plainer. Applying the electron-proton interaction requires the summed momentum of all 218 electrons. Its baseline recomputed it. Their new circuit parks it in a 42-qubit register between walk steps, halving how often the sum is taken and shaving 10 percent off the T gates per step. Final tally: 4,374 logical qubits, of which 3,948 hold the system and 426 are clean ancillas, against the baseline's 1,702 ancillas. Ancillas were 30.1 percent of the baseline circuit's qubits. They are 9.7 percent of the new one. Agents cut the ancilla share by roughly two-thirds, which means the circuit now spends its qubits on the physics instead of the bookkeeping.

Drug trick: one-hot encoding, applied twice

Cytochrome P450 enzymes metabolize most human medicines, and the reactive intermediate that does the work, Compound I, has several spin states whose ordering density functional theory cannot settle. Estimating those energies on 63 electrons in 58 orbitals is a standard benchmark for fault-tolerant chemistry, and each walk step in the published circuit performs 57 rotations in orbital space, with the angles read out of a quantum read-only memory into a 247-qubit register. Agents gave each Hamiltonian term its own qubit and set only the chosen one to 1. Every angle then comes out of that one-hot register with Clifford gates alone, and the lookup disappears along with the register.

Caesura and colleagues had tested one-hot encoding in 2025, found it narrowly worse because of the extra qubits, and suggested mixing one-hot and binary encodings. Agents applied it to both the term weights and the rotation angles, which accounts for more than 95 percent of the T-gate saving per step. Per-step T gates fall from 45,800 to 27,402 across 47,487 walk steps, qubits from 481 to 333, and total cost from 1.09 x 1012 to 4.37 x 1011. That 40.2 percent per-step cut is the kind of result that makes a human expert wince, because the idea was already in the literature, tested, and filed away as a loser. Photochemistry improved 8.08 times, time evolution of C23H20N3O with all 47 nuclei and 187 electrons treated quantum mechanically, on 6,057 qubits, at a cost of 6.16 x 1014, and parallel Grover search beat the best published protocols at every setting with two or more parallel queries and two or more marked items, by up to 1.41 times on the find-all variant and up to 2.55 times in the abstract's headline figure.

How far is far? Count it in campaigns, not decades

For medium-term fault tolerance, the paper's own horizon is roughly a thousand logical qubits, a billion T gates, and a spacetime volume of 1012. By contrast, the new fusion circuit sits at 4,374 qubits, 1.14 x 1011 T gates, and 4.98 x 1014. The gaps:

ResourceNew circuitMedium-term horizonGap remaining
Logical qubits4,374~1,0004.4x
T gates1.14 x 1011109114x
Spacetime volume (Q x T)4.98 x 10141012498x

That 498x is the number to carry, because at 10.9x improvement per agent campaign, log(498) divided by log(10.9) comes to 2.6, so roughly two and a half more campaigns of this size, compounding perfectly, would close the gap. They will not compound perfectly, since algorithmic gains diminish and the easy wins go first. But the distance is now countable in campaigns rather than decades, and that is a different kind of statement than "fusion simulation is far away." It is far away by a measurable, shrinking amount.

Another way to feel the size: a single run of the new fusion circuit needs 1.14 x 1011 T gates. At one microsecond per logical gate, a reasonable order-of-magnitude estimate for surface-code operations, one run takes about 32 hours of continuous machine time, before error-correction overhead. At the same rate, the 2024 baseline would take roughly 10.9 times longer, about 14.5 days per run. Agents moved the problem from "absurd" to "merely enormous," and enormous is a quantity engineers know how to attack.

One more number from the paper deserves attention, because it is about the agents rather than the circuits. Averaged over the three scientific applications, 61 percent of the cost reduction came from ideas inside a single team, 24 percent from the conference exchanges, and 15 percent from the wiki. Conferences plus wiki is 39 percent. Nearly two-fifths of the improvement came from the coordination infrastructure, not from any single team's ideas. On the photochemistry problem the record changed hands seven times, and the final circuit combines work from three teams. Whoever copies this result should copy the org chart first and the model second.

Strongest case against all of this

Proofs verify a circuit against a specification humans wrote. If the specification is wrong, wrong physics, wrong error budget, a loophole in how Toffoli gates are counted, then the proof is valid and the result is still wrong. Its authors document specification loopholes that valid proofs exploited, and the Comparator's own documentation warns that solutions filling definition holes, which is exactly what a quantum circuit is here, "must always be checked with an additional (potentially human) verifier," because a definition can be filled in a way that passes every check and misses what the challenge meant. So the honest headline is not "AI proved it." It is "AI proved consistency with a human spec, and the humans are still the ones who decide what the spec means." There is also the small matter of release. Google says the Lean library, the problem specifications, and the verified solutions "will be open sourced shortly." As of November 10, none of it had been released, so until independent researchers can run the Lean kernel on the proofs themselves, the 10.9x exists as a claim in a preprint table, and the cheapest known circuit for simulating the inside of a fusion capsule is a line in a table and a proof nobody outside the project has read.

Baselines are partly author-adjusted, which the paper discloses. Authors halved the P450 baseline through their own compilation choices before the agents improved on it. Its arcsin baseline is eight years old, and the paper's own footnote admits that a 2026 circuit computing the inverse square root to 2-24 relative error in 7,735 Toffoli gates would cut the square-root gate count by up to ten and the baseline cost by up to three. Against that modernized baseline, the honest arcsin improvement is about 97x, not 290x. Still the largest gain in the paper. Still worth the headline. But a third of the number that will travel furthest.

What this analysis does not cover

This is a preprint, not peer-reviewed work. Version 1 was submitted November 6, 2026, and version 2 followed on November 9. Every figure is a logical-resource estimate for future error-corrected machines, not a measured run. No quantum hardware executed any of these circuits, and no classical computer simulated them at full scale. Compute budgets per team and the specific Gemini 4 model variants are not reported; the arXiv abstract names Gemini 4 agents, but no variant or size. My one-microsecond-per-logical-gate runtime estimate is an order-of-magnitude assumption, not a paper figure. That "2.6 more campaigns" framing assumes multiplicative compounding of equal-size gains, which overstates progress because real algorithmic gains diminish.

What you can do

If you run a quantum-algorithms group, the bottleneck has moved. Finding circuits is now something agents do well. Writing specifications is the scarce input, and whoever writes the spec decides what gets optimized, so invest in formal-specification skill, Lean and quantum Hoare logic, before you invest in more compute. If you evaluate quantum-computing timelines, stop tracking qubit counts alone and start tracking Q x T for a fixed benchmark problem. Stopping power is now the one to watch: the paper's own horizon is 1012, and the live number is 4.98 x 1014. If you build LLM agents, the 39 percent collaboration share is the transferable lesson. A shared wiki with a merge threshold plus scheduled conferences beat seven isolated teams, so copy the org chart, not just the model. And if you are simply watching the field, watch for the open-source release of the Lean library. That is the moment independent verification becomes possible, and the moment these numbers become facts rather than claims.

The Bottom Line

Agents just made the best quantum programs for fusion, chemistry, and drug metabolism several times cheaper, and the only thing standing between those numbers and reality is a proof checker, a human-written specification, and a release that has not happened yet. That is genuinely new, and genuinely incomplete. Useful fusion simulation is now 498x away in spacetime volume, about two and a half agent campaigns if the gains kept compounding, which they will not, and one run would still take 32 hours on a machine that does not exist. What changed is not the hardware but the path from here to there, which is now a list of theorems with holes in it, and there are agents very good at filling holes. Whether the holes they fill are the ones that matter is still a human decision, and it will stay one until somebody else reads the proofs.

Related articles

Sources