Claude Mythos 5 Outpaces Eight Years of Human Quantum Circuit Research in 53 Hours

Anthropic's Claude Mythos 5 model has produced quantum circuit designs that outperform every published human benchmark across eight separate problem domains — completing in 53 hours a design-space exploration that researchers at leading quantum computing laboratories have been advancing incrementally for nearly a decade. The results, published October 16, 2026 and submitted the previous day to arXiv as paper 2610.22367, describe a closed-loop framework in which Mythos 5 was given plain-language descriptions of quantum computing problems spanning chemistry simulation, combinatorial optimization, physics simulation, and number theory, then iteratively improved its circuit designs without any human involvement between rounds.

Across all eight tasks, the system produced circuits that outperformed the best previously published human designs. In seven cases, it improved simultaneously on both qubit count and Toffoli gate count — the two primary resources consumed by real fault-tolerant quantum hardware. For the eighth problem, a core operation in elliptic curve cryptography, the model derived mathematical identities that no researcher had previously published, used them to build a class of reversible quantum circuits the field had long considered infeasible, and formally verified the proofs using the Lean theorem prover. That circuit uses 17 times fewer quantum gates than the best prior design, at the cost of 12 percent more qubits.

The scale of the improvement makes the result difficult to frame as ordinary optimization. The FeMoco molecule — a nitrogen-fixing enzyme core used as a standard quantum computing benchmark — required an estimated 50 trillion Toffoli gate operations to simulate when researchers first characterized the problem in 2017. Eight years of expert effort reduced that figure to 340 million. Claude Mythos 5 matched that scale of progress, in domains beyond chemistry, in 53 hours of autonomous computation.

Why Quantum Circuit Efficiency Determines the Hardware Timeline

To understand why this matters, it helps to understand why quantum circuit design is so technically constrained — and why the constraints have resisted algorithmic shortcuts for so long.

Classical computers represent information as binary bits and execute operations through logic gates that can freely discard intermediate results. A classical program can compute a value, store it temporarily, use it in a condition, and then erase it once it is no longer needed. Memory is reusable and cheap; branching on a condition is free.

Quantum computers operate under entirely different physical constraints. Quantum information cannot be copied (the no-cloning theorem) or erased without consequence (the unitarity requirement). Every quantum operation must be reversible — the computation must, in principle, be run backward to its starting point without losing any information. This is not a software limitation; it is a requirement of quantum mechanics itself. The practical consequence is that any intermediate value computed during a quantum circuit must either be preserved in dedicated registers or explicitly "uncomputed" by running the gates that produced it in reverse. Both approaches cost additional qubits or additional gates — often both.

The second major constraint is the absence of classical conditional branching. A quantum computer in superposition is simultaneously in all possible states. If a classical algorithm branches based on a condition — taking path A when a bit is 0 and path B when it is 1 — a quantum implementation must execute both paths for every execution. Algorithms that depend on making many small conditional decisions, accumulating history, and discarding branches are structurally expensive to implement in quantum hardware. They generate what researchers call "garbage" — intermediate state that must be kept around to enable the reverse computation that uncomputes it — and the garbage can cost hundreds of qubits per instance.

The standard unit for measuring quantum circuit cost is the Toffoli gate, also called the T gate or controlled-controlled-NOT gate. In fault-tolerant quantum architectures, executing a Toffoli gate requires a procedure called magic state distillation, which is resource-intensive and dominates the runtime of almost every practical quantum algorithm. The fewer Toffoli gates a circuit uses, the less physical hardware time it consumes and the smaller the qubit budget required. Cutting Toffoli gate count by a factor of 12 or 17 is not an incremental improvement — it is the difference between a computation that might be feasible on near-future hardware and one that would require a machine an order of magnitude more capable.

Quantum hardware engineers have therefore been caught in a two-dimensional optimization problem with no obvious gradient. Reducing gate count often requires additional qubits for scratch space. Reducing qubit count often forces more gate operations. Expert researchers typically publish improvements on one axis while accepting small regressions on the other, and the field advances through decades of accumulated marginal progress.

Anthropic's Closed-Loop Design Framework

