OrbitalHub

A quantum computer’s problem is not speed. It is that a qubit is a poor place to keep information. Every gate carries a chance of flipping, rotating or leaking the state it touches, and a useful algorithm might ask for a million gates in a row. The field measures progress in operations without error, not operations per second: a “megaquop” is a run of more than a million quantum operations in which the machine is right every time. On 19 October 2026, Quantinuum reported that its Helios trapped-ion processor had come within a factor of five of that bar, with a logical error rate of five per million operations (Quantinuum, 19 October 2026). Underneath that number sat a harder claim: each time the team built a bigger error-correcting code, the failure rate fell by about twelve.

The obstacle is that you cannot check a quantum state the way you check a classical bit. Measuring it destroys it, so copying information for safekeeping is not available. The 1990s answer was to encode one logical qubit across many physical qubits and measure special combinations of them, called stabilizers, whose values stay predictable unless something has gone wrong. When a stabilizer reads oddly, the pattern of oddities says which physical qubit misbehaved and how, and a classical decoder works backward to undo the most likely error chain. Redundancy cuts both ways: encoding a qubit this way manufactures fresh opportunities for failure, so protection can cost more than it saves. The threshold theorem says there is a critical physical error rate p_th below which adding protection wins, and for topological codes the payoff is exponential: p_L ∝ (p/p_th)^((d+1)/2), where d is the code distance, a rough count of how many simultaneous errors a logical qubit survives. What decides whether this is useful is Λ ≡ p_th/p, the suppression factor.

For most of the field’s history the honest answer to “what is Λ?” was “a bit above two.” Google Quantum AI’s surface-code work on the Willow processors put a distance-7 code below threshold with Λ above two, and simulation of the same setup returned Λ = 2.25 (Google Quantum AI, Nature, 2024). But a factor of two is a shallow slope, and distance is expensive: a surface code of distance d consumes 2d²−1 physical qubits. Before Willow, no processor had definitively demonstrated below-threshold performance at all.

What Quantinuum announced changes the shape of that arithmetic. The technical details appeared on 16 October 2026 as a preprint titled “Quantum error correction well below the color code threshold” (Lavasani et al., arXiv:2610.24077). The code is a triangular color code: a self-dual CSS topological code on a honeycomb tiling of an equilateral triangular surface, with qubits on the vertices and each face carrying both an XX-type and a ZZ-type stabilizer generator. Its block parameters, [[(3d²+1)/4, 1, d]], mean a distance-3 block needs 13 physical qubits, distance 5 needs 37, distance 7 needs 73.

The code and the hardware fit each other. A color code is self-dual, so the logical Hadamard and phase gates are transversal: the same operation applied to every physical qubit lands exactly on the encoded qubit. Because it is a CSS code, and trapped-ion hardware can connect any pair of ions on demand, the logical CNOT is transversal too, putting the whole Clifford group within reach without the lattice-surgery machinery other code families require.

The measurements were taken on Helios, which holds 98 trapped barium-137 ions. The team ran memory experiments at distances 3, 5 and 7, fitting six, two and one blocks into each shot to keep the qubit count roughly constant. Each shot ran twenty rounds of stabilizer measurements before a logical readout. The per-round failure rate came out at 5.5e-4 for distance 3, 3.8e-5 for distance 5 and 5e-6 for distance 7, with a fitted suppression factor of Λ = 12. The logical two-qubit Clifford error fell from 7e-4 at distance 3 to 7e-5 at distance 5, a suppression factor of 9.

In September, the company had demonstrated the Helix code, reaching a per-qubit memory error of 4.6e-5 per round with no post-selection (Quantinuum, September 2026). Helix spends 10 physical qubits per logical qubit but has a shallower slope; the color code spends up to 37 and has a steeper one. Robin Blume-Kohout, co-director of the quantum performance lab at Sandia National Laboratories and uninvolved in the work, read the result differently: a logical qubit nearly a hundred times better than the physical qubits it is made of. In his words, it goes a long way to “retire one of the field’s central technical risks” (Quantinuum, 19 October 2026).

The hard part was leakage. A barium ion’s qubit lives in a pair of hyperfine levels, and six nearby levels offer somewhere else to go. Leaked population stays there until a mid-circuit reset, and meanwhile a gate acting on a leaked qubit spreads the problem to its neighbours, so one leak can cascade into a logical failure.

The hardware fix is a mid-circuit repump scheme. Narrow-linewidth, state-selective optical transitions move leaked population into three 2D5/2 states, then drive it up to 2P3/2, which decays mostly back to the 2S1/2 ground state. Each cycle returns nearly half of what is left, so leakage falls geometrically; three cycles measured a suppression of 6.5×. The cost is worth admiring: the repump adds no gate and no time to the circuit, because the optical pumping runs in parallel with ground-state cooling and ion transport during qubit sorting. On its own it cut the observed logical error rate by 4× at distance 3 and 8× at distance 5.

The circuit fix rebuilds the stabilizer measurement as a SWAP-based leakage-reduction unit the team calls SWAP-superdense. Data qubits are swapped out for fresh ancillas before each measurement, so a qubit that has leaked gets measured and reset instead of poisoning its neighbours. The trap’s all-to-all connectivity turns the swap into a software-level relabeling of qubits, which also shortens the syndrome-extraction depth by one.

Then there is the decoder, which has to keep pace with the machine in real time. Tesseract, the team’s primary decoder, finds the most likely error chain and comes close to optimal, but it is too slow to run while the hardware is still going. So they trained two neural decoders, a three-dimensional convolutional network and a round-token transformer that encodes each round of syndrome data as a token, on data from an emulator of Helios alone, then applied them to the hardware without fine-tuning, with comparable performance. Their inference latency runs to a few hundred microseconds, an order of magnitude faster than the syndrome extraction rate (Lavasani et al., 2026). A decoder that cannot keep up is a decoder that cannot be used.

What remains is mostly engineering, which is the good kind of remaining. A distance-7 block already consumes 73 of the machine’s 98 ions, so the next step is a bigger trap. A universal machine still has to run the T gate, which the color code cannot do transversally and which arrives instead through magic-state injection, demonstrated with the same code in 2025. The arithmetic that worried people for a decade, the question of how many physical qubits it takes to hold one good logical qubit, now looks tractable in a way it did not a month ago. The slope got steeper by a factor of twelve while the hardware underneath it did not change at all. The machine is the same 98 ions it was in September; what changed is the code wrapped around it, and the code is the part engineers can keep improving.