Logical qubits that beat their physical parts: who has shown it, how, and what is still missing

Background

Physical qubits, logical qubits, and why the headline count misleads

A physical qubit is one piece of hardware that holds quantum information, such as a superconducting circuit, a trapped ion or a single neutral atom held by a laser. Every physical qubit makes mistakes at some rate. Today those rates are far too high for the long calculations that would be commercially useful. A logical qubit is one unit of quantum information spread across many physical qubits by an error-correcting code, so that errors on individual parts can be found and fixed without destroying the information.

The code works by measuring checks again and again. Each check reveals whether neighbouring qubits still agree, without reading out the stored information itself. A conventional computer called a decoder reads these check results, called the syndrome, and works out which errors probably happened. The code distance is roughly the number of physical errors needed to corrupt the logical qubit without being caught. A larger distance needs more physical qubits and, in principle, gives more protection.

There is a catch. Each added physical qubit is another place for an error to occur. Google's 2024 paper states the condition plainly: the exponential suppression of errors 'only occurs if the physical error rate is below a critical threshold'. Below threshold, a larger code means fewer logical errors. Above it, a larger code makes things worse. Break-even is a separate bar. It means a logical qubit or logical operation does better than the physical qubit or physical operation it replaces.

This is why a count of physical qubits says little about computing power. A 105-qubit chip may hold a single logical qubit. Groups also use the words 'logical qubit' for codes that can only detect errors, where runs with a detected error are thrown away. So every claim needs the same questions. Which code and distance was used? Were errors corrected or only detected? Was the logical qubit storing information or computing? Were runs discarded? What baseline was it compared against?

Sources: [1]

Reported evidence

Google Quantum AI: a surface-code memory that improves as it grows

The clearest below-threshold result so far is Google Quantum AI's 'Quantum error correction below the surface code threshold'. It was posted to arXiv on 24 August 2024 and published in Nature (volume 638, 2025, pages 920–926), so it has passed peer review. A surface code arranges physical qubits in a square grid with checks between neighbours. The team ran two surface-code memories, 'a distance-7 code and a distance-5 code integrated with a real-time decoder'. The larger one is described as 'a 101-qubit distance-7 code'.

The paper reports that logical errors were 'suppressed by a factor of Λ = 2.14 ± 0.02 when increasing the code distance by two'. The distance-7 memory had '0.143% ± 0.003% error per cycle of error correction'. Its lifetime exceeded its 'best physical qubit's lifetime by a factor of 2.4 ± 0.3', so this logical memory passed break-even. By this publication's arithmetic, a factor of 2.14 applied twice, from distance 3 to 5 and from 5 to 7, means about 4.6 times fewer logical errors at distance 7 than at distance 3.

The team also decoded in real time, 'achieving an average decoder latency of 63 μs at distance-5'. Real-time decoding matters because a working computer has to decide what to do next while the calculation is still running. In a separate test with simpler repetition codes, run up to distance 29, Google found that 'logical performance is limited by rare correlated error events occurring approximately once every hour'. The paper says these events 'set a current error floor of 10⁻¹⁰' in that test.

This result does not show computation. It is a memory: one logical qubit held over time, with no logical gates between logical qubits. The paper's own outlook sets out the remaining distance: 'achieving a 10⁻⁶ error rate would require a distance-27 logical qubit using 1457 physical qubits'. By this publication's arithmetic, 0.143% per cycle is about 1,430 times higher than 10⁻⁶. The projected 1,457 qubits are about 14 times the 101 used here, for a single logical qubit.

Sources: [1]

Reported evidence

Google's colour code: first logic steps, at smaller margins

A second Google paper, 'Scaling and logic in the color code on a superconducting quantum processor', was posted on 18 December 2024 and published in Nature (volume 645, 2025, pages 614–619). The colour code is a different layout that makes some logical operations cheaper than in the surface code. Its checks are harder to run and its errors are harder to decode.