The experimental setup described in the Anthropic paper is deliberately simple in structure, even if the results are not. Andi Gu, leading Anthropic's STEM Fellows Program, assembled a collaboration that included Anthropic quantum physicist Alek Kemeny and Harvard University professors Susanne Yelin and Mikhail Lukin — Lukin is also a co-founder of QuEra Computing, one of the leading neutral-atom quantum hardware companies.

The framework gave Claude Mythos 5 a plain-language description of each quantum circuit design task. No quantum circuit templates were provided. No hints about the expected architecture were included. The descriptions covered chemistry (molecular energy simulation), optimization (combinatorial search algorithms), physics simulation (quantum many-body problems), and number theory (cryptographic primitives). In each case, the task was to implement a specific classical algorithm as a reversible quantum circuit that could be executed on fault-tolerant hardware.

Claude generated Python code that implemented candidate circuits. An automated evaluation system checked whether each circuit was correct and computed a scalar score proportional to the product of the circuit's qubit count and its Toffoli gate count. The model received the score and any error output and then generated a new candidate. No human reviewed or guided the intermediate iterations.

The scoring function — qubits multiplied by gates — captures the practical cost of running an algorithm on fault-tolerant quantum hardware more accurately than either metric alone. A circuit that minimizes gates at the cost of hundreds of additional qubits may be worse in practice than one that balances both. By optimizing the product, the system was pushed toward circuits that are jointly efficient — the frontier that human designers find hardest to advance.

How Claude Proved New Math to Solve the divsteps Problem

The most technically significant result involves a classical algorithm called divsteps, which is a core primitive in elliptic curve cryptography. Elliptic curve point addition — the fundamental operation used in HTTPS key exchange, cryptocurrency signatures, and code signing — requires a subroutine that computes multiplicative inverses modulo a large prime. The divsteps algorithm, designed by Daniel J. Bernstein, accomplishes this efficiently for classical computers by iteratively updating two values through small conditional steps, accumulating and then discarding "branch history" information as it goes.

Implementing divsteps as a quantum circuit had long been considered structurally intractable. The algorithm generates branch history — information about which conditional path was taken at each step — and then immediately throws it away. A classical computer has no obligation to retain that information. A quantum circuit does. To implement divsteps reversibly, every branch decision would need to be preserved so that the computation could be uncomputed later. Storing the complete branch history for a 256-bit divsteps computation, according to researchers' prior estimates, would require hundreds of qubits — an impractical overhead that caused the field to largely set the problem aside.

Claude Mythos 5 initially approached the problem the way a human engineer might: by trying to infer rules for reconstructing branch history from the current computation state without storing it. The system tested several candidate reconstruction rules empirically, checking whether they correctly recovered branch information for small test cases. These approaches worked for small inputs but failed for 256-bit numbers, which are the cryptographically relevant scale.

Rather than continuing to enumerate empirical rules, the model shifted strategy. It analyzed the mathematical structure of the divsteps iteration directly — specifically, how the values (f, g) that divsteps maintains evolve across iterations — and began deriving algebraic identities that would formally constrain the relationship between the current state and the historical branch information.

The resulting identities had not been published in the mathematical literature. Claude produced a formal proof of their correctness using the Lean theorem prover, a proof assistant that verifies mathematical arguments with mechanical precision. A Lean proof is not a software test or a statistical check; it is a formal certificate that the claim holds for all inputs within the specified domain, verifiable by any computer running the Lean kernel. The divsteps algebraic identities were thereby established as a new mathematical result, not merely an empirical observation.

Using these identities, the model constructed a quantum circuit that implements divsteps reversibly without any stored branch history. The circuit accepts a 12 percent increase in qubit count relative to the most parsimonious prior design but reduces the Toffoli gate count by a factor of 17 compared with the best previously published reversible divsteps implementation — Schrottenloher (2026). The new circuit expands the Pareto frontier of achievable designs — it does not simply improve one metric at the cost of the other, but opens a region of qubit-gate tradeoff space that was previously inaccessible by any known construction.

The practical significance for post-quantum cryptography is notable. More efficient quantum circuits for elliptic curve inversion mean that future fault-tolerant quantum hardware would need fewer physical resources to attack elliptic curve cryptographic keys. This does not make elliptic curve cryptography insecure today — the hardware required to run even the improved circuits remains many years away — but it marginally accelerates the timeline and reinforces the case for adopting NIST's post-quantum cryptographic standards promptly.

