Claude designed leaner quantum circuits. The 17x is one comparison

In 7 of 8 tasks an AI-led search found circuits with fewer gates and fewer qubits than the starting designs. The viral 17 times is one trade-off on one task, against one earlier design, for 12% more qubits.

Research desk Anthropic and Harvard, arXiv preprint Read on 17 October 2026

Bars are the paper's own ratios (Table I). The scatter places Table S3's four designs; positions and the 17.5 division are ours.

The headline, and what it measures

On 16 October 2026 Anthropic announced that its model Claude Mythos 5 had designed quantum circuits that need fewer resources than the best published ones. The paper, Discovering state-of-the-art quantum circuits with large language models, went up as arXiv:2610.22367 on 15 October. Its authors are Andi Gu (Harvard, and Anthropic’s STEM Fellows Program), Alek Kemeny (Anthropic), and Susanne Yelin and Mikhail Lukin (Harvard; Lukin is also with QuEra Computing). We read the preprint in full, including its supplementary tables.

Social posts turned it into “AI designs quantum circuits 17 times more efficient than humans, in 53 hours, with no human help, confirmed by Harvard and QuEra”. Each part of that sentence is a little off. The 17 times is one comparison on one task, against one earlier design, and it costs 12% more qubits. The rest of this page shows where every number comes from.

The problem it attacks: every operation costs

A useful quantum algorithm spends most of its effort on a few ordinary calculations done on quantum data: arithmetic, decoding, evaluating a function. Two things make those calculations expensive on a quantum computer.

Gates cost. In an error-corrected machine the Toffoli gate needs a specially prepared resource state (see our note on magic states), so the Toffoli count tracks much of the running time.
Qubits cost, and nothing can be thrown away. A quantum circuit has to be reversible. Scratch values cannot simply be deleted; they must be computed back to zero, and until then they occupy qubits. A circuit also cannot branch on its input the way ordinary code does, so every branch it might take has to be built in, even if it is rarely used.

The paper scores a design by multiplying the two: T × Q, the Toffoli count times the peak number of qubits in use. Lower is better.

How the search worked

Each of the eight tasks started from a hand-written specification of what the circuit must do and a blank program. Claude was asked to propose several different approaches, then wrote Python code that builds each circuit. An independent evaluator checked every candidate for correctness and scored it by T × Q; Claude saw only the feedback. The search ran inside an evolutionary framework, OpenEvolve,, kept a range of designs with different gate and qubit trade-offs, and let good ideas cross between approaches. The circuits chosen can be simulated on an ordinary computer by tracking a bit string and a sign, which is what made reliable automatic checking possible.

Anthropic’s post says the elliptic-curve design came from a single 53-hour run with minimal human input, limited to the initial brief and occasional prompts to think more broadly.

The results, task by task

In seven of the eight tasks the discovered circuit uses both fewer Toffolis and fewer qubits than the baseline. The gains below are the paper’s own, on T × Q (Table I):

Fixed-point Gaussian (numerical): 39 times. From 24,000 Toffolis and 362 qubits to 1,583 and 139.
HHL rotation angle (numerical, used in linear-system algorithms): 32 times.
Reed-Solomon decoder for decoded quantum interferometry (optimisation): 12 times, from 5.1 million Toffolis to about 440,000, against Google’s earlier construction.
Coulomb potential (numerical, the 1/r term in simulating molecules): 9.9 times.
Non-abelian lattice-gauge simulation (physics): 7.7 times.
Fe₂S₂ alias-select step (chemistry): 4.1 times.
Hermitian-code decoder (optimisation): better on both counts, but there was no published reversible circuit to beat, so the baseline is a straightforward one built for the comparison.
Prime-field modular inversion (number theory): a new architecture rather than a single win; see the next section.

Where 17 times comes from

The eighth task is benchmarked inside a bigger calculation: adding two points on an elliptic curve, y² = x³ + 7 over a 256-bit prime field. That curve is secp256k1, the one Bitcoin uses, and point addition is the core step of Shor’s attack on elliptic-curve keys. The paper compares four designs (Table S3):

