Anthropic: Claude Designs More Efficient Quantum Circuits, Cutting Some Gate Counts by 17x

Anthropic announced that Claude Mythos 5 designed quantum circuits that outperform the best previously published designs across eight computational primitives, in some cases by an order of magnitude or more. The results matter because circuit design, not hardware alone, has driven most of the historical reduction in the quantum resources that useful algorithms require — so faster circuit design could bring practical quantum computers closer.

The work was led by Andi Gu as part of Anthropic's STEM Fellows Program, with mentorship from Alek Kemeny, a quantum physicist at Anthropic, in collaboration with Susanne Yelin (Harvard University) and Mikhail Lukin (Harvard University and QuEra Computing). The full paper is on arXiv at arxiv.org/abs/2610.22367.

Why quantum circuit design is a hard optimization problem

Quantum computers store information in qubits, which can be built from single atoms, superconducting circuits, or particles of light. Qubits exploit superposition — the ability of a quantum system to exist in a combination of states at once — to process certain problems in chemistry, materials science, and number theory that are intractable for classical computers.

The machines built to date have only hundreds to thousands of qubits, far too few to run many algorithms that promise practical advantages. Qubits are also highly sensitive to environmental noise such as heat, vibration, and cosmic rays; small errors accumulate until the computer returns a wrong answer. Because qubits and computing time are both scarce, researchers have worked to redesign quantum algorithms to use fewer qubits and finish in less time.

Quantum algorithms are implemented as quantum circuits: sequences of gates applied to qubits. The Toffoli gate is one of the most expensive gates to run, so counting Toffoli gates is a standard way to estimate how long a computation will take.

The canonical example is FeMoco, the iron–sulfur cluster at the heart of nitrogenase, the enzyme bacteria use to turn atmospheric nitrogen into ammonia. In 2017, researchers estimated that a quantum computer would need about 50 trillion Toffoli gates to compute FeMoco's ground-state energy. Through a series of algorithmic advances, that estimate has fallen to about 340 million gates — a roughly 150,000-fold reduction, corresponding to a few hours of computation on a future machine with about three million physical qubits. Those reductions came largely from redesigning circuits rather than from better hardware.

How Anthropic tested Claude on circuit design

Anthropic gave Claude plain-language specifications for eight circuits drawn from chemistry, optimization, physics simulation, and number theory, plus an automated evaluator that checks and scores each design. Claude was not given the existing published circuits to tune.

Three properties made quantum circuits a good fit for the model:

• Circuits can be written as code. Quantum circuits are sequences of gates, so Claude's coding capabilities can be used to write, run, and revise circuit designs as ordinary programs.
• Correctness can be checked efficiently. The class of algorithms Anthropic targeted gives one definite output per input, which an ordinary computer can verify — so an external evaluator program could validate Claude's proposals.
• There is a clear objective score. The evaluator scores designs on the number of qubits multiplied by the number of gates, a proxy for how long the circuit would take to run.

Claude Mythos 5 worked in a closed loop: it proposed a circuit design, received feedback and a score from the evaluator program, and used that feedback to improve its next attempt, with no human input between rounds. Across the eight computational primitives — the basic routines that larger quantum algorithms are built from — Claude found novel designs using both fewer qubits and fewer gates than the best previously published algorithms.

Anthropic states that in each case the improvement came from uncovering new structural and mathematical insights about the problem, rather than from fine-tuning existing designs. For example, when compiling a circuit for simulating an iron-sulfide molecule, Claude noticed that the molecule's symmetries and repeating structure meant some results could be calculated once and reused rather than recomputed for every part of the system. In other cases it found that existing circuits included costly components needed only to handle extremely rare inputs, and redesigned them without those components.

The reversibility constraint that shapes quantum circuits

Quantum circuit design imposes two constraints that ordinary programming does not, and both make quantum circuits far more expensive in runtime and qubits than their classical counterparts.

First, a quantum circuit cannot make "if-then" decisions the way an ordinary program can. An ordinary program can check a value and run only one of two pieces of code. A quantum computer runs on a superposition of many inputs at once, some of which would take the first branch and some the second, so the circuit must include the operations for both every time it runs.

Second, a quantum circuit cannot discard information. An ordinary program can overwrite or delete scratch work; in a quantum computer, intermediate information cannot simply be erased because every step must be reversible. Leaving that information in place is also not an option, because leftover scratch work would corrupt the final result. The only way to discard information is to "uncompute" it by running the computation that created it in reverse, at the cost of additional gates.

