Generated by Codex with GPT 5.6 Sol High

Quantum computing is constrained not only by hardware. The algorithm that looks elegant on paper must eventually become a reversible circuit, and a poor circuit can consume orders of magnitude more qubits and gates than a carefully designed one. That makes circuit design a software-and-systems optimization problem with unusually sharp rules: implementations can be expressed as code, checked automatically for correctness, and scored against an explicit resource budget.

The official Anthropic Research post, “Designing more efficient quantum circuits with Claude,” describes a closed-loop system that gave Claude Mythos 5 plain-language specifications for eight computational primitives from chemistry, optimization, physics simulation, and number theory. An external evaluator tested each proposal and scored it using qubit count multiplied by gate count. Claude then revised its code in response. Across all eight tasks, the resulting designs moved beyond the best published circuits, sometimes by more than an order of magnitude.

Why ordinary optimization rules break down

A classical program can branch, overwrite temporary values, and discard scratch space. A quantum circuit generally cannot. It operates on superpositions, so it must encode all relevant paths in one fixed sequence of gates. It must also be reversible: intermediate information cannot simply be erased, because the computation may need to be run backward to disentangle that scratch work from the final answer.

The standard escape hatch is “uncomputation”—reversing the operations that produced an intermediate value—but that consumes more gates. Keeping intermediate values avoids recomputation but occupies more qubits. Circuit design therefore becomes a space-time tradeoff in which the obvious classical implementation may be an especially bad quantum one.

Anthropic’s harness turned that tradeoff into an executable search problem. Claude proposed Python implementations, the evaluator rejected incorrect designs, and valid ones received a numerical score. The model could explore several approaches in parallel and iterate without human intervention between rounds. Humans supplied the task definitions and occasionally prompted the model to search more broadly, but they did not manually steer each optimization step.

This setup matters as much as the model. The evaluator prevents persuasive but invalid reasoning from surviving, while the objective gives the model a gradient-like signal without requiring a differentiable program. It is the same general pattern that makes coding agents useful on tests, theorem provers, and performance benchmarks: let the model generate candidates, but place correctness and progress outside the model’s own judgment.

Recovering history instead of storing it

The first detailed result concerns modular inversion, the most expensive part of adding points on an elliptic curve. A fast classical method called divsteps repeatedly chooses operations based on the values it sees. Classical software can forget the record of those choices. A reversible circuit must retain that branch history so it can undo its work, and storing the full record wipes out much of the algorithm’s advantage.

Claude eventually derived algebraic identities that allowed the branch information to be reconstructed from the evolving numerical state instead of stored at every step. It checked the construction with large numerical simulations and formalized the key claim in Lean. The resulting reversible implementation exposed a family of choices between decoding history and retaining it. One point on that new Pareto frontier uses 12% more qubits than the smallest earlier design but 17 times fewer gates.

The process took a 53-hour run. That is striking, but the deeper lesson is architectural: an apparently necessary log or checkpoint may be redundant if history can be recovered from current state. The same question appears in reversible computation, storage engines, speculative execution, and distributed recovery. Before paying to persist every decision, ask whether the state transition preserves enough structure to reconstruct it.

Rebuilding the algorithm around the machine

The second case optimizes the decoder inside decoded quantum interferometry, a proposed quantum optimization algorithm. The previous state-of-the-art circuit used the extended Euclidean algorithm to decode Reed–Solomon syndromes. Its number and sequence of operations depend on the input, which is natural for ordinary software but expensive for a quantum circuit that must embody every path.

Claude replaced it with Berlekamp–Massey decoding. That algorithm performs the same kind of operation for a fixed number of rounds, making its control flow a much better match for a quantum circuit. It then attacked the memory cost of reversibility. A naive design would save a 12-qubit record in each round, eventually consuming 840 qubits. Claude instead found that most temporary values could be reconstructed from the updated state.

Some exceptional values still had to be stored. Rather than reserve space for the 665-qubit worst case, the system ran 403 million simulated decodings and found that almost every run needed at most one 19-qubit saved value. The circuit accepts failure in roughly one run out of 10,000, within the task’s allowed error rate. Combining the algorithm change, state reconstruction, and measured resource budget reduced the decoder’s gate count by a factor of 12 relative to the previous construction.

That result is a useful antidote to local optimization. The gain did not come from shaving a few gates from the old decoder. It came from changing the algorithm to fit fixed quantum control flow, changing the representation of temporary state, and replacing a theoretical worst-case allocation with an empirically justified reliability target. Large improvements often require moving across abstraction layers rather than tuning one layer in isolation.

What the result does—and does not—establish

The eight successes show that long-running agents can contribute original technical designs when three conditions hold: candidates are expressible as code, correctness is cheaply testable, and quality has an objective metric. Anthropic also found that the model tended to be conservative, repeatedly checking sound ideas and favoring familiar methods. Requiring qualitatively different approaches and occasionally widening the search helped it escape those habits.

The experiment does not show that an agent can design an entire fault-tolerant quantum computer or that these circuits have already delivered useful work on quantum hardware. The tasks were deliberately chosen to support classical validation, and one highlighted design trades a small probability of failure for a much lower resource budget. Independent scrutiny of the proofs, implementations, assumptions, and hardware-level costs still matters.

The broader engineering takeaway is nevertheless strong. AI-assisted discovery works best when the surrounding system converts an open-ended research problem into a disciplined loop: generate diverse implementations, validate them with tools the model cannot talk around, score the real bottleneck, and preserve the evidence needed for human review. In this case, the important innovation is not simply that Claude wrote quantum code. It is that a carefully constructed verifier-and-feedback loop let the model search a difficult design space while keeping correctness and resource use anchored outside the model.