Quantinuum's Helios cuts logical errors 12-fold per step in code distance

Quantinuum reports that a logical qubit on its Helios trapped-ion computer fails about five times in a million error-correction rounds. That is at the largest code it could fit, distance 7. According to the team's preprint, logical error rates were 5.5×10⁻⁴, 3.8×10⁻⁵ and 5×10⁻⁶ per syndrome extraction cycle at distances 3, 5 and 7. The authors fit this to a suppression factor of Λ = 12. The headline number matters less than the slope. Each increase in code distance removed roughly an order of magnitude of the remaining error, which is the behavior fault-tolerant roadmaps assume.

The work is a preprint, not a peer-reviewed paper. It was not peer reviewed when announced and was posted as a PDF on Quantinuum's website. It is also a company result, and a memory experiment rather than a computation. The caveats are covered below.

01What "beyond breakeven" means

A logical qubit spreads one qubit of information across many hardware qubits. Some hold data, and others are measured repeatedly to produce syndrome data. Syndrome extraction is a round of repeated parity checks that detect errors. A decoder then infers which errors probably occurred.

Adding qubits is a trade. A larger code can catch more simultaneous faults, but it also has more components that can fail. Ars Technica puts the consequence plainly: if hardware error rates are too high, growing the logical qubit makes things worse. The term "breakeven" has two uses:

• Logical versus physical. An encoded operation beats the same operation on an unencoded physical qubit. Quantinuum's March 2026 work on 94 error-detected logical qubits used this sense. Encoded operations there produced fewer errors than unencoded ones on the same task.
• Scaling with distance. Each step up in code distance lowers the logical error rate. The fitted ratio per step, Λ, measures how far below threshold the hardware sits.

The second sense is the one that sets cost. The expected logical error scales roughly as Λ to the power of (d+1)/2, up to a prefactor. A 1,000-fold reduction therefore takes about ten distance steps at Λ = 2 and about three at Λ = 12. These are my arithmetic, not figures from the paper. Ars notes that most earlier below-threshold demonstrations saw error rates drop by something much closer to two than 10. At that rate, the number of hardware qubits per logical qubit grows impractically large.

02The experiment

Helios is a 98-qubit machine. It is a trapped-ion computer. Ions are shuttled around a ring and into two arms, where lasers act on them. Because any two ions can be brought together, Ars says the machine can host essentially any error-correcting code. The team used triangular color codes. Including measurement qubits, the distance 3, 5 and 7 codes need 13, 37 and 73 physical qubits.

Each run used 20 rounds of correction before the final readout. Single rounds fail too rarely to measure. The distance-7 figure rests on thin statistics: three logical failures in 29,000 runs of 20 rounds, with a one-sigma range of 3×10⁻⁶ to 9×10⁻⁶. To keep the total qubit count comparable across codes, six distance-3 memories and two distance-5 memories ran in parallel.

The headline Λ = 12 is a fit, and the individual steps differ. The ratios between adjacent measurements are about 14.5 (distance 3 to 5) and about 7.6 (distance 5 to 7), from the reported rates. The fit carries an uncertainty of +3 and −2. A clean exponential is consistent with the data, but three points and three distance-7 failures cannot exclude some flattening at larger sizes.

03Leakage control and decoding

The authors identify leakage as a main obstacle. It happens when an ion leaves the two states used for computation. Helios now applies an optical repump that returns leaked barium-137 ions to the computational subspace in parallel with ground-state cooling. This gives 6.5× leakage suppression per cycle with no added circuit runtime. A software scheme also swaps leaked data qubits for measurement qubits, which can then be reset. In smaller tests, the hardware repump cut memory error rates fourfold at distance three and eightfold at distance five relative to circuit-level leakage reduction alone. The gain grows with distance, which is why leakage matters for Λ.

Decoding is the part not yet shown live. The team tested a streaming version of the Frontier decoder and two neural-network decoders. The neural decoders were trained only on data from a Helios emulator. They processed each round in 0.22 to 0.52 milliseconds on an NVIDIA H100 GPU. But in the memory experiment, researchers decoded measurements after the runs. A complete circuit with live decoding remains to be tested. The timing was also measured on recorded data, so it excludes communication with the quantum device and feedback delays.

04Gates, comparisons and what remains unproven

Memory is the easy case. Quantinuum also benchmarked logical gates, running random two-qubit Clifford sequences on encoded pairs. The error per logical gate was 7×10⁻⁴ with distance-3 codes and 7×10⁻⁵ with distance-5 codes, against 9.5×10⁻⁴ for the same circuits on unencoded qubits. The company quotes an average gate suppression factor of 9. Distance-7 gates were not evaluated because Helios lacks enough physical qubits.

The company's comparisons come with caveats:

• It says the previous best color-code result, at distance 5, was 0.819% per cycle.
• At equal distance, the prior best was a surface code. It reached 0.0772% per cycle at distance 7. Quantinuum calls its own result a 154× improvement.
• The press release says the result is 100 times lower than the best published result on other hardware, from Google Quantum AI on a superconducting system.

These are per-round numbers from different codes and platforms. Trapped-ion rounds are far slower in wall-clock time than superconducting ones. One secondary report puts a Helios round at about a fifth of a second. That timing was not confirmed in the primary material I could access. Per-round error therefore does not translate directly into error per unit of computation time.

For roadmaps, the question is how far Λ = 12 extends. Quantinuum links the result to Apollo, its planned fault-tolerant machine. Its accuracy is now within the target range for Apollo, which the company plans to make available in 2029. The company's release says a scaled-up version could reach useful reliability at a feasible size, less than a million physical qubits. Craig Gidney of Google Quantum AI reportedly estimated from the scaling that practical error rates would be reached at a code distance of about 21. That figure is an informal estimate, not a result from the paper.

The authors list unmet milestones. One is below-threshold scaling of high-fidelity color-code magic-state preparation. Magic states are needed for universal computation. The others are fast live decoding, logical gates at distance 7 and beyond, and machines with far more than 98 qubits. The experiment shows that on this hardware, below-threshold scaling is steep rather than marginal. That reduces one major risk, but the step from a protected memory to a protected algorithm remains to be demonstrated.