This forces a trade-off between space (qubits) and time. At one extreme, a circuit can uncompute intermediate results as soon as they have been used, freeing qubits but forcing recomputation if those results are needed again later. At the other extreme, the circuit can retain intermediate results until they are no longer needed, avoiding repeated work but requiring many more qubits.

Result 1: a reversible implementation of divsteps for modular inversion

The first task Anthropic gave Claude was point addition — a rule for combining two points on an elliptic curve to produce a third. Point addition is the core step in quantum algorithms for the discrete logarithm problem on elliptic curves: given a starting point and the result of adding it to itself n times, find n. For large curves, ordinary computers cannot solve this problem in any reasonable amount of time, but a sufficiently large quantum computer could. These additions account for most of the qubit and runtime costs of such algorithms, which is why point addition is a standard benchmark.

Claude received a one-paragraph brief explaining the mathematical rule for point addition, how the evaluator would check each proposed circuit for correctness and score it on qubits and gates, and an instruction to explore several approaches in parallel. After working for 53 hours with minimal human input — limited to the initial brief and occasional prompts to think more broadly — Claude arrived at a completely new approach.

Why divsteps had no practical quantum circuit

Most of the cost of point addition comes from a single step called modular inversion. Elliptic-curve arithmetic uses numbers that wrap back around at a fixed limit; modular inversion is the wraparound version of division: given an integer a, find x such that ax ≡ 1 (mod p). Ordinary computers perform this efficiently using a method called divsteps, which starts with a pair of numbers and repeatedly simplifies them over many rounds, conditionally swapping, adding, subtracting, or halving them while preserving just enough information to produce the modular inverse at the end.

Divsteps had not produced a practical quantum circuit because of the reversibility constraint. The record of which operation was chosen at each iteration — called branch information — is the kind of scratch work a traditional program can discard. A quantum circuit has to retain that record so the computation can be run backward. A straightforward quantum version of divsteps is therefore forced to accumulate a long history of branch information, requiring an enormous number of additional qubits.

Claude's decoding approach

Claude recognized that divsteps could be promising for quantum circuits only if there were a way around storing the full history, and proposed that the record might not need to be stored at all. It reasoned that the branch information could be directly inferred, or "decoded," by inspecting the pair of numbers after each iteration — in essence, the numbers themselves would store the record, and the circuit could run backward without extra qubits.

Early candidate decoding rules worked on small test cases but failed at the full problem size, on 256-bit numbers. Claude then took a more theoretical approach: rather than guessing and testing rules, it set out to understand mathematically why divsteps behaves as it does. It proved a series of results about the iteration process, including several new algebraic identities, and from those identities derived a precise formula for the decoding rule that recovers the branch information from the numerical pairs. It checked the formula first through large-scale numerical simulations and then by formalizing the claim in Lean. The result was the first reversible implementation of divsteps with no stored branch history.

A family of designs along the Pareto frontier

Decoding saves qubits but costs time, so Claude looked for situations where storing branch information would be cheaper than decoding it. By varying the threshold at which the circuit stores rather than decodes, Claude produced a new family of designs spanning the two extremes. Compared with the smallest previous design, one circuit in the family uses 12% more qubits but 17x fewer gates. More generally, the new designs expand the Pareto frontier, offering combinations of qubit count and runtime that were not previously available.

Anthropic compares its designs against the best previously published results from Schrottenloher (2026) and Luo et al. (2026).

Result 2: a 12x cheaper decoder for decoded quantum interferometry

Optimization problems — scheduling, logistics, materials design — present competing constraints and ask for the solution satisfying as many as possible. Many quantum algorithms have been proposed for such problems, but most promise only modest or uncertain gains over ordinary computers. Decoded quantum interferometry (DQI) is one of the strongest candidates for a superpolynomial quantum speedup, an advantage that widens rapidly as problems get larger.

When a quantum computer finishes a computation, reading out its qubits produces just one answer, selected at random from the possibilities they held in superposition. DQI prepares a quantum state in which good solutions are more likely to be read out than bad ones. This involves an error-correcting decoder that recovers a short list of "errors" from a compact summary. That decoder is the most expensive step in the algorithm, so a faster decoder makes DQI faster.

The OPI problem and the cost of Reed–Solomon decoding

The researchers who introduced DQI demonstrated it on optimal polynomial intersection (OPI), a grid-based version of curve fitting. Imagine a grid in which each position x contains several acceptable values of y; the goal is to find a simple curve (a low-degree polynomial) that passes through an acceptable square for as many x positions as possible. DQI tackles this using a Reed–Solomon decoder.

