Anthropic Says Claude Redesigned Quantum Circuits That Beat Published Records

Anthropic published research on October 16, 2026 claiming that Claude, given plain-language specifications and an automated scoring program, produced quantum circuit designs that use fewer qubits and fewer gates than the best previously published versions across eight computational primitives. The company says the improvements reached an order of magnitude or more in some cases, and that one headline result — a new reversible algorithm for modular inversion — came out of a single 53-hour run with minimal human input. The work has been posted to arXiv; Anthropic does not indicate that it has been peer reviewed.

The framing matters more than the specific numbers. Anthropic is not arguing that a model invented a new branch of physics. It is arguing that a large class of hard, expensive engineering work in quantum computing happens to have exactly the properties that make an LLM-plus-evaluator loop effective: the artifact is code, correctness is machine-checkable, and cost is a single number.

The setup: a scorer, not a conversation

According to Anthropic, the team gave Claude a short brief describing what each circuit must compute, plus an evaluator program that checks a proposed circuit for correctness and scores it on qubit count multiplied by gate count — a proxy for runtime. Claude writes a candidate implementation in Python, the evaluator validates and scores it, and the score feeds back into the next attempt. Anthropic says the model ran these rounds without human input in between.

The primitives spanned chemistry, optimization, quantum simulation, number theory and numerical computing. Anthropic says the gains came from new structural or mathematical insight rather than from micro-optimizing existing designs. Two examples it cites: noticing that an iron-sulfide molecule's symmetries allowed some results to be computed once and reused, and stripping out costly circuit components that existed only to handle extremely rare inputs.

The work was led by Andi Gu through Anthropic's STEM Fellows Program, mentored by Anthropic quantum physicist Alek Kemeny, in collaboration with Susanne Yelin of Harvard and Mikhail Lukin of Harvard and QuEra Computing. The model used is identified as Claude Mythos 5. Compute cost, number of candidate circuits generated, and failure rates across the eight tasks were not disclosed.

Why quantum circuits are unusually hard to optimize

Two constraints make this domain different from ordinary programming, and Anthropic's post explains them clearly enough to be worth restating. First, a quantum circuit cannot branch: because the machine operates on a superposition of inputs, the circuit must include the operations for every path on every run. Second, it cannot discard scratch work, because every step must be reversible — intermediate values have to be "uncomputed" by running their creation backward, which costs gates, or kept around, which costs qubits.

That forces a space-versus-time trade-off with no classical analogue, and it is where most of the reported wins came from.

Modular inversion: reconstructing what you can't store

The first task was elliptic-curve point addition, the dominant cost in quantum algorithms for the elliptic-curve discrete logarithm problem and a standard field benchmark. Its most expensive step is modular inversion. Classical computers do this efficiently with a method called divsteps, which iteratively swaps, adds, subtracts or halves a pair of numbers. The problem for quantum circuits: the record of which operation was chosen in each round — the branch information — is exactly the kind of scratch work that must be retained for reversibility, and storing the full history demands an enormous number of extra qubits.

Anthropic says Claude's idea was that the record need not be stored at all, because it might be inferable from the number pair after each iteration. Early heuristic decoding rules worked on small cases but broke at the full 256-bit size. Claude then proved a series of algebraic identities about the iteration, derived a decoding formula from them, validated it with large-scale numerical simulation, and formalized the claim in Lean. The result, per Anthropic, is the first reversible implementation of divsteps with no stored branch history.

Because decoding costs time, Claude then varied the threshold at which the circuit stores rather than decodes, producing a family of designs. Against the smallest previous design, Anthropic reports one member of that family uses 12% more qubits but 17x fewer gates, and says the family extends the Pareto frontier of qubit-count/runtime combinations.

A 12x cheaper decoder for DQI

The second result targets decoded quantum interferometry, which Anthropic describes as one of the stronger candidates for a superpolynomial speedup on optimization problems. DQI's most expensive step is Reed–Solomon decoding. The prior state-of-the-art circuit used the extended Euclidean algorithm, whose step count depends on the input — a bad match for a fixed gate sequence, forcing the design to pad out extra rounds and run every operation regardless of need.

Claude instead built around Berlekamp–Massey decoding, which performs the same step in every round a fixed number of times. It then applied the same storage trick as in divsteps: reconstruct most temporary values from the circuit's current state rather than save them. A handful of exceptional values still had to be stored, and here the resource-budget decision is the interesting part. Reserving memory for the worst case — an exception in 35 different rounds — would take 665 qubits. Anthropic says Claude wrote a fast simulator, ran 403 million sample decodings, found that nearly every run needed at most one saved value, and sized the circuit for exactly one, at 19 qubits. Roughly one run in 10,000 then exceeds that budget and fails, which Anthropic says is within the task's allowed error rate.

Combined, the method change, architecture change and budget change cut decoder gate count by 12x relative to Google's prior construction, per Anthropic. The post cites Google Quantum AI estimates that one particular instance of the underlying problem would take about three months on the Frontier supercomputer versus roughly an hour on a future quantum machine running DQI, with most of that hour spent decoding.

The caveats Anthropic names, and a few it doesn't

Anthropic reports that Claude was conservative by default: it second-guessed real improvements, repeatedly re-verified settled results, and leaned toward well-known approaches. The team mitigated this by requiring several qualitatively different approaches in parallel and by occasionally prompting the model to broaden its search. That is worth noting precisely because the post also calls the run "largely on its own" — the autonomy is real but bounded, and the prompts that pushed toward novelty were human judgment calls that no benchmark captures.

Several things the announcement does not establish. These are resource estimates for hardware that does not exist; Anthropic notes today's machines have only hundreds to thousands of qubits, and the FeMoco figure it cites — about 340 million Toffoli gates, down from roughly 50 trillion estimated in 2017 — assumes a future machine with around three million physical qubits. The baselines Claude beat are specific published designs, cited in the post as Schrottenloher (2026), Luo et al. (2026) and Khattar et al. (2025); whether other groups accept them as the true state of the art is not something a blog post settles. Independent replication has not been reported. And circuit design is one layer of a stack that also includes error-correcting codes, fast decoders and hardware control — Anthropic says these could in principle be co-optimized by AI, but that is a proposal, not a result.

The most defensible claim here is a process claim: an eight-year, multi-group effort produced the 150,000-fold FeMoco reduction, while one search loop produced a new elliptic-curve approach in 53 hours. If that ratio holds on other machine-checkable design problems, the interesting question for builders is less about quantum computing than about which parts of their own stack have a cheap, trustworthy evaluator.

What to watch

• Whether quantum researchers outside Anthropic and Harvard reproduce the divsteps and Berlekamp–Massey circuits and agree the compared baselines were current.
• Whether the arXiv paper clears peer review, and whether the Lean formalization covers the full decoding claim or only parts of it.
• How much compute, how many candidate circuits and how many human nudges each result actually required — none of which Anthropic disclosed.
• Whether the one-in-10,000 failure budget in the DQI decoder survives contact with full fault-tolerant error-correction accounting, rather than being analyzed in isolation.
• Whether the same closed-loop pattern transfers to the adjacent layers Anthropic flags — error-correcting codes, syndrome decoders, control stacks — where evaluators are harder to write and correctness is less binary.