Schrottenloher (2026): 1.9 million Toffolis, 1,446 qubits.
Claude’s divstep circuit: 4.0 million Toffolis, 935 qubits.
Claude’s second design, a specialised version of Luo et al.: 21 million Toffolis, 843 qubits.
Luo et al. (2026): 70 million Toffolis, 838 qubits.

Dividing 70 million by 4.0 million gives 17.5: that is the 17 times. It is against the design that uses the fewest qubits, and Claude’s circuit needs 935 against 838, about 12% more. Against the design that uses the fewest gates, Claude’s circuit needs about 2.1 times as many Toffolis, while using 35% fewer qubits. On the paper’s own T × Q score, Schrottenloher’s design (2.7 × 10⁹) is lower than Claude’s (3.7 × 10⁹). None of the four wins on both counts, and the paper says so: for this task it reports no single baseline or gain. What it claims is a new design that improves the trade-off between gates and qubits.

In plain words: the three ideas

Move the data, not the work. If a calculation has two branches that each need an expensive multiply, a naive circuit builds both. The discovered circuits swap the right inputs into place, which is cheap, and run one shared multiply.
Read the past from the present. To undo a step, a reversible circuit needs to know which branch it took. Instead of storing every decision, the circuits recover many of them from the numbers left behind. For modular inversion the model identified the invariant that makes this work and developed it into a proof.
Do not pay for the rare case. Quantum algorithms already allow a small chance of failure. The circuits size their memory for typical inputs and let rare, expensive inputs fail.

The maths

The score. For the Gaussian: 24,000 × 362 ≈ 8.7 million before, and 1,583 × 139 ≈ 0.22 million after. The ratio is about 39.

Routing. One controlled multiply-add on n-bit numbers, done naively for two branches, costs 3n² + 17n − 2 Toffolis. Routing the data first halves it. For n = 64 that is 13,374 Toffolis down to 6,687 (our arithmetic on the paper’s formula).

Failure budget. The Reed-Solomon decoder needs a stack of past values. In the worst case that is 35 entries of 19 qubits, 665 qubits. Under the inputs the algorithm actually sees, a second entry is needed with probability 1.0 × 10^-4, so the circuit keeps one entry, 19 qubits, and fails on those rare inputs. The modular-inversion circuit does the same with its history: 60 stored decisions instead of a worst case of 263, overflowing with probability about 2.4 × 10^-6 per inversion.

What this does not show

It is not “17 times more efficient than humans”. It is 17 times fewer gates than one earlier design, for 12% more qubits, on one task. Across the tasks with a published baseline the gains on the combined score run from 4.1 to 39 times.
It was not done without people. Humans wrote the eight task specifications and the evaluator, chose the score, and sometimes prompted the model to search more broadly. The evaluator, not the model, decided what counted as correct.
Harvard and QuEra did not confirm it. Yelin and Lukin are co-authors. That is authorship, not independent review, and the preprint has not been peer-reviewed.
Nothing ran on a quantum computer. These are resource estimates, checked by classical simulation. No machine that can run them exists yet.
It is not proven correct for every input. Correctness was tested on large samples, with exhaustive checks for some parts; the full point-addition circuit failed 4 times in 100,000 tests, inside its stated failure budget. Sampling measures rare failures; it does not rule them out.
Your Bitcoin is not newly at risk. One arithmetic block got cheaper. The paper gives no new estimate of the cost of breaking a key. Our Bitcoin page has the current numbers.
The score is a stand-in. The authors note that real cost also depends on wiring, scheduling, measurements and error correction, so a better T × Q is not automatically better on every machine.

Why a reader of this site should care

This site is about the loop between AI and quantum computing. Most of that loop so far has been AI reading a quantum computer’s errors. This is the other direction becoming real: an AI proposing new algorithm structure, with a checker it cannot argue with. The honest test is what happens next: peer review, an independent rebuild of the circuits, and a whole algorithm costed with these parts. Until then, ask the question this desk always asks: 17 times what, against which design? For the basics behind it, see what a logical qubit is and our quantum computing FAQ.

Sources

We read the sources above ourselves. Where a figure or number is ours, the article says so. If you find a mistake, tell us: a wrong sentence here gets logged like any other.