Replacing Google's Decoder With 12x Better Quantum Design

The second major result addresses a different class of quantum circuit: the error-correction decoder required by the Decoded Quantum Interferometry (DQI) algorithm, which Google researchers have identified as one of the most promising near-term paths to practical quantum advantage in combinatorial optimization.

DQI achieves superpolynomial speedup over classical algorithms on certain structured optimization problems — problems that include variants of resource scheduling, materials design, and molecular simulation. The algorithm's most expensive computational step is a Reed-Solomon decoding operation, which corrects errors in a set of encoded data points. Google's research team (Khattar et al., 2025) designed this decoder using the extended Euclidean algorithm, a classical approach for polynomial arithmetic.

The extended Euclidean algorithm has a structural problem in quantum contexts: it runs for a variable number of rounds depending on its input. Because the number of rounds varies, the computation generates different amounts of intermediate state for different inputs — and a quantum circuit must be prepared for all possibilities simultaneously, since it cannot know in advance which branch it is on. Google's implementation handled this by allocating enough quantum registers to accommodate the worst-case number of rounds and padding shorter computations to match, resulting in a circuit significantly longer than the typical case.

Claude Mythos 5 recognized that the extended Euclidean algorithm was mismatched with quantum circuit requirements and replaced it with the Berlekamp-Massey algorithm for solving the same polynomial problem. Berlekamp-Massey executes a fixed number of elementary operations per round — it does not branch based on intermediate results in the same way. This property makes it structurally compatible with quantum circuits, which need uniform iteration depth to avoid the variable-state accumulation problem.

Switching to Berlekamp-Massey introduced a new problem. Each round of the algorithm generates a small amount of intermediate state — auxiliary registers that must be preserved for later uncomputation. Naively preserving all of this state across all rounds would require 665 qubits of dedicated storage, roughly as impractical as the divsteps branch history problem.

Claude applied a reverse-inference technique: rather than storing the intermediate registers directly, it analyzed whether the state at the end of a round could be reconstructed from the current (output) values without having been stored. For most values, this approach succeeded, eliminating the need to preserve the majority of the intermediate registers.

A small fraction of input values — "exceptional" cases — could not be handled by the reverse-inference approach and still required dedicated storage. Determining how many storage qubits to reserve for these exceptions required characterizing the probability distribution of exceptional inputs. Claude wrote a fast simulator and executed 403 million sample decodings drawn from the input distribution relevant to the DQI algorithm, precisely measuring the rate at which the exceptional case arose. The empirical result was that 19 qubits of storage — compared with the 665-qubit worst-case estimate — was sufficient to handle all but approximately one in ten thousand runs.

The one-in-ten-thousand failure rate is within the accepted error budget for quantum computations, which are inherently probabilistic and already tolerate a small rate of uncorrected errors. The net result is a Reed-Solomon decoder for quantum DQI that uses 12 times fewer Toffoli gates than the Khattar et al. construction from 2025.

Eight Problems, Eight Records: The Full Scope of the Benchmark Sweep

The two results described above are the paper's most striking, but they were embedded within a broader experiment covering eight quantum circuit design tasks. The full task set spanned several of the most practically important near-term quantum algorithm domains.

In seven of the eight cases, the circuits produced by Claude Mythos 5 beat the best previously published human designs on both the qubit count and the Toffoli gate count simultaneously. Improving both metrics at once is harder than improving either one individually, because the qubit-gate tradeoff typically means that gains on one axis come at a cost on the other. Achieving joint improvement suggests the model found qualitatively different circuit architectures, not incremental refinements of human-expert designs. Results across all eight tasks are presented in Figure 2 of the paper.

For the eighth task — the divsteps elliptic curve problem — the circuit did not improve on the prior human best in both dimensions simultaneously, because the new algebraic structure required more qubits. Instead, it opened a new region of the Pareto frontier: a design that trades a modest qubit increase for an order-of-magnitude gate reduction, which in many hardware deployment contexts is the more useful tradeoff. Researchers designing algorithms for specific hardware platforms can now choose between circuit families that previously did not exist.

