Quantinuum ran a trapped-ion code below threshold. Its best number is 3 failures in 29,000 tries

On Quantinuum's Helios-1 ion-trap chip, three sizes of the same color code (13, 37 and 73 qubits) showed the logical error rate falling as the code grew, the pattern a code needs to be worth using. All the decoding in this work was done after the experiment, not in real time, and no magic states or logic gates beyond memory and two-qubit Cliffords were shown.

Research desk Quantinuum, company preprint Read on 19 October 2026

A line chart of logical error rate against code distance 3, 5 and 7 on a log scale, falling from about 5.5 in 10,000 to 3.8 in 100,000 to 5 in a million, with a shaded band at distance 7 showing the wide uncertainty from only 3 observed failures in 29,000 tries, and a side panel of the two-qubit Clifford gate error falling from 9.5 in 10,000 unencoded to 7 in 100,000 at distance 5. — Both curves are the paper's own Table I and Figure 5 numbers. The shaded band at distance 7 is our way of drawing its stated uncertainty.

Why "below threshold" is the number that matters

Error correction only pays for itself past a line called the threshold. Above it, a bigger code has more pieces that can go wrong, so growing the code makes things worse. Below it, a bigger code suppresses errors faster than it adds them, so growing the code makes things better, and keeps making things better the larger it grows. Showing that a real machine sits on the right side of that line, and stays there as the code grows, is the first condition for error correction ever being worth the qubits it costs.

On 19 October 2026 Quantinuum released a preprint, Quantum error correction well below the color code threshold, by 23 researchers at the company's Broomfield, Colorado and London sites. We read the preprint in full.

What the preprint reports

The team ran a triangular color code, a pattern of stabilizer checks on a honeycomb-like lattice, at three sizes on Quantinuum's Helios-1 trapped-ion processor: distance 3 (13 qubits), distance 5 (37 qubits) and distance 7 (73 qubits). For each size they prepared a logical qubit, ran 20 rounds of error-checking, and measured how often the logical state came out wrong.

The logical error rate per round fell as the code grew:

Distance 3: 5.5 in 10,000 per round (178 failures in 15,840 shots).
Distance 5: 3.8 in 100,000 per round (17 failures in 21,600 shots).
Distance 7: about 5 in a million per round (3 failures in 29,000 shots).

That is the "99.9995%" the company's press release leads with: one minus the distance-7 error rate. Each step up in size cut the error rate by a factor the paper calls Λ (lambda), fitted at 12, with a wide uncertainty (12, +3/−2) because so few failures were seen at distance 7. They also ran two-qubit Clifford gates inside the distance-3 and distance-5 codes, with error 7 in 10,000 and 7 in 100,000, against 9.5 in 10,000 for the same gate run unencoded, a suppression factor of about 9.

Two engineering fixes made this possible. Leakage, where a qubit's state slips outside the two levels a computer uses, was repumped back by a hardware routine that cut it 6.5 times every three cycles, improving the logical error rate 4 times at distance 3 and 8 times at distance 5. The syndrome checks themselves ran on a "SWAP-superdense" circuit built for Helios's all-to-all ion connectivity. The team also tried two neural-network decoders trained on simulated data and found they ran fast enough, a few hundred microseconds per round, for real-time use, though this experiment's own decoding was done afterward, offline.

In plain words

Imagine a relay team where each runner has a small chance of dropping the baton. Add more runners checking each handoff and you would expect more chances for something to go wrong, unless each checker is reliable enough that extra checking catches more mistakes than it creates. Quantinuum built three relay teams of growing size and timed them: the bigger team, with more checkers, dropped the baton less often, not more. That is the whole result. It says nothing yet about how fast the team runs, or whether it can do anything besides hold the baton still.

What this does not show

The headline number is a 3-event sample. The distance-7 result, 5 in a million per round, comes from 3 observed failures in 29,000 attempts. The paper's own uncertainty on that number spans roughly 3 in a million to 9 in a million.
Decoding was offline. All the results in this preprint were decoded after the experiment finished. The paper shows that fast decoders exist and could run in real time, but none of them ran in real time here.
No magic states, no T gates. The paper's own discussion says a general computation needs magic-state preparation inside the code, which this work does not attempt; only memory and two-qubit Clifford gates were tested.
It has not been peer-reviewed. This is a company preprint, not yet reviewed or published in a journal, and no outside lab has reproduced it.
Bigger means more qubits, not fewer. The best logical error rate used 73 physical qubits to protect one logical qubit; this is a demonstration of scaling behavior, not of a low-overhead code.

Why a reader of this site should care

Most error-correction news on this desk is either a small code on real hardware or a bigger claim in simulation. This is the real-hardware kind, and it is the specific thing fault tolerance depends on: not a single good number, but a trend, three points in a row, each one better than the last as the code grows. That trend is also the hardest thing to fake with cherry-picked settings, because it has to hold at every size tested. The honest caveats are the ones above: a thin sample at the top end, and a result that stops well short of a working computation. Compare it with the simulated, much larger savings in our note on Google's modular codes, which point in the opposite direction, toward fewer qubits per logical qubit rather than more reliable ones.

Sources

We read the sources above ourselves. Where a figure or number is ours, the article says so. If you find a mistake, tell us: a wrong sentence here gets logged like any other.