Hadamard Get the app

Quantinuum’s 99.9995% Logical Fidelity: What the Record Measures

Quantinuum's 99.9995% Logical Fidelity: What the Record Measures — Hadamard

Quantinuum’s 99.9995% logical fidelity record means that a distance-7 color code on its Helios trapped-ion computer kept stored quantum information intact with about five logical errors per million error-correction cycles. It is a quantum memory result. It does not tell you how accurately Helios runs a full algorithm. The headline “10x” and “100x vs Google” figures are Quantinuum’s own framing of comparisons that are not like-for-like.

This article explains what was measured, how the numbers compare with Quantinuum’s September Helix result and Google’s Willow, and what the result means for the company’s 2029 fault-tolerance target. It also covers what it does not mean for RSA and Bitcoin.

What Quantinuum announced on October 19, 2026

On October 19, 2026, Quantinuum announced 99.9995% logical fidelity on its commercial Helios system, which it describes as about five errors per million operations. The company says this is 10x lower than its own record from the previous month. It also says it is 100x lower than the best published result on any other hardware, which is Google Quantum AI’s superconducting work.

The experiment used a color code. According to the press release, each increase in code distance cut logical errors by a factor of about 12, and Quantinuum says this puts its accuracy within the target range for Apollo, its planned fault-tolerant machine. Robin Blume-Kohout of Sandia National Laboratories, who was not involved, called it a significant milestone that researchers have worked toward for many years. His was the only independent comment in the coverage we reviewed.

The technical details are in a preprint, “Quantum error correction well below the color code threshold” (arXiv:2610.24077). It reports memory experiments and logical two-qubit Clifford randomized benchmarking with triangular color codes at distances 3, 5 and 7 on Helios-1. The paper had not been peer reviewed when the result was announced.

What does Quantinuum’s 99.9995% logical fidelity actually measure?

A physical qubit is a single trapped ion, and errors build up in it with every operation. A logical qubit spreads one unit of quantum information across many physical qubits. The system repeatedly measures “syndromes,” which reveal errors without destroying the encoded state, and a decoder works out which corrections to apply. Each round of syndrome measurement is called a cycle.

According to the PostQuantum analysis of the preprint, 99.9995% is the memory fidelity per syndrome-extraction cycle at distance 7. It is the probability that the stored logical state survives one round of error correction. That gives three important qualifications:

  • It is not an algorithm success rate. A real computation runs many cycles and many logical gates, so errors add up across all of them.
  • It is not a gate fidelity. The logical two-qubit Clifford gates had a separate suppression factor of about 9, with wide error bars (+8/−4).
  • It rests on few events. The distance-7 figure comes from 3 logical failures in 29,000 runs of 20 rounds each. The 1σ range runs from 3×10⁻⁶ to 9×10⁻⁶, so “five per million” is a central estimate, not a precise value.

The physical hardware underneath is strong to begin with. When Helios launched commercially in November 2025, Quantum Computing Report listed 98 physical qubits with all-to-all connectivity, 99.9975% single-qubit gate fidelity, 99.921% two-qubit fidelity across all pairs and 99.967% state preparation and measurement fidelity. Sandia and Quantinuum published those benchmarks in Nature.

The color code on Helios: distances 3, 5 and 7, below threshold

Code distance is roughly the number of physical errors needed to corrupt the logical state without the decoder noticing. When physical error rates are below a code’s threshold, increasing the distance should make logical errors fall exponentially. The ratio between successive distances is called Λ (lambda). A higher Λ means each step up in code size is worth more.

These are the per-round logical memory errors reported in the PostQuantum breakdown, which match InElectronics’ coverage:

Code distance Logical error per round Equivalent fidelity per round
d = 3 5.5×10⁻⁴ about 99.945%
d = 5 3.8×10⁻⁵ about 99.996%
d = 7 5×10⁻⁶ about 99.9995%

The reported fitted suppression factor is Λ ≈ 12. A clean drop across three distances is the main evidence that Helios is operating “well below” the color code threshold, as the paper title says. It matters more than any single fidelity number, because it shows that adding qubits is reducing errors rather than adding new ones.

The trade-off: up to 37 physical qubits per logical qubit

Color codes have useful properties for fault tolerance. They allow certain logical operations to be applied transversally, meaning qubit by qubit across the code block. The cost is overhead. Coverage including TFTC notes that the color code uses up to 37 physical qubits per logical qubit. The Helix code used in September uses about 10.

That is a real trade-off for a 98-qubit machine. Earlier Helios demonstrations favored density, with 94 error-detected logical qubits in a GHZ state and 48 error-corrected logical qubits at a 2:1 encoding rate, according to The Quantum Insider. The October result goes the other way: much lower error per logical qubit in exchange for far fewer of them.

Is it really 10x better than Helix and 100x better than Google Willow?

The “10x” claim

