Claude designs quantum circuits that beat the best published ones

Quantum computing has a hardware problem that everyone talks about and a software problem that gets far less attention. The machines that exist today have hundreds to thousands of fragile qubits. The algorithms that would make them useful need far more, and they need to run long sequences of expensive operations without errors piling up. Every qubit and every gate a circuit designer can remove brings useful quantum computing a little closer. On 16 October 2026 Anthropic published research showing that Claude has become very good at exactly that kind of removal.

The team gave Claude plain language specifications for eight quantum circuits, drawn from chemistry, optimization, physics simulation, number theory and numerical computing, plus an automated evaluator that checks each proposed design and scores it. Working largely on its own, Claude found designs that improve on the best published circuits, in some cases by an order of magnitude or more. The accompanying paper on arXiv reports that in seven of the eight tasks the discovered circuits use both fewer Toffoli gates and fewer qubits than the state of the art. In the eighth, Claude found a new reversible architecture for modular inversion, the most expensive step in elliptic curve arithmetic.

The work was led by Andi Gu, a Harvard physicist working in Anthropic's STEM Fellows Program, with mentorship from Anthropic quantum physicist Alek Kemeny and in collaboration with Susanne Yelin of Harvard and Mikhail Lukin of Harvard and QuEra Computing. Lukin is one of the best known names in neutral atom quantum computing, which makes this more than an AI lab marketing exercise. Here is what Claude actually did, how the setup worked, and where the limits are.

Why circuit design matters so much

A quantum computer runs a program as a long sequence of simple operations called gates. Some gates are cheap, others are expensive. The Toffoli gate is one of the costliest to run on an error corrected machine, so researchers count Toffolis to estimate how long a computation will take. The other scarce resource is qubits. The paper ranks every design by a single number: Toffoli count multiplied by peak qubit count, which the authors call the TQ cost.

Anthropic's post gives a striking example of how much this matters. In 2017, researchers estimated that simulating FeMoco, the iron sulfur cluster at the heart of the enzyme bacteria use to turn nitrogen from the air into ammonia, would need about 50 trillion Toffoli gates. Through a long series of algorithmic advances that estimate has come down to about 340 million, a roughly 150,000 fold reduction. That corresponds to a few hours of computation on a future machine with about three million physical qubits. Almost all of that progress came from redesigning circuits, not from better hardware, and it took many research groups about eight years.

Quantum circuits are hard to design for two reasons that ordinary programmers never face. First, a quantum circuit cannot make if then decisions the normal way. It runs on a superposition of many inputs at once, so it must contain the operations for every branch, every time. Second, a quantum circuit cannot throw information away. Every step has to be reversible, so scratch work must be "uncomputed" by running the steps that created it backwards, which costs extra gates. Designers constantly trade qubits against time: keep intermediate results and pay in qubits, or erase them and pay in recomputation.

How the experiment worked

The key trick is that the class of circuits the team studied computes ordinary classical functions on quantum data. That means a classical computer can check whether a candidate circuit is correct by tracking a bit string and its sign, instead of simulating an exponentially large quantum state. Correctness and cost can both be measured automatically, which is exactly the kind of feedback loop language models thrive on.

According to the paper, the searches ran on the open source framework OpenEvolve with Claude Mythos 5 proposing architectures and rewrites. Each search started from a hand written task specification and a blank program, with no implementation guidance. Claude first proposed several distinct algorithm families, which were then developed in parallel, with strong candidates shared between families from time to time. Every candidate was a Python program that builds the circuit. The evaluator rejected anything incorrect and scored valid designs by their TQ cost. Anthropic says Claude worked in a closed loop, with no human input between rounds.

The researchers also describe a weakness they had to work around. In early experiments Claude was "conservative by nature", repeatedly second guessing apparent improvements and preferring well known approaches to novel ones. Forcing it to develop several qualitatively different ideas in parallel, and occasionally prompting it to think more broadly, pushed it toward more ambitious designs.

Result one: a 12x cheaper decoder for a promising quantum algorithm

Decoded quantum interferometry, or DQI, is one of the strongest candidates for a quantum algorithm with a large speedup on optimization problems. It turns an optimization task into a decoding problem for a classical error correcting code, and the decoder is by far its most expensive step. Anthropic notes that, by estimates from researchers at Google Quantum AI, one particular instance would take about three months on the Frontier supercomputer versus roughly an hour on a future quantum computer running DQI, and most of that hour would be spent decoding.

The previous best reversible circuit for this decoder, from Khattar and colleagues at Google, used the extended Euclidean algorithm. Because that algorithm takes different paths for different inputs, a quantum version has to stretch the computation over many more rounds than any single input needs. Claude switched to a different method, Berlekamp Massey decoding, which performs the same kind of step in every round. It then found a way to rebuild most of the temporary values from the circuit's current state instead of storing them.