The FeMoco context makes the pace of this progress concrete. The challenge of simulating the iron-sulfur core of the nitrogenase enzyme — the molecule responsible for biological nitrogen fixation, central to fertilizer production and therefore to global food supply — is a standard benchmark in quantum resource estimation. In 2017, Reiher et al. estimated this simulation would require approximately 50 trillion Toffoli gate operations. Eight years of intensive algorithmic work by teams including Google, Microsoft, Caltech, and university research groups had reduced that figure to approximately 340 million by the time this paper was published. The scale of progress demonstrated in the Anthropic STEM Fellows experiments — matching the magnitude of that compression across multiple domains, in 53 hours — gives weight to the paper's claim that AI-driven circuit optimization may become a routine accelerant for quantum algorithm development.

From AlphaFold to Autonomous Proof Discovery: A Step Change in AI Science

Several landmarks in AI-for-science research have preceded this result, and the comparisons are instructive.

DeepMind's AlphaFold 2, which effectively solved the protein structure prediction problem in 2020, learned to map amino acid sequences to three-dimensional structures by training on the Protein Data Bank — a large corpus of experimentally determined protein structures. The model found patterns in existing data that transferred to new sequences with extraordinary accuracy. AlphaFold did not need to understand protein chemistry; it needed to recognize structural regularities in a large dataset.

AlphaTensor, also from DeepMind, discovered faster matrix multiplication algorithms in 2022 by formulating the search as a reinforcement learning problem. It found sequences of scalar operations that computed matrix products with fewer multiplications than methods known since the 1970s. That result was significant, but the search space was defined by a reward function built on known mathematical properties of matrix multiplication — the model discovered an efficient path through a constrained space.

The divsteps result is different in a specific way: Claude Mythos 5 was not recognizing patterns in existing mathematical solutions, and it was not searching through a space whose structure was fully pre-specified. It encountered a problem the field had effectively marked as intractable — where no solution was known and the difficulty was a proven structural property of the target algorithm — and resolved the difficulty by deriving new mathematics that changed the structure of the problem. The Lean formal verification converts this from an empirical finding to a proved result.

This distinction matters for how to read claims about AI progress in scientific research. AlphaFold showed that AI could match expert human pattern recognition at scale. The Anthropic quantum circuit work suggests that at least some frontier models can now discover mathematical structure where humans have found none — not by accessing more data than humans, but by exploring the problem space differently.

No other AI laboratory has published results of comparable specificity in quantum circuit optimization. Google Quantum AI's work (Khattar et al., 2025) represents the prior state of the art for the DQI decoder, and it was produced by human experts. The Anthropic paper's closest scientific analogs are DeepMind's AlphaProof (2024), which used Lean proofs to solve mathematical olympiad problems, and the broader line of LLM reasoning research, but neither applied formal proof generation to novel problems in applied quantum algorithm engineering.

Limitations the Paper Acknowledges

The paper and Anthropic's accompanying blog post are candid about several important constraints.

The most significant is hardware. Better quantum circuits do not change the fact that fault-tolerant quantum computers capable of running these algorithms still do not exist at scale. The machines required to execute the improved divsteps and DQI circuits must have error rates low enough to sustain millions of Toffoli gate operations, which requires physical qubit counts and error correction overheads far beyond what current quantum hardware — including IBM, Google, IonQ, and QuEra's leading systems — currently provides. The circuit-level improvements narrow the hardware gap; they do not close it.

The Toffoli gate count metric, while the standard proxy for quantum circuit cost, also does not capture all forms of overhead in a real fault-tolerant implementation. Routing overhead (constraints imposed by the physical connectivity of qubits on a chip), the cost of different basis gates in different hardware architectures, and the latency of classical control circuitry are all absent from the benchmarks used in this paper. A circuit with 12 times fewer Toffoli gates on paper may realize a smaller speedup on specific hardware platforms.

The 1-in-10,000 failure rate on the DQI decoder is within accepted probabilistic error bounds for quantum computation but is a real limitation. Quantum error correction codes already tolerate some rate of logical errors, and the decoder's failure probability adds to that background. For applications where correctness guarantees are critical — cryptographic operations, certified simulations — this would need further analysis before deployment.

