For years, the easiest way to describe progress in quantum computing was to count qubits. A company announced 50, then 100, then 1,000 physical qubits, and the headlines naturally followed the bigger number. That was understandable, but it was never the full story. A quantum computer is not useful because it has many fragile qubits. It becomes useful when those qubits can hold and process information reliably enough to run a calculation that matters.

That is why the most important quantum computing story this month is not simply a new chip or a larger machine. It is the steady movement from physical qubits toward logical qubits: protected units of quantum information built from many physical qubits working together. This shift marks a change in the field’s center of gravity. Quantum computing is moving from demonstrations of raw capability toward the engineering discipline required for fault-tolerant machines.

A physical qubit is the hardware-level quantum system: a superconducting circuit, trapped ion, neutral atom, photon, or spin device. It is powerful because it can represent quantum information, but it is also delicate. Noise from the environment, imperfect control pulses, stray interactions, and measurement errors can corrupt the computation. A logical qubit is different. It is an encoded qubit, distributed across multiple physical qubits, designed so errors can be detected and corrected without directly destroying the quantum information.

The basic idea sounds similar to classical error correction, but quantum error correction is far harder. In an ordinary computer, copying a bit and checking whether the copies agree is straightforward. Quantum information cannot be copied in that simple way, and measuring it directly can collapse the state being protected. Quantum error-correction codes therefore measure surrounding “syndrome” information: clues about whether an error occurred, without reading the encoded quantum state itself.

The most widely discussed approach is the surface code, which arranges qubits in a lattice and uses repeated checks to detect errors over time. In December 2024, Google’s Willow processor provided an important proof point for this strategy. Google reported, and Nature published, results showing below-threshold quantum error correction, meaning the logical qubit improved as the code size increased. In plain terms, adding more physical qubits to the code made the protected qubit better rather than worse.

That point matters because it addresses a central fear in quantum scaling. More hardware normally means more places for errors to enter. If the physical error rate is too high, a larger code can simply create a larger failure surface. Below the threshold, however, the logic flips: extra qubits provide enough protection that the encoded error rate falls. Google’s Nature paper reported a distance-7 logical memory with a lifetime exceeding its constituent physical qubits, an important step beyond the “break-even” idea.

Break-even is not the same thing as a commercially useful quantum computer. It does not mean we can run chemistry, materials, optimization, or cryptography workloads at industrial scale tomorrow. It does mean the field has crossed from hopeful theory into experimentally demonstrated behavior that scaling plans depend upon. The achievement is less dramatic than a headline claiming immediate revolution, but more important than many louder claims.

IBM’s recent roadmap gives another view of the same transition. IBM has described a path toward Starling, a planned fault-tolerant system targeted for 2029 with 200 logical qubits and the ability to run circuits containing 100 million gates. The roadmap emphasizes not just qubit counts, but modularity, logical operations, real-time decoding, and low-overhead quantum error-correction codes. Whether IBM meets every milestone on schedule remains to be proven, but the engineering vocabulary is telling. The race is no longer only about building chips. It is about building complete systems.

Real-time decoding is one of the least glamorous and most decisive parts of that system. During error correction, the quantum processor produces a stream of syndrome data. A classical computer must interpret that data, infer likely errors, and provide corrections fast enough that the quantum calculation can continue. If this classical feedback loop is too slow, the correction arrives after the damage has already spread. Fault tolerance therefore requires a tight marriage between quantum hardware and classical high-performance computing.

This is why recent work from Quantinuum, Microsoft, NVIDIA, IBM, Google, and academic groups deserves attention. Their approaches differ: trapped ions offer high fidelity and flexible connectivity, superconducting devices offer fast gates and deep fabrication experience, and neutral atoms and photonics bring their own scaling arguments. Yet they are increasingly being judged by a common question: can the platform support logical qubits, correction cycles, decoders, and useful operations in a system that scales?

Quantinuum has reported notable progress using trapped-ion hardware, including demonstrations of logical qubits with lower error rates than corresponding physical qubits, and more recent work describing high-rate encodings that produce many logical qubits from a relatively small number of physical qubits. These results are not identical to Google’s surface-code milestone, because the hardware architecture and code strategy differ. That distinction is important. There may not be one universal winner in quantum error correction. Different platforms may succeed with different codes and control systems.

The practical significance is that logical qubits are becoming a more serious benchmark than physical qubits. A 1,000-qubit machine with noisy, unprotected qubits may be less meaningful than a smaller system that can show reliable encoded operations. Likewise, a logical qubit that only stores information is not enough by itself. A useful fault-tolerant computer must prepare logical states, perform logical gates, measure them, connect them, and do all of this repeatedly over long computations.

There is also an important distinction between error correction and error mitigation. Error mitigation tries to estimate or reduce the effect of noise after running imperfect circuits, often by using extra measurements or extrapolation. It can be valuable on today’s noisy machines. Error correction, by contrast, aims to actively protect quantum information during the computation. Recent research is also exploring how mitigation techniques might help logical qubits in the early fault-tolerant era, but mitigation is not a substitute for full fault tolerance.

For business and policy leaders, the message is sober but encouraging. Quantum computing still has not delivered a broad, indisputable commercial advantage over classical computing. Many useful algorithms would require many logical qubits and very deep circuits. The gap between today’s experiments and tomorrow’s utility-scale machines remains large. At the same time, the technical conversation has become more concrete. It is now possible to ask better questions: What is the logical error rate? What is the decoding latency? How many physical qubits are required per logical qubit? What operations are fault tolerant? How does the architecture scale?

DARPA’s Quantum Benchmarking Initiative reflects this more disciplined posture. Its goal is to evaluate whether any quantum computing approach can reach utility-scale operation, where computational value exceeds cost, by 2033. That framing is useful because it avoids treating quantum progress as either magic or failure. It asks whether a proposed machine can be built, operated, benchmarked, and justified against real computational value.

The next few years should therefore be judged by a different scoreboard. We should watch for logical qubits that can run gates, not only idle memories. We should watch for decoders that operate in real time, not only offline analysis. We should watch for modular systems that preserve fidelity across connections. We should watch for algorithms designed around realistic logical resources, not abstract machines with perfect qubits.

The encouraging news is that quantum computing is becoming less mysterious as an engineering project. The field still faces deep physics, manufacturing, control, software, and economic challenges. But the outlines of the problem are clearer than they were a decade ago. Build better physical qubits. Encode them into logical qubits. Decode errors fast. Reduce overhead. Prove useful circuits. Compare against the best classical methods.

That may sound less spectacular than promises of instant disruption. It is also more credible. The quantum future will not arrive because a processor has a large qubit count printed on a slide. It will arrive when logical qubits are reliable, operations are repeatable, and systems can run calculations whose value survives serious benchmarking. In 2026, the field is not finished. But it is finally being measured by the standards that matter.

Researched and Written by Peter Jonathan Wilcheck

Reference Sites:

1. Google Research: Making quantum error correction work
2. Nature: Quantum error correction below the surface code threshold
3. IBM Quantum: How IBM will build a large-scale fault-tolerant quantum computer
4. Quantinuum: Real Time Error Correction at Increased Scale
5. DARPA: Quantum Benchmarking Initiative Stage B Selection