The last step was empirical. A worst case design would reserve 665 qubits for rare exceptional values. Claude wrote a fast simulator, ran 403 million sample decodings and found that almost every run needs at most one saved value. So the circuit reserves just 19 qubits and accepts that roughly one run in 10,000 fails, well inside the error rate the task allows. The result, per the paper: about 440,000 Toffolis and 1,837 qubits, against 5.1 million Toffolis and 1,938 qubits for the baseline. That is 12x fewer gates and about 5% fewer qubits.

Result two: a new way to do elliptic curve arithmetic

The headline experiment was elliptic curve point addition, the core step of quantum algorithms for the elliptic curve discrete logarithm problem. That is the problem a large enough quantum computer would solve to break the elliptic curve cryptography that protects much of the internet and most cryptocurrencies. Point addition is a standard benchmark in the field, and its most expensive part is modular inversion.

Ordinary computers do modular inversion efficiently with a method called divsteps, which repeatedly adds, subtracts or halves a pair of numbers. On a quantum computer that method had never been practical, because each step's choice must be remembered so the computation can later be reversed, and storing that history costs an enormous number of qubits. Claude's idea, after 53 hours of work with minimal human input, was that the history might not need storing at all. The numbers themselves could reveal which branch was taken.

Simple decoding rules failed at full 256 bit size, so Claude changed approach. It proved new algebraic identities about how divsteps behaves, derived an exact rule for recovering each decision from the registers, checked it in large simulations and formalized the claim in the Lean proof assistant. Only the deepest, rarest decisions still go into a short stack.

This result needs careful reading. Compared with the smallest previous design, by Luo and colleagues at 838 qubits and about 70 million Toffolis, Claude's main circuit uses 12% more qubits but 17x fewer gates: 935 qubits and 4.0 million Toffolis. It is not the fastest design on record, though. A gate optimized design by Schrottenloher needs only 1.9 million Toffolis, but 1,446 qubits. What Claude added is a new family of options in the low qubit region where none existed, which the authors describe as expanding the Pareto frontier. Separately, Claude also tuned Luo's construction itself, cutting its Toffoli count by 3.4x at the cost of five extra qubits. CTOL made the same point: the 17x figure is real, but it is a gain over the smallest prior design only. Gu has published the full circuit with commented code on his project page.

Does this put cryptography at risk?

Not directly, and not soon. These are logical qubits, the error corrected kind that today's machines cannot yet provide at this scale, and a single point addition is one building block of a much larger attack circuit. What the result does show is that the resource estimates for attacking elliptic curve cryptography are not fixed. They keep falling as people, and now models, find better circuits. That is one more reason the migration to post quantum cryptography should not wait. It also fits a pattern from Anthropic's research team this month: Claude recently traced the origin of the NIST elliptic curve seeds to a 1990s random number generator.

The other six tasks

The remaining results in the paper's Table 1 are less dramatic individually but show how general the method is. The gain in TQ cost was 39x for a fixed point Gaussian function, 32x for the rotation angle step of the HHL linear systems algorithm, 9.9x for a Coulomb potential used in chemistry simulation, 7.7x for a nonabelian lattice gauge simulation and 4.1x for an alias sampling step used in simulating the Fe2S2 molecule. For a decoder over Hermitian codes no reversible compilation existed in the literature at all, so the paper compares against a naive implementation instead.

The authors identify three recurring ideas behind the gains. Claude replaced conditional arithmetic with cheap conditional routing of data through one shared operation. It recovered branch decisions from the evolving state instead of keeping a history. And it used the small failure budget most quantum algorithms allow to drop machinery that only rare inputs need.

What to keep in mind

There are real caveats. These are Anthropic's own results, published as a preprint, and independent replication is still to come. Several gains depend on accepting a small failure probability, for example up to one in 1,000 for the decoders, which a hardware team has to agree to. The TQ cost is a deliberately simple proxy; in practice the relative value of qubits, depth and routing depends on the hardware and the error correction scheme. And the method only works where correctness can be checked cheaply by a classical computer, which excludes many kinds of quantum circuits.

Still, the contrast Anthropic draws is hard to ignore. The FeMoco improvements took the field about eight years of human work, step by step. Claude's elliptic curve design came out of a single 53 hour run. The authors suggest the next step could be optimizing the whole stack together, from the algorithm down to error correcting codes and hardware layout, to design error corrected machines tailored to specific problems. If that works, useful quantum computers may arrive sooner than the hardware roadmaps alone suggest.

Sources: Anthropic research post (16 Oct 2026), Gu, Kemeny, Yelin and Lukin on arXiv, project page with the point addition circuit, CTOL analysis.