Quantum computing made real progress in the last 24 hours, but not for the reason most headlines will suggest. Quantinuum’s Helios result, a reported 99.9995% logical fidelity, is a serious error-correction milestone, not quantum-washing. Yet the more consequential development is quieter: Alice & Bob’s claim that its cat-qubit architecture could reduce the resources needed to break RSA-2048 to 22,593 physical qubits, while using GPUs to decode its error-correction signals.

That distinction matters because quantum computing has spent the last decade optimizing the wrong scoreboard. Physical qubit counts generate headlines. Logical error rates determine whether a machine can run a useful algorithm. A processor with thousands of noisy qubits is not necessarily closer to commercial value than a smaller machine with a credible path to stable logical qubits. The industry is finally being forced to discuss the conversion rate between the two.

Quantinuum’s five errors per million operations is impressive, but it is still a component result, not a useful application. The company has not demonstrated RSA breaking, drug discovery, or an optimization workflow that beats classical systems. Alice & Bob’s 22,593-qubit estimate is also not a forecast of a machine arriving soon. It is a resource estimate based on a particular architecture, decoder, compilation strategy, runtime, and set of assumptions about hardware performance. Both results are valuable. Neither is commercial quantum advantage.

The important shift is that the bottleneck is becoming legible. The question is no longer whether companies can make a qubit survive longer in isolation. It is whether they can manufacture, connect, decode, and operate enough error-corrected qubits at a tolerable cost. That is a much less glamorous problem, and it is where the winners will emerge.

Quantinuum’s result is genuine science. A logical qubit is encoded across multiple physical qubits so that errors can be detected and corrected. The relevant metric is not the fidelity of one gate or one measurement, but the probability that the encoded qubit fails during a logical operation. Quantinuum reported 99.9995% logical fidelity using a color-code approach on its Helios system, equivalent to roughly five errors per million operations.

That number clears an important psychological threshold, but readers should not confuse it with fault tolerance. Useful algorithms require many logical qubits performing billions or trillions of operations. At five failures per million operations, a circuit with one billion logical operations would still accumulate thousands of expected failures if error correction did not include additional fault-tolerant machinery, verification, and recovery. The result demonstrates progress toward a scalable stack. It does not demonstrate a scalable stack.

The missing denominator is the physical cost. Quantinuum’s announcement does not make the logical qubit free. Every logical qubit consumes physical qubits, control electronics, calibration effort, cryogenic capacity, and classical decoding. Logical fidelity is meaningful only alongside code distance, number of physical qubits per logical qubit, cycle time, decoder latency, and whether the logical error continues falling as the code grows.

This is where Alice & Bob’s work deserves more attention than its smaller headlines suggest. Cat qubits encode information in oscillator states designed to suppress one dominant class of errors at the hardware level. That can reduce the burden placed on the error-correction code, especially when the architecture is engineered around biased noise. The company’s estimate of 22,593 qubits for RSA-2048 is therefore not simply a smaller version of the usual superconducting-qubit estimate. It reflects a different error budget and a different allocation of hardware complexity.

But resource estimates are easy to oversell. “22,593 qubits” sounds like a finish line. It is not. The estimate also assumes the architecture can deliver the required gate fidelities, connectivity, measurement rates, decoding throughput, and sustained uptime. A machine that reaches the qubit count but cannot maintain those parameters has not broken RSA. Architecture papers are maps, not roads.

The GPU decoding demonstration is commercially relevant for exactly this reason. Error correction produces a stream of syndrome data that must be processed quickly enough to keep up with the quantum processor. If decoding falls behind, the quantum computer spends its time generating error information that the control system cannot use. Alice & Bob’s use of NVIDIA’s NVLink-based infrastructure shows that the classical side of the machine is becoming part of the product architecture, not an afterthought.

Still, synthetic data is the phrase investors should underline. A decoder validated on simulated syndromes has not yet proven that it can handle the correlated, drifting, hardware-specific errors produced by a real processor. The demonstration is a credible engineering step, not evidence that the full cat-qubit system has crossed into fault-tolerant operation.

The same skepticism applies to Pasqal’s 256-qubit quantum magnet result. A quantum system behaving differently from leading classical simulations can be scientifically interesting, particularly in strongly correlated regimes. But disagreement with simulation is not automatically quantum advantage. It can indicate that the quantum system is probing a regime classical methods find difficult, or that the experiment, noise model, or interpretation needs more work. Until the output is validated and connected to a practical task, the result is physics, not a business case.

These developments move enterprise quantum computing forward, but they do not pull the commercial timeline dramatically closer. The near-term implication is not that banks should replace classical optimization systems or that pharmaceutical companies should begin migrating production workloads. It is that quantum readiness programs should focus less on vendor qubit counts and more on logical resource requirements.

For enterprise planning, the useful questions are now concrete. How many logical qubits does the target algorithm require? How many logical operations must it execute? What logical error rate is acceptable? How much classical decoding and data movement does the architecture require? Which assumptions have been demonstrated on hardware rather than in a resource estimate?

Quantinuum currently has one of the strongest public positions on demonstrated logical performance. Google remains formidable in error-correction research, particularly after its Willow work on below-threshold behavior and magic-state cultivation. Alice & Bob is less visible but potentially more disruptive if its biased-noise architecture delivers the claimed reduction in physical overhead. The winner will not be the company with the best isolated fidelity number. It will be the company that turns that number into a repeatable logical-qubit factory.

Magic states are especially important because they are a central cost driver for universal fault-tolerant quantum computation. Google’s reported cultivation result, with a logical fidelity near 0.9999 and roughly a 40-fold reduction in error for the prepared state, addresses a real bottleneck. But magic-state production is not a complete computer. It is one expensive ingredient in the fault-tolerant recipe.

The honest enterprise timeline is therefore bifurcated. Narrow scientific workloads, quantum simulation experiments, and hybrid workflows will expand before broad fault-tolerant advantage arrives. Cryptographically relevant machines remain a long-term engineering project, but the resource estimates are now specific enough that post-quantum migration cannot be postponed. Security teams do not need to predict the exact arrival date of a cryptographically capable machine. They need to account for data with long confidentiality lifetimes and infrastructure that takes years to replace.

The next decisive signal is not another record fidelity announcement. Watch for a company to publish a logical-qubit scaling curve using real hardware, show that the logical error continues to fall as the code grows, disclose the physical-qubit overhead, and report decoder performance under live operating conditions. That combination would separate a platform from a laboratory result.

The industry is heading toward a less marketable but more honest phase. Qubit counts will still dominate press releases, but investors who understand error budgets will increasingly value architecture, calibration automation, decoder integration, and manufacturing yield. Quantinuum has the strongest demonstrated result in this news cycle. Alice & Bob may have the more important commercial thesis. The companies that win will be those that make error correction boring, repeatable, and cheap enough to run every day.