The September baseline was the Helix code on Helios. Quantum Computing Report reported a logical memory error of 4.6×10⁻⁵ per logical qubit per cycle over 20 rounds. With 0.5% decoder postselection it was 1.9×10⁻⁵. Quantinuum also described that work on its blog post on real-time error correction at increased scale.

Compared with the non-postselected Helix figure, 5×10⁻⁶ is roughly a 9x improvement. Compared with the postselected figure, it is closer to 4x. Outlets describe the two metrics slightly differently, so “10x” is best read as Quantinuum’s framing. It is not an exact ratio of identical measurements. The improvement also comes from a code that uses more than three times as many physical qubits per logical qubit.

The “100x vs Google” claim

Google’s Willow benchmark, posted in August 2024 and later published in Nature, used a 101-qubit distance-7 surface code. It reported a logical error of 0.143% ± 0.003% per cycle and Λ = 2.14 ± 0.02, with a logical lifetime 2.4x longer than its best physical qubit. Dividing 1.43×10⁻³ by 5×10⁻⁶ gives a raw ratio near 290, which is larger than the 100x Quantinuum claims. That gap is a reminder that these numbers do not measure the same thing in the same way:

  • Different codes. A surface code and a color code at the same distance use different numbers of qubits and have different thresholds.
  • Different clocks. Willow ran a 1.1 µs cycle, with 63 µs average decoder latency at distance 5. Trapped-ion cycles are much slower. Error per cycle leaves out how much wall-clock time a computation takes, and that matters for useful algorithms.
  • Different eras. Willow’s result is from 2024. Google has published further work since, including the logical-gate results covered in our explainer on magic state cultivation and Google’s 40x Willow result.
  • Different failure modes. Google reported that its repetition codes were limited by rare correlated errors, roughly once an hour or about every 3×10⁹ cycles. Twenty-round experiments cannot detect rare events like that.

The fairest comparison is Λ: about 12 on Helios against 2.14 on Willow. That gap shows how much more each step in code distance gains on Helios. It still does not say which platform will reach a useful fault-tolerant computation first.

From Helios to Sol (2027) and Apollo (2029)

Quantinuum presents the result as evidence for its roadmap. On its August 2026 earnings call, the company said:

  1. Sol is a 192-physical-qubit system targeted for the second half of 2027. Its first production-candidate 2D QCCD traps are back from fabrication and being validated.
  2. Apollo is a universal, fully fault-tolerant machine planned for 2029, with its design described as essentially complete.
  3. Lumos is the follow-on system for the 2030s.

These are company statements, not delivered hardware. NAND Research’s analysis of the earnings and Quantinuum’s own post on its path to 2029 give more context. The October result supports one claim on that path: logical error rates in the range Apollo needs are reachable on current hardware. It does not show that the architecture scales to many logical qubits running deep circuits, or that fault-tolerant non-Clifford gates work at scale. Universal computation requires both.

Does this bring Q-Day closer for RSA and Bitcoin?

Not directly. This was a memory and Clifford-gate experiment on a handful of logical qubits. It does not change published estimates of how many logical qubits, non-Clifford operations and how much runtime are needed to break RSA or elliptic-curve cryptography. As The Qubit Report put it when weighing whether the announcement was substance or “chest-puffing,” the milestone is real, but it is one step on a long path.

It does add evidence that error correction is improving faster than in the past. That is the main reason migration planning should not wait for a definite date. For specifics, see our guides to which Bitcoin addresses are vulnerable to quantum computers and whether quantum computers can break Ethereum.

Hadamard builds BB84 with that timeline in mind. It is a hash-based Ethereum Layer 2 that does not use ECDSA. Accounts are one-time addresses based on hash commitments, so they do not depend on elliptic-curve keys that a future fault-tolerant machine could attack.

FAQ

What does 99.9995% logical fidelity mean, and is the computer 99.9995% accurate?

No. It is the probability that a distance-7 logical qubit stored in memory survives one error-correction cycle without a logical error. Full computations involve many cycles and gates, and logical gate performance was measured separately with wider uncertainty.

Is Quantinuum’s result really 100x better than Google’s Willow?

The 100x figure is Quantinuum’s claim. The raw per-cycle numbers give a larger ratio, but the codes, cycle times and dates differ, and the per-cycle metric ignores wall-clock speed. The error-suppression factor (about 12 against 2.14) is a fairer, though still imperfect, comparison.

Why use a color code instead of a surface code, and what does it cost?

Color codes support certain logical operations transversally, which is useful for fault-tolerant computation. The cost is overhead: up to 37 physical qubits per logical qubit in this experiment, against about 10 for the Helix code Quantinuum used in September.

Does this bring Q-Day for RSA and Bitcoin closer?

It does not change the resources needed to break RSA or ECC, and it does not demonstrate large-scale fault-tolerant computation. It is evidence that error correction is maturing, which supports migrating to post-quantum cryptography early.

Sources