Reed–Solomon decoding starts from a compact summary of errors called a syndrome. The decoder infers from this summary where in the data the errors occurred and what they were. The previous state-of-the-art quantum circuit processed syndromes using the extended Euclidean algorithm, a sequence of divisions and swaps whose number and order of steps depend on the particular input. Here the quantum constraints reemerge: an ordinary program can follow a different path for every input, but a quantum circuit working on many inputs at once must handle all of them with a single fixed sequence of gates. The previous design therefore had to stretch the computation over many more rounds of iteration than any single input would need, and run every operation in every round even when unnecessary.

Anthropic cites estimates by researchers at Google Quantum AI implying that solving one particular OPI problem would take about three months on Frontier, one of the world's most powerful supercomputers, compared with roughly an hour on a future quantum computer running DQI — most of that hour spent on Reed–Solomon decoding.

Berlekamp–Massey instead of extended Euclid

Asked to design a more efficient decoding circuit, Claude quickly concluded that the extended Euclidean algorithm was a poor fit for a quantum circuit. It instead organized its circuit around Berlekamp–Massey decoding, which reads through syndromes one at a time and gradually works out the simplest rule that predicts each number in the list from the ones before it; once that rule is found, it reveals the errors. Unlike the extended Euclidean algorithm, Berlekamp–Massey performs the same kind of step in every round and always runs the same number of rounds, which suits a quantum circuit's single fixed sequence of gates.

Reconstructing temporary values instead of storing them

Switching to Berlekamp–Massey removed the need for different paths for different inputs, but making it reversible introduced the uncomputing problem again. In every round the circuit calculates temporary values it needs only briefly, and this information cannot simply be deleted: to uncompute it later, the circuit must be able to recover it.

Storing this information would have been prohibitively expensive, so Claude took the same approach as with divsteps: it found a way to reconstruct most of the information from the circuit's current state. A few exceptional values could not be recovered this way and had to be saved. Setting aside enough memory for the worst case, in which an exceptional value arises in 35 different rounds, would take 665 qubits. Instead, Claude wrote a high-speed simulator and ran 403 million sample decodings to measure how often the exceptions actually occurred. Almost every run needed to save one value at most, so Claude's circuit sets aside room for just one saved value, or 19 qubits. About one run in 10,000 needs more than that and fails, which Anthropic states is well within the error rate the task allows.

Together these optimizations reduced the number of gates in the decoder by a factor of 12 relative to Google's previous construction. Anthropic attributes the improvement to redesigning the computation at three levels: a different method (Berlekamp–Massey instead of the extended Euclidean algorithm), a different circuit architecture (reconstructing temporary values instead of storing them), and a different resource budget (measuring precisely how much memory and computation the circuit really needed). No single change would have been enough on its own.

What Anthropic learned about Claude's behavior

Anthropic frames the result as an example of a broader pattern in scientific progress: making theoretical ideas practical by making a process fast and cheap enough to carry out. The 150,000-fold drop in the FeMoco estimate took many research groups eight years, with each step typically representing months of work. By contrast, Claude's elliptic-curve design came from a single 53-hour run.

Anthropic also reports limitations. In early experiments, Claude was conservative by nature: it repeatedly second-guessed apparent improvements and sometimes continued to double- and even triple-check results that were already well supported. This caution was sometimes valuable — it prompted Claude to write Lean proofs to verify its divsteps design — but it also manifested as a tendency to prefer existing, well-known approaches over more novel ones.

Anthropic took two steps to mitigate this:

1. The setup required Claude to propose several qualitatively different approaches and develop them in parallel.
2. Anthropic occasionally prompted Claude to broaden its search.

These interventions succeeded in getting Claude to pursue more ambitious ideas. The elliptic-curve result did not come from shaving gates off a pre-existing design but from exploring a method of reversible modular inversion that had not previously been possible, then deriving the mathematical results needed to make it practical. Once it had the idea, Claude developed the approach, implemented it, and verified its correctness autonomously.

What the results imply for fault-tolerant quantum computing

Anthropic notes that circuit design is only one part of building a useful quantum computer. Because qubits are so fragile, the machine must catch and fix its own errors as it runs, which depends on many other components: error-correcting codes, fast decoders, and control of the hardware itself. These components all affect one another, but to manage complexity each is usually designed separately.

Many of those components share the characteristics that made circuit design a good fit for Claude: a design can be written as code, checked for correctness, and scored by its cost. Anthropic raises the possibility that AI could optimize all of them jointly, from the algorithm down to the hardware, to build an entire error-corrected quantum computer tailored to a specific problem. Such designs could also tell hardware builders which capabilities matter most for a given application — which Anthropic suggests could put problems such as designing catalysts and understanding new materials within reach of the first fault-tolerant machines.