The paper reports that going from distance three to five 'suppresses logical errors by a factor of Λ3/5 = 1.56(4)'. It reports three kinds of logical operation. Transversal Clifford gates, which act on all the qubits of a code in parallel and cannot by themselves give a universal computer, 'add an error of only 0.0027(3)'. Magic-state injection, a step towards the extra operations needed for universal computing, reached 'fidelities exceeding 99% with post-selection'. Lattice surgery, a way of joining and splitting code patches to move information between them, gave 'teleported state fidelities between 86.5(1)% and 90.7(1)%'.

Google's own blog post sets out the limits. It says 'this initial result is smaller than the factor of 2.31×' seen with surface codes, and it calls the surface code 'still our main workhorse configuration'. Fidelities of 86.5% to 90.7% for moving logical information are far from what long computations require. The magic-state figure depends on discarding runs. These are first logic steps at small distances, not fault-tolerant computation.

Sources: [2] [3]

Reported evidence

Harvard, MIT and QuEra: many logical qubits in neutral atoms

Neutral-atom machines hold single atoms in focused laser beams and can move them during a calculation. That makes it possible to connect any qubit to any other. The Harvard-led paper 'Logical quantum processor based on reconfigurable atom arrays' (arXiv, 7 December 2023) was published in Nature. It describes a processor 'operating with up to 280 physical qubits'.

The team reports 'improvement of a two-qubit logic gate by scaling surface code distance from d=3 to d=7' and 'preparation of color code qubits with break-even fidelities'. It also ran sampling circuits 'with up to 48 logical qubits' using '228 logical two-qubit gates and 48 logical CCZ gates'. This was computation on many logical qubits at once, not only memory.

There is a qualifier. The paper says the encoding 'substantially improves algorithmic performance with error detection'. Detection means runs with a flagged error were set aside. As circuits grow, a smaller share of runs survives, so this approach cannot by itself scale to long computations.

A follow-up, 'Architectural mechanisms of a universal fault-tolerant quantum computer' (arXiv, 25 June 2025), was published in Nature volume 649 on 10 November 2025, according to NIST's publication record. It used 'reconfigurable arrays of up to 448 neutral atoms'. It reports '2.14(13)x below-threshold performance in a four-round characterization circuit', obtained 'by leveraging atom loss detection and machine learning decoding'. It also investigated 'logical entanglement using transversal gates and lattice surgery' and universal logic 'through transversal teleportation with 3D [[15,1,3]] codes'. Reusing qubits mid-circuit raised 'experimental cycle rates by two orders of magnitude'.

Four rounds of checks is a short test. The 2.14 figure happens to match Google's Λ, but it comes from a different experiment and circuit and should not be read as the same measurement. The abstract does not report a long-lived memory compared across several code distances, as Google's paper does.

Sources: [4] [5] [6]

Reported evidence

Trapped ions: Microsoft with Quantinuum, then Quantinuum's Helios preprints

In April 2024, researchers from Microsoft Azure Quantum and Quantinuum posted 'Demonstration of logical qubits and repeated error correction with better-than-physical error rates'. The experiments ran on Quantinuum's H2 trapped-ion processor. With the [[7,1,3]] code, they 'entangled logical qubits... with error rates 9.8× to 500× lower than at the physical level'. A [[12,2,4]] code reached 'error rates 4.7× to 800× lower than at the physical level, depending on the judicious use of post-selection'.

The wide ranges matter. The top of each range relies on post-selection, meaning runs with a detected error were discarded. The bottom of each range is closer to what correction alone delivered. The paper also reports repeated error correction with the [[12,2,4]] code. Each correction cycle 'consists of over 100 physical CNOTs', yet the authors 'show evidence that' its error rate 'approaches the error rate of two physical CNOTs'. The arXiv record shows a third version dated 17 November 2024 and lists no journal reference, so we treat it as a preprint.

