The console under the television is still the same. Years later, its games seem to know how to do much more with it. Anyone who follows a console generation knows that feeling: as studios master the platform, they learn where to spend resources, what to reuse and how to fit in ideas that once seemed too ambitious for that machine.
Naughty Dog left a good record of this. In a retrospective published on PlayStation.Blog, Evan Wells explained that the studio got more out of the PS3 with each project. After believing it had reached the limit with Uncharted 3, the team found room to push further again in The Last of Us. The programmers’ experience was part of the available power, too.
That is a useful way into an Anthropic research project with Claude. The setting is now quantum computing, but the question has an interesting family resemblance: how much can we gain by rethinking the program before asking for a bigger machine?
A better circuit before hardware at scale
In research released on October 16, the company reports a search for more efficient circuits using Claude Mythos 5. After 53 hours working on elliptic-curve point addition, one solution used 12% more qubits but reduced the Toffoli gate count by a factor of 17 compared with the earlier design with the lower qubit count. There was an initial human request and occasional prompts to broaden the exploration.
View chart data
| Resource | Luo et al. | Claude (divsteps) |
|---|---|---|
| Toffoli gates | 70 000 000 | 4 000 000 |
| Logical qubits | 838 | 935 |
It is a substantial design result, with a well-defined trade-off: spend a little more of one resource to save a great deal of another. Think of a developer choosing to reserve more memory to avoid repeated work. The analogy helps illustrate the decision, although a quantum machine’s resources and rules are different.
A quantum circuit is a sequence of operations on qubits; those operations are called gates. Improving that circuit means finding a more economical way to perform the desired calculation. The question is no longer just how many qubits a machine will have, but also how much work we will ask them to do.
The preprint by Andi Gu, Alek Kemeny, Susanne Yelin and Mikhail Lukin brings together eight tasks. In seven, the circuits found reduced both qubits and Toffoli gates compared with the reference designs. In the eighth, they expanded the available trade-offs between the two resources. These are components of larger algorithms in fields such as chemistry, simulation and numerical computing.
Claude proposes, the evaluator checks
The research follows a loop: the model proposes a circuit, an independent evaluator checks the proposal and calculates its cost, and Claude uses the feedback to try to improve it. The score combines Toffoli gates, operations that matter to the cost of fault-tolerant computing, with peak logical-qubit usage. For large domains, verification uses sampling; some designs also allow rare failures within the limit permitted by the task.
What makes this setup interesting is that ideas have to deliver. A suggestion must survive checks and show an advantage by the chosen measure. For anyone following AI programming tools, that deserves attention: the quality of the test matters as much as the ability to generate a convincing answer.
The quantum challenge has a distinctive feature. In certain subroutines, intermediate results must be undone in a controlled way to free auxiliary qubits. The technique, called uncomputation, prevents leftover computation from disrupting the interference the algorithm needs, as IBM’s educational documentation explains. That cleanup also costs operations.
In the example highlighted by Anthropic, Claude explored the classical divsteps algorithm for modular inversion. The solution recovers information about earlier decisions from the state of the calculation, reducing the need to keep a history. Variants balance recovery and storage. The company also reports using Lean to verify the recovery rule.
It is the kind of ingenuity that makes optimization enjoyable: discovering that something which seemed to require more space can be reorganized. On consoles, that satisfaction comes when a studio finds a better way to distribute the work. Here, it emerges in a mathematical construction with requirements of its own.
What the factor of 17 actually measures
The reduction in gates does not demonstrate an entire application running 17 times faster on a commercial computer. That number describes a comparison between circuits. Other aspects of the implementation come into play when determining execution time.
One is depth: how many layers of operations must happen in sequence. Independent gates can run in parallel; others have to wait. The circuit must also be adapted to the connections and operations available on the processor, as IBM explains in its guide to running circuits.
There is also protection against errors. Logical qubits represent information that can be encoded across multiple physical qubits, the hardware elements. IBM’s introduction to error correction explains that distinction. Saving resources in the logical design is therefore an important part of the calculation, but the final amount of hardware depends on how the system is built.
Benchmark readers already know the approach that helps here: look at the metric, the task and the conditions. An improvement in one component can be excellent in its own right, without becoming a promise of an equal multiplier across everything the machine does.
A lesson from console generations, without declaring the end of PCs
The console comparison is about the value of software and accumulated knowledge. Anthropic’s work optimizes quantum circuits; it does not directly improve a classical CPU or announce its replacement. IBM’s explanation of this setting describes systems in which the classical computer organizes the work and the quantum processor carries out the part suited to it. Specialized technologies can coexist.
That is why viewing this research as a handover from a finished classical generation to a quantum one that is ready to go would reach beyond the result. The more fruitful parallel is learning. On a console, developers make better use of a platform over the years. In this experiment, the search tries to make calculations more feasible before we have fault-tolerant quantum machines at the scale needed for many applications.
In MaisFPS’s view, that is the reason to follow the research. Building more capable hardware remains important; learning to ask less of it can also expand what becomes possible. Claude appears here in a design-and-evaluation experiment, not as an everyday chat feature that delivers any finished circuit. The next steps call for replication and implementation assessments. The old lesson from consoles still offers inspiration: the specification sheet tells part of the story; the ingenuity of those writing the code helps write the rest.
