Thanks to quantum error correction, logical qubits can now beat the physical qubits underneath them on small circuits, and a Nature paper from Microsoft Quantum and Quantinuum puts numbers on it. The headline is an 11-fold to 800-fold drop in logical error rate on a trapped-ion machine. The fine print matters, though, because the biggest gains depend on throwing away runs that look corrupted.

That distinction is the whole story. Below is what the team ran, what the figures do and do not show, and why quantum error correction researchers treat post-selection as a stepping stone rather than a finish line.

What the paper reports

The paper, “Improved quantum processor logical error rates via correction and detection,” appeared online in Nature on 10 June 2026 (volume 654, pages 349-355). It has 37 authors from Microsoft Quantum and Quantinuum, with K. M. Svore as corresponding author. The editorial record lists receipt in February 2025 and acceptance in May 2026, so this was a long review. The experiments ran on Quantinuum hardware, a trapped-ion device built around a quantum charge-coupled device (QCCD) architecture, with Microsoft supplying the error-correction software layer.

The authors compare logical circuits against several physical baselines, meaning the same task run on bare, unprotected qubits. Across those comparisons they report logical error rates 11 to 800 times lower. They argue that present hardware is already good enough for fault-tolerance techniques to help on non-trivial circuits, not only on idle memory.

The two codes, in plain terms

An error-correcting code spreads one fragile quantum state over many physical qubits so that individual faults can be spotted without reading out the data itself. The team used two codes.

  • A 12-qubit code inspired by earlier work from Knill, encoding 2 logical qubits. Coverage of the paper calls it the “carbon code.”
  • A 16-qubit tesseract color code, a four-dimensional color-code construction, encoding 4 logical qubits.

Both are small. The encoding ratio is what a hardware team watches: 12 physical qubits for 2 logical ones, or 16 for 4, keeps overhead low. The trade is that codes this compact lean on detecting errors more than correcting them, and that shapes the headline numbers.

The numbers, side by side

Figures below come from the Microsoft Quantum announcement and trade coverage of the paper; the Nature page itself carries only the 11x to 800x range in its abstract, and the full text is paywalled.

Experiment Reported result
Bell-state preparation, 12-qubit code Error from about 0.8% (physical) to about 0.001% logical, the 800x case
Repeated correction rounds About 51x lower error per round than the physical baseline
12-qubit entangled (cat/GHZ) state 22x suppression
Largest circuits Up to 12 logical qubits in parallel

One trade publication adds finer detail, such as the Bell-state run showing no errors in more than 15,000 accepted trials. Treat that as secondhand until you have read the paper.

Why post-selection is the caveat to read first

Post-selection means running the circuit, checking the error-detection measurements, and discarding any run where something looks wrong. The surviving runs are cleaner by construction. The abstract states plainly that the codes are combined with “a scalable method of error detection and post-selection.”

So the 800x figure is real, but it describes the accepted runs. A deployed machine cannot simply discard half its computation and call the answer reliable; for a long algorithm the acceptance rate would collapse. Reporting says the authors point to alternatives, such as passing error information up to higher layers of encoding, and treat real-time decoding and feed-forward (adjusting the circuit mid-run based on measured errors) as future work. Syndrome interpretation in this experiment was done after the fact.

The headline also depends on the baseline. An 800x gain over a 0.8% error rate is a different claim from an 800x gain over the best two-qubit gate the machine can do. The paper compares against several baselines for exactly that reason, and the spread from 11x to 800x reflects how favorable each comparison is.

Detection versus correction, and why the difference matters

The paper’s title pairs the two words on purpose. Correction means the decoder identifies which fault occurred and repairs it, so the computation continues. Detection means the code notices that something went wrong but cannot say what, so the only safe move is to throw the run away. As a general rule, a small code can flag more faults than it can repair, because telling apart many possible error patterns takes more redundancy than simply noticing one occurred.

That is why the experiment mixes both modes. Where the code can correct, it does. Where it can only flag, post-selection takes over. The practical question for the field is how much of the gain survives once the discard step is replaced by something a long-running machine can afford.

How to read a logical error rate

A logical error rate is only meaningful next to the thing it is compared with. Three habits help when reading any announcement of this kind.

  • Ask what the baseline is. A bare physical qubit sitting idle is easier to beat than a physical circuit that has been optimized for the same task.
  • Ask what was discarded. An acceptance rate below 100% changes what the number means for a real workload.
  • Ask what the circuit does. A Bell-state preparation is a short circuit with one entangling step; a twelve-qubit entangled state is a longer one. Gains on one do not automatically transfer to the other.

By these tests the paper does reasonably well: it reports several baselines, it states the post-selection in its abstract, and it includes repeated rounds rather than a single shot. The weak spot, noted by the trade coverage, is that absolute logical error rates for the larger circuits are not given in the summaries available to us.

Why repeated rounds count

Early logical-qubit experiments often encoded a state, waited, and decoded it. Real computations need correction in the middle, between gates, so that errors do not pile up. The reported result for the 12-qubit code is up to ten rounds of correction, with a per-round error far below the physical baseline according to The Quantum Insider’s account. The authors say this is the first demonstration they know of where correction during a computation helps rather than hurts. That claim is theirs, and it is the kind of statement independent groups will test.

What limits the hardware

According to the trade coverage, the dominant noise source in the processor was dephasing caused by moving ions around the chip, which is the price of the QCCD design. The team reportedly reduced it with compiler optimizations and dynamical decoupling, a technique that applies pulse sequences to cancel slow noise. If that account is right, the next improvements may come from cleaner shuttling rather than from bigger codes.

It is also worth being clear about scale. Twelve logical qubits on carefully chosen circuits is a long way from the millions of operations that chemistry or cryptography workloads would need. Nobody involved claims otherwise; Microsoft describes a 50-logical-qubit platform with Atom Computing as upcoming, and that work is not part of the validated results.

How this fits the wider field

Logical-qubit demonstrations now come from several hardware families. In January 2024, Harvard, MIT and QuEra reported a neutral-atom processor with up to 48 logical qubits and as many as 228 two-qubit logic gates, published in Nature. That experiment emphasized scale and reconfigurable atom arrays. The Microsoft and Quantinuum paper emphasizes the opposite corner: fewer logical qubits, but measured error suppression against explicit physical baselines, including repeated correction mid-circuit.

The two approaches are complementary rather than rival scoreboards. For a related claim that needed the same kind of careful reading, see our claim check on Quantinuum’s non-Abelian anyon result.

Why a skeptic should still care

It is easy to wave off a result that relies on discarding data. That would be a mistake here. Until recently, the open question was whether encoding qubits helped at all on real devices once the extra gates needed to run the code were counted, since each added gate is another chance for a fault. A result in which the protected circuit beats the unprotected one, on several baselines and in a peer-reviewed venue, answers that question for this regime. The remaining questions are about cost and scale, which are engineering problems rather than doubts about whether the approach works.

For readers following the field, the useful habit is to hold two statements at once: the improvement is genuine, and it is not yet the fault-tolerant machine that the term usually implies.

What to watch next

  1. Real-time decoding with feed-forward, so that no runs need discarding.
  2. Logical error rates for the larger circuits reported as absolute numbers, not just ratios.
  3. Whether the same gains hold when the circuit depth grows well beyond a few correction rounds.
  4. Independent replication on other hardware, since the paper’s data and circuits are available on request.

Microsoft also released an open-source error-correction package called deq inside its Quantum Development Kit, which lets outside groups test decoding ideas against this style of experiment.

Sources