Quantinuum and collaborators have since posted several preprints using Helios, which the papers describe as 'a 98-qubit trapped-ion quantum processor'. 'Computing with many encoded logical qubits beyond break-even' (25 February 2026) reports computations 'with between 48 and 94 logical qubits' that 'outperform their unencoded counterparts'. It uses error-detecting iceberg codes with what the authors call 'reasonable postselection rates'. 'Fault-tolerant execution of error-corrected quantum algorithms' (4 March 2026), by JPMorganChase and Quantinuum researchers using the H2 and Helios processors, ran QAOA, an optimisation algorithm, and HHL, an algorithm for linear equations. Its largest run used '12 logical (97 physical) qubits', for which the authors report only 'better-than-random performance'; they describe the work overall as 'near-break-even'.

The most recent preprint, 'Experimental validation of a compact fault-tolerant architecture for trapped ions' (2 September 2026), reports 'an error of 4.6 (+6.2/−2.6)×10⁻⁵ per logical qubit per QEC cycle'. It also reports 'an error of 2.8 (+1.0/−1.6)×10⁻⁴ per two-qubit logical Clifford', and says the encoded version 'outperforms its corresponding unencoded physical baseline'. These figures were obtained 'without relying on postselection'. The authors use simulations to argue that better hardware could 'bring the same architecture into the 10⁻⁶–10⁻⁸ logical-error regime'.

None of these four trapped-ion papers lists a journal reference on arXiv. The error bars on the memory figure are wide. The headline of 94 logical qubits refers to error detection, not to 94 corrected qubits.

Sources: [7] [12] [13] [14]

Reported evidence

Microsoft with Atom Computing, and IBM's simulated codes and roadmap

Microsoft and Atom Computing posted a preprint on 18 November 2024. Its latest version, revised on 9 June 2025, is titled 'Fault-tolerant quantum computation with a neutral atom processor'. The processor has '256 qubits, each an individual neutral Ytterbium atom'. The team reports 'the entanglement of 24 logical qubits encoded into 48 atoms', 'at once catching errors and correcting for, on average 1.8, lost atoms'. The paper's main text says these encoded circuits 'outperform unencoded circuits on physical qubits'. The abstract's phrase 'showing better-than-physical error rates' refers to a separate Bernstein-Vazirani run 'with up to 28 logical qubits encoded into 112 atoms'. The operations are designed so that key errors 'convert to atom loss, which can be detected by imaging'.