Access to Claude Mythos 5 remains restricted. The model is available only through Anthropic's Project Glasswing framework, which limits access to a small set of trusted organizational partners. Independent replication of these results by external quantum computing researchers requires either access to the model or a complete reconstruction of the methodology using a different system. No independent replication had been published as of October 17, 2026.

The task set of eight problems was also selected by the research team, not drawn from a standardized external benchmark suite. Tasks may have been chosen in part because they were tractable within the autonomous closed-loop framework, which could introduce selection bias in favor of problem structures that LLMs handle well. The paper does not discuss the selection criteria in detail.

Anthropic's Vision for Full-Stack Quantum Co-Design

The paper's conclusion points toward a longer-term research program that extends well beyond optimizing individual circuits. Anthropic describes a vision it calls end-to-end or full-stack co-design: rather than treating quantum hardware architecture, error correction codes, and algorithmic circuit design as separate layers to be optimized independently, an AI system would optimize them simultaneously as a unified system.

The motivation is structural. Circuit-level optimizations like the ones demonstrated in this paper are constrained by the hardware architecture they target. A circuit optimized for a surface-code error-corrected superconducting qubit array looks different from one optimized for a neutral-atom reconfigurable architecture. If AI models can jointly optimize both the hardware connectivity and the circuit structure — treating hardware design choices as variables rather than constants — the resulting systems could be substantially more efficient than any achieved through sequential human optimization of each layer separately.

This is speculative at the current state of the technology. Quantum hardware design involves physics constraints — coherence times, gate fidelity, qubit connectivity, fabrication tolerances — that are not yet fully reducible to optimization targets a language model can reason about. But the same objection would have applied to quantum circuit synthesis before this paper: the assumption that the design space was too constrained and technically specialized for an LLM to navigate proved incorrect.

For quantum hardware companies, the implication is that the algorithmic software layer is no longer the reliable bottleneck it was assumed to be. Roadmaps that projected quantum advantage in specific application domains based on a predicted trajectory of circuit-level algorithmic improvement should be revised. If AI-driven circuit optimization can compress years of research into days, the binding constraint shifts more fully to the hardware side — to physical qubit quality, error rates, and the engineering of large-scale fault-tolerant systems.

The closest near-term application of this work is likely in accelerating the design pipeline for applications where quantum advantage is already theoretically established: certain molecular simulation problems in chemistry and materials science, specific optimization problems of the type DQI targets, and factoring and discrete logarithm computations relevant to cryptography. For each of these, the circuit-level overhead has historically been a secondary reason for delays behind hardware maturation. This paper shrinks that secondary reason substantially.

The divsteps result carries a separate forward implication. If Claude Mythos 5 can identify and formally prove new algebraic structure in a classical algorithm that specialists had classified as quantum-intractable, the methodology may generalize to other classical algorithms where quantum implementations have been similarly dismissed. There is a large class of algorithms in cryptography, signal processing, and scientific simulation for which quantum implementations have been considered impractical primarily due to the garbage generation problem. Each of those represents a potential target for the same reverse-inference and formal-proof approach that unlocked divsteps.

What the quantum computing research community now faces is a tool that can potentially do in weeks what previously took years — not because it knows quantum physics better than human experts, but because it can explore the mathematical structure of an algorithm more comprehensively than any individual researcher, across more cases simultaneously, without fatigue, and with access to formal verification to confirm what it finds. Whether that tool remains gated behind Project Glasswing or eventually becomes more broadly available to academic researchers is a question Anthropic has not yet answered publicly.

The more immediate question for the field is replication. The results in arXiv:2610.22367 are detailed enough that quantum circuit researchers can evaluate the methodology and, in principle, reproduce the key architectural choices. Whether the new divsteps algebraic identities hold up to independent mathematical scrutiny — and whether the DQI decoder performs as claimed on the hardware platforms for which it was designed — will be determined by the quantum computing community over the months ahead. If they hold, the paper marks the moment AI-assisted quantum circuit synthesis became a genuine accelerant for the hardware timeline, rather than an impressive demonstration with unclear practical stakes.

Read more: Anthropic's AI for science biology claim faces scrutiny