The 24-qubit result works out to two atoms per logical qubit (this publication's arithmetic) in a distance-two code that, in the paper's words, 'can detect errors and correct for lost atoms', a far lighter encoding than the distance-7 surface code above. The comparison is with physical error rates for this entangling task, not a long-lived memory. arXiv lists no journal reference.

IBM's main error-correction paper, 'High-threshold and low-overhead fault-tolerant quantum memory', was published in Nature (volume 627, 27 March 2024). It proposes quantum low-density parity-check (qLDPC) codes. The paper reports 'an error threshold of 0.7% for the standard circuit-based noise model'. It also reports that '12 logical qubits can be preserved for nearly 1 million syndrome cycles using 288 physical qubits in total', assuming a 0.1% physical error rate. A surface code doing the same 'would require nearly 3,000 physical qubits'. By this publication's arithmetic, 288 is about one-tenth of 3,000.

These are simulation results: the paper cites 'Numerical simulations performed for the circuit-based noise model'. It notes that the codes 'are not geometrically local', and it lists qubits 'coupled to seven connections' as a hardware challenge. IBM's roadmap, published on 10 June 2025, says that 'By 2029, we will deliver IBM Quantum Starling', running '100 million quantum gates on 200 logical qubits'. It names Kookaburra (2026) as 'the first quantum processor module capable of storing information in a qLDPC memory'.

IBM's 12 November 2025 release describes Loon as an 'experimental processor' that shows the key components for fault tolerance. It reports decoding 'in real-time (less than 480 nanoseconds) using qLDPC codes', 'a full year ahead of schedule'. The release gives no measured logical error rates. None of the IBM documents we opened reports a qLDPC logical qubit that beats its physical parts in hardware.

Sources: [8] [9] [10] [11]

Our interpretation

Reading the results side by side: memory, computation and peer review

Our reading is that the results fall along two separate lines. Memory means holding one logical state over many check cycles. Google's surface-code paper is the strongest memory result: it is peer reviewed, it is below threshold across three code distances, and it beats its best physical qubit. Computation means logical gates between logical qubits, including the non-Clifford operations needed for universal algorithms. Harvard and QuEra, Quantinuum, Microsoft and Atom Computing have gone further on computation, but with smaller codes, error detection, short depths or preprint status.

Peer-reviewed results in the documents we opened are Google's surface-code memory and colour-code papers, both Harvard-led neutral-atom papers, and IBM's qLDPC paper, which is simulation, not hardware. Preprints with no journal reference listed on arXiv are the Microsoft–Quantinuum 2024 paper, the Microsoft–Atom Computing paper and the three 2026 Quantinuum Helios papers. Peer review checks methods. It does not make one group's numbers comparable with another's.

The measures really do differ. Error per correction cycle, error per logical gate, state fidelity and 'improves on the unencoded circuit' are four different things. 'Better than physical' always means better than a baseline the authors chose: the best single qubit, a physical two-qubit gate or an unencoded version of the same circuit. Results that discard flagged runs should be kept apart from results that correct errors and keep every run.

Sources: [1] [2] [4] [6] [9] [7] [8] [14]

Our interpretation

What the evidence does not show yet, and what to watch

No group has shown logical error rates near the 10⁻⁶ that Google's paper uses as its benchmark, nor the 10⁻⁶ to 10⁻⁸ range Quantinuum targets. As noted above, Google's distance-7 memory is about 1,430 times above 10⁻⁶ by our arithmetic. Quantinuum's per-cycle memory figure of 4.6×10⁻⁵ is about 46 times above 10⁻⁶ by the same arithmetic, but it uses a different code and measure, so the two should not be ranked against each other. No one has shown many logical qubits, each below threshold, running long sequences of gates with every run kept.

Other pieces are also missing. Fault-tolerant non-Clifford gates at useful scale have not been shown; the magic-state and teleportation results above are early steps. Real-time decoding at the speed and size of a large machine has not been shown, and Google's rare correlated errors show that new failure modes can appear at scale. IBM's qLDPC codes have not been shown in hardware in any document we opened. Google's own projection of 1,457 physical qubits for one logical qubit at 10⁻⁶ shows why physical counts will keep rising long before logical counts do.

Some signals can be checked on a calendar. IBM's roadmap places Kookaburra, its first qLDPC memory module, in 2026. Whether IBM publishes measured logical error data from it by 31 December 2026 is a direct test of that target, as is Starling in 2029. The Quantinuum Helix preprint was posted on 2 September 2026, and its progress through peer review, including whether the figure without discarded runs holds, can be followed on arXiv and in journals. As of 14 October 2026, arXiv lists no journal reference for the Microsoft–Quantinuum and Microsoft–Atom Computing preprints.

Further signals would be a surface-code memory beyond distance 7, logical gates between below-threshold logical qubits rather than single memories, and neutral-atom results over many more than four rounds. For readers following the businesses, the useful habit is to match each company claim to one of these specific results and to its conditions. None of this says anything about share prices.

Sources: [1] [14] [10] [7] [8] [5]

Background

Evidence date and disclosure

Every source was opened on 2026-10-14, and the piece was checked against those sources before publication. Company statements are the companies' own claims; percentages and comparisons are this publication's arithmetic from the cited figures. The publisher may hold positions in companies covered; see Disclosures.

Sources: [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]