Quantinuum Reports Record Error Suppression on Helios, at About a Fifth of a Second per Correction Round

19 Oct 2026 – Quantinuum said its Helios computer, a 98-qubit trapped-ion machine, held an error-corrected logical qubit at an error rate of $$5 \times 10^{-6}$$ per round of error correction, a result the company described as a world record. It announced the result in a press release and a technical blog post, with the details in a 22-page preprint, “Quantum error correction well below the color code threshold”, by 23 researchers at Quantinuum’s sites in Broomfield, Colorado, and London.

The team encoded one logical qubit in triangular color codes of distance 3, 5 and 7, then protected it through 20 rounds of syndrome extraction, the repeated parity checks that detect errors. With measurement qubits included, the three codes need 13, 37 and 73 physical qubits. Across the three Quantinuum color code experiments, the logical error rate per round fell from $$5.5 \times 10^{-4}$$ at distance 3 to $$3.8 \times 10^{-5}$$ at distance 5 and $$5 \times 10^{-6}$$ at distance 7. The authors fitted a suppression factor, Λ, of 12. Λ is the number by which logical errors are divided for each increase of two in code distance.

The distance-7 figure is based on three logical failures in 29,000 runs of 20 rounds each, with a one-sigma range of $$3 \times 10^{-6}$$ to $$9 \times 10^{-6}$$. The paper had not been peer reviewed at the time of the announcement and was available as a PDF on Quantinuum’s website.

The researchers also benchmarked logical gates, running random sequences of two-qubit Clifford gates on pairs of encoded qubits. The error per logical two-qubit Clifford gate was $$7 \times 10^{-4}$$ with distance-3 codes and $$7 \times 10^{-5}$$ with distance-5 codes, against $$9.5 \times 10^{-4}$$ for the same circuits on unencoded physical qubits. From the two encoded distances, the authors fitted a Λ of 9, with an uncertainty of +8 and −4. Distance-7 gate experiments need more qubits than Helios has, the authors wrote.

Unencoded two-qubit Clifford error on the same hardware: $$9.5 \times 10^{-4}$$. Memory error rates are given with one-sigma Wilson intervals, gate errors and Λ with one-sigma fit uncertainties. Memory figures are for the Tesseract decoder. Preprint, Table I and Figure 5.

The authors credit two measures against leakage for the scaling. Leakage happens when a barium-137 ion leaves the two energy levels that encode the qubit for one of six other levels. Quantinuum added a mid-circuit leakage repump to Helios, a sequence of laser pulses that pumps leaked ions back into the qubit levels during ground-state cooling. The team paired it with a syndrome-extraction circuit that regularly swaps each data qubit with a freshly reset measurement qubit.

According to the paper, three repump cycles cut the leaked population 6.5-fold and added no time to circuits. The repump lowered logical error rates fourfold and eightfold at distances 3 and 5, respectively, compared with the swap circuit alone.

All decoding was done after the experiments had finished. The headline figures come from Tesseract, a search-based decoder published by researchers at Google Quantum AI, which the authors described as near-optimal but generally too slow for real-time use.

The team also tested a streaming version of the Frontier decoder and two neural-network decoders trained only on data from a Helios emulator. The neural decoders processed each round in 0.22 to 0.52 milliseconds on an NVIDIA H100 GPU.

Quantinuum said the logical memory error rate was 10 times lower than the record it set in September with its Helix code on the same machine, and 100 times lower than the best published result on other hardware, which it attributed to Google Quantum AI’s superconducting Willow processor. In its blog post, the company said that on these results an Apollo-scale machine could reach fault-tolerant quantum advantage with about 30 times fewer physical qubits than other leading approaches.

The company also said its accuracy is now within the target range for Apollo, the universal fault-tolerant computer it plans to make available in 2029. Chief executive Rajeeb Hazra said that with this result, Quantinuum had proven it has the error-correction architecture and trapped-ion technology needed for universal fault tolerance.

Robin Blume-Kohout, co-director of the Quantum Performance Laboratory at Sandia National Laboratories, who was not involved in the study, described the logical qubit as “nearly 100x better than its component physical qubits.” He said a scaled-up version could reach the reliability needed for useful fault-tolerant computation with fewer than a million physical qubits.

Craig Gidney, a quantum software engineer at Google Quantum AI, congratulated the team on X later that day. From the scaling, he estimated that practical error rates would be reached at a code distance of about 21. He also called a 20-millisecond cycle time “brutally slow,” then corrected the figure to 200 milliseconds.

My Analysis

The figure from this paper I would put in front of a board is the suppression factor, Λ = 12, ahead of the 99.9995%. From Λ and the starting error rate, an engineer can work out how many physical qubits each logical qubit needs. A machine’s cost and delivery date depend heavily on that number.

The 99.9995% is a measurement of one logical qubit, protected by one code, on today’s 98-qubit machine. In its blog, Quantinuum takes one failure in a trillion operations, $$10^{-12}$$, as the error rate for a utility-scale machine. If the error rate keeps falling by a factor of 12 at each step from $$5 \times 10^{-6}$$ per round at distance 7, it reaches $$10^{-12}$$ at distance 21. In this paper’s layout, a distance-21 color code needs 661 physical qubits per logical qubit, counting measurement qubits.

With a Λ of 2, close to Google’s 2024 surface-code result, a code starting from the same error rate would need distance 53, or 4,213 physical qubits per logical qubit in the same color-code layout, more than six times as many. In both calculations I held the suppression factor constant as the code grows. With three code sizes measured, nobody can yet tell whether it stays constant. I also used memory figures in both: the logical gates improved more slowly with distance, with a fitted Λ of 9 and wide error bars.

Quantinuum has shown the steepest error suppression I have seen reported in a distance-scaling experiment, on a machine that spends about a fifth of a second on each round of error correction, according to the paper’s own timing figure. On this evidence, a useful trapped-ion computer would need fewer qubits than a superconducting machine at Willow’s suppression factor. At today’s pace, it would run far more slowly: a round on Google’s Willow takes 1.1 microseconds.

None of the outlets I read on the first day reported how long a round takes on Helios. Craig Gidney was the only person I saw raise speed that day, in his posts on X. No outlet examined the Google baselines behind the hundredfold comparison or the blog’s thirtyfold qubit saving.

Where the 99.9995% figure comes from

The 99.9995% is a fidelity per round of error correction: one minus the estimated logical error per round of syndrome extraction. The team prepared one of six logical states, ran 20 rounds of checks and then measured the qubit, with no computation in between. It divided the failure rate by 20.5 rounds, the extra half round standing in for state preparation. The rate is pooled over the six states and comes from a single run length rather than a fit across several.

In its press release, Quantinuum translates the figure into five errors in a million operations; in its blog post, into a million operations with five uncorrectable errors. In both, one round of error checking counts as one operation. I raised the same issue with Helix in September: a correction cycle is not a standardized unit of useful computation. Per-round error is still the right quantity for comparing quantum memories, which is how the authors use it.

The paper’s computational figure is the logical gate error. At distance 5, the team measured an error of $$7 \times 10^{-5}$$ per logical two-qubit Clifford gate with randomized benchmarking, 14 times lower than for the same gates on bare physical qubits. At distance 3, the encoded gates, at $$7 \times 10^{-4}$$, were only slightly better than unencoded ones. Gates were not run at distance 7, where the headline memory figure comes from, because two 73-qubit code blocks do not fit on a 98-qubit machine.

Blume-Kohout described a logical qubit nearly 100 times better than its physical qubits. The authors publish no per-round memory baseline for physical qubits, so readers cannot check that figure against the paper. The paper’s one like-for-like comparison of logical and physical performance is the factor of 14 for gates. Blume-Kohout knows this hardware well. He was senior author of Sandia’s quantum universal operation performance system (QUOPS), a cross-platform benchmark of quantum computing capability written with Quantinuum co-authors and run on Helios-1, which I covered in September.

In its blog, Quantinuum presents the result as nearly reaching a “megaquop” machine, John Preskill’s term for an error-corrected computer that can run about a million quantum operations. Running a million operations with a good chance of no failure needs error rates near one in a million per operation. The memory figure, $$5 \times 10^{-6}$$, is five times above that. The gate figure, $$7 \times 10^{-5}$$, is 70 times above it. Circuits built only from Clifford gates can also be simulated efficiently on classical computers. The team ran only Clifford circuits.

The distance-7 point is based on three failures. In its blog, Quantinuum acknowledges that with three failures it had just enough statistical confidence to make the claim. The authors note that direct sampling will become impractical as logical error rates fall further, and they point to benchmarking methods that need fewer samples.

A fitted suppression factor of 12

An error-correcting code gets better as it grows only when the hardware’s physical error rate is below the code’s threshold. Below threshold, the logical error rate is divided by a factor Λ for each increase of two in code distance. That factor is roughly the ratio of the threshold to the physical error rate. Experimenters measure it from the logical error rates themselves. On Helios, the average two-qubit gate error is $$8.4 \times 10^{-4}$$ with the repump switched on, according to the paper’s supplement. Color-code checks involve up to six qubits each, against four for the surface code, so the color code is harder to run below threshold.

I track Λ on my capability page for below-threshold operation because the code distance a machine needs follows from Λ and its starting error rate. In September, Microsoft and Qolab listed an error rate that falls predictably as the code grows as one of their four conditions for a scalable logical qubit.

Λ is the factor by which the logical error rate falls for each increase of two in code distance. The IBM Heron figures are for the logical basis aligned with the enlarged direction; averaged over all four logical states, the factors were below 1.

Λ = 12 is a fit across three distances. The individual steps were about 14.5 from distance 3 to 5 and about 7.6 from distance 5 to 7. The second ratio depends on just three failures at distance 7.

In its press release, Quantinuum says each tested increase cut errors by a factor of 12. Given those two steps, the blog’s “average factor of 12” is the accurate description. The two steps are consistent with a single Λ within the error bars. In simulation, the team predicted $$2.6 \times 10^{-6}$$ at distance 7, just below the measured one-sigma range. With three failures, nobody can tell whether that gap is real.

Gidney and Quantinuum both arrived at 21 by dividing the distance-7 error rate by 12 at each step. On that arithmetic, the logical error rate passes $$10^{-12}$$ a little beyond distance 19. Triangular color codes come only in odd distances, so the next one after 19 is 21.

Anyone extrapolating from three points to distance 21 has to assume that physical error rates stay where they are as machines grow. In the authors’ simulated error budget, memory errors linked mostly to moving ions around the trap account for 36% of 1/Λ. Depending on layout and scheduling, ions in a larger trap may have to travel farther in each round.

Handling leakage on Helios

A Helios qubit is two hyperfine levels of a barium-137 ion, which has six other hyperfine levels close in energy. An ion that falls into one of those levels stops working as a qubit, and gates it takes part in can spread errors to its partners. A single leaked ion can cause a burst of correlated faults that error-correcting codes, designed for errors that stay inside the qubit, cannot correct.

The authors note that every leading modality suffers from leakage. The team behind China’s Zuchongzhi 3.2 got its surface code below threshold with an all-microwave leakage suppression scheme. QuTech this month built leakage removal into qubit readout.

When the team simulated the standard superdense syndrome circuit with no leakage handling, it found the same logical error rate, about $$5 \times 10^{-3}$$ per round, at distances 3, 5 and 7 (Figure 2c). Without leakage handling, enlarging the code would not help at all.

Quantinuum’s syndrome circuit, which the authors call SWAP-superdense, swaps each data qubit with a freshly reset measurement qubit at least once every three rounds. In the measurement role, a leaked ion is measured and reset. On Helios the swap needs no physical gate, because the control system relabels which ion plays which role. Relabeling works because any ion in the trap can be brought next to any other, the all-to-all connectivity of Helios.

On the hardware side, the team added a mid-circuit repump: laser pulses that return leaked population to the qubit levels, timed to run during ground-state cooling so that circuits take no longer. Users can switch the repump on in their own programs, according to the paper’s supplement.

Simulating the error budget with leakage handled, the authors attribute 43% of 1/Λ to two-qubit gates, 36% to memory errors linked mostly to ion transport and 13% to crosstalk from mid-circuit measurement and reset. Leakage contributes to each of those channels and accounts for 41% when its shares are added up. Quantinuum says transport and cooling will take less time in Sol’s grid-shaped trap. From elevated syndromes on some checks in early runs, the team also traced an error in the software that tracks each qubit’s phase during ion transport, and fixed it.

The comparisons with Google

Quantinuum measured both of its comparative claims against Google Quantum AI’s Willow superconducting processors. In Google’s 2024 experiment on a 105-qubit Willow chip, a distance-7 surface code reached 0.143% logical error per cycle with Λ = 2.14. Google also decoded a distance-5 code in real time over up to a million cycles, with an average decoder latency of 63 microseconds.

Per round of error correction

Against that 2024 figure, Quantinuum’s $$5 \times 10^{-6}$$ is 286 times lower. Google later improved Willow’s calibration with a reinforcement-learning agent, which I covered in July, and reported $$7.72 \times 10^{-4}$$ per cycle at distance 7 in Nature. In its blog, Quantinuum cites the preprint of that work for a 154-fold gap. In the press release, Quantinuum links only to the 2024 paper. On a per-round basis, Quantinuum’s 100x claim is conservative against both Google results.

Per second of operation

A Willow cycle takes 1.1 microseconds. The authors do not state a round time for Helios in the text. In Figure 3, where they plot decoder speed against the pace of the hardware, they draw reference lines at roughly 200 milliseconds for one round of syndrome extraction and roughly 35 milliseconds for one layer of gates. Gidney first put the cycle at 20 milliseconds and corrected it to 200 the same day. The 200 milliseconds applies to these experiments, with this circuit and Helios’s current transport and cooling schedule. If a Willow cycle lasted one second, a Helios round would last more than two days.

For a stored qubit, Quantinuum comes out ahead per second as well. At $$5 \times 10^{-6}$$ per round and about 0.2 seconds a round, a logical qubit with a steady error rate would fail roughly once every 11 hours. At 0.143% per 1.1-microsecond cycle, Willow’s 2024 distance-7 memory would have a logical error every 0.8 milliseconds. The 11 hours is an extrapolation: each Helios run lasted about four seconds, and the authors report no runs longer than 20 rounds. Quantinuum calls its distance-7 logical qubit “the most robust quantum memory ever recorded.” Counting per second, I found nothing in the comparison with Willow to dispute that.

For computation, the faster machine comes out ahead. Logical operations have to be interleaved with rounds of error correction. A machine with slow rounds therefore completes fewer logical operations per second. In the gate benchmarks, the team ran one round after every seven transversal Clifford gates. The number of gates per round varies with the code and the circuit. Sandia’s QUOPS benchmark has two scores: the largest circuit a machine can complete and an effective rate of operations per second. The Sandia-led team measured Helios-1 at 303 QUOPS per second on physical qubits, against 20 million for Willow. Helios-1 completed far larger circuits, with a score of 1,504 against Willow’s 216.

In April I put trapped-ion gates at roughly 1,000 times slower than superconducting gates. A full round of error correction on Helios, which includes moving and cooling ions, takes close to 200,000 times as long as a cycle on Willow.

Gidney estimated in 2025 that factoring RSA-2048 would take 4.96 days on fewer than a million noisy qubits, which he described as less than a week. He assumed a surface-code cycle of one microsecond, a control reaction time of ten microseconds and distance-25 codes, sized to keep logical errors near $$10^{-15}$$ per round.

At Λ = 12, Helios’s color-code memory would also need distance 25 to reach $$10^{-15}$$ from today’s starting point. At a fifth of a second per round, the same number of rounds would take about 2,700 years. Gidney built his schedule for surface codes, where each logical operation takes many rounds. Engineers designing a trapped-ion machine with transversal gates would write their own schedule, and their round time would depend on their trap. On Helios, the logical gates scaled with Λ = 9, so a computation would also need a larger distance than the memory. The 2,700 years is an illustration of scale; a runtime estimate would need a schedule built for trapped ions.

The 30x qubit claim

In its blog, Quantinuum uses Λ to argue that an Apollo-scale machine could reach fault-tolerant advantage with about 30 times fewer physical qubits than other leading approaches. Quantinuum extrapolates two curves to a logical error rate of $$10^{-12}$$: Helios’s, which reaches it at distance 21, and the curve from Google’s 2025 color-code experiment, which needs distance 109. For 100 logical qubits, it arrives at about 30,000 physical qubits for Quantinuum against about 900,000 for the superconducting machine.

Quantinuum counts data qubits only: 331 per logical qubit at distance 21 and 8,911 at distance 109, or 33,100 and 891,100 for 100 logical qubits. With measurement qubits included, both counts roughly double. The absolute numbers are therefore too low, but the ratio stays at about 27, which Quantinuum rounds to 30.

For the superconducting baseline, Quantinuum chose Google’s first color-code experiment, at Λ = 1.56, over Google’s stronger surface-code results. With the surface-code results, the gap is smaller. Both curves are also extrapolated well beyond the distances measured: three points for Helios and two for the superconducting color code.

I ran the same calculation with Google’s 2024 surface-code numbers, 0.143% at distance 7 and Λ = 2.14. The error rate reaches $$10^{-12}$$ at distance 63. A distance-63 surface code has 3,969 data qubits, or about 397,000 for 100 logical qubits. On these extrapolations, Quantinuum is right that its color code would need fewer physical qubits than Willow’s surface code. The multiplier is about 27 against Google’s color code and about 12 against its surface code. Neither Quantinuum nor I counted qubits for magic-state factories or routing, or estimated runtime.

Apollo’s target range and qubits per logical qubit

On the current roadmap graphic, published with its 19 October blog post, Quantinuum lists Apollo for 2029 with thousands of physical qubits at a two-qubit gate error of $$10^{-4}$$ and hundreds of logical qubits at error rates from $$10^{-5}$$ to $$10^{-10}$$. In a footnote, Quantinuum attributes the lower end to published analyses of new codes. It does not say whether the rates are per gate or per round. The memory figure, $$5 \times 10^{-6}$$ per round, is inside that range, so Quantinuum’s statement that its accuracy is within Apollo’s target range is correct for memory. The logical gates, at $$7 \times 10^{-5}$$, are not yet inside it. In the text of its September 2024 roadmap, Quantinuum set a stricter bar, logical error rates better than $$10^{-6}$$.

The scaling result is stronger evidence for Apollo than the headline number. In July, Quantinuum and SoftBank put Apollo at about $$10^{-7}$$, with code distances of 7 to 9, in a logical-layer envelope that I reported at the time. They did not say whether that figure is per gate or per round.

Dividing today’s distance-7 memory figure by 12 gives about $$4 \times 10^{-7}$$ at distance 9 and $$3.5 \times 10^{-8}$$ at distance 11. At Helios’s measured Λ and with today’s hardware, the memory error rate would fall into that envelope between distance 9 and 11, before any of the fidelity gains Quantinuum plans for Apollo.

The team used 73 of Helios’s 98 physical qubits for the record-setting logical qubit. On its second-quarter earnings call in August, Quantinuum said Sol, its next machine, due in 2027, is designed to provide 100 logical qubits from 192 physical ones, at a logical error rate of $$10^{-5}$$. At 73 qubits each, two distance-7 color codes would fit in Sol’s 192.

Quantinuum’s efficiency results come from other codes. The company used 52 physical qubits for a pair of Helix logical qubits. On the same 98-qubit machine, it has also run computations on 48 error-corrected logical qubits in concatenated iceberg codes. In the press release, Quantinuum presents the codes as a trade between accuracy and efficiency. So far the accuracy record and the efficiency records have come from different codes on the same hardware. Apollo needs hundreds of logical qubits at the fidelity of this one.

Quantinuum rounds the memory improvement over September’s Helix result to tenfold. From $$4.6 \times 10^{-5}$$ per round, measured in one basis, to $$5 \times 10^{-6}$$, the improvement is about 9.2-fold. The logical gates improved fourfold, from $$2.8 \times 10^{-4}$$ to $$7 \times 10^{-5}$$. In the press release, Quantinuum compares 10 physical qubits per logical qubit for Helix with up to 37 for the color code, counting data qubits only. With measurement qubits included, the numbers are 26 and 73.

Decoding since Helix

In September I called offline decoding the most consequential qualification of the Helix results. The team decoded this experiment offline as well. It also measured what real-time decoding on Helios would require.

A decoder has to turn each round’s syndrome data into a correction before the next operation that depends on it. The team wrote a streaming version of Frontier, a decoder published in June, and compiled it to WebAssembly, which Helios’s real-time control stack can call from programs written in Guppy, Quantinuum’s programming language. Run on a laptop against recorded Helios syndromes, it took from tens of microseconds per round at distance 3 to a tail of about 25 milliseconds at distance 7, below the 35-millisecond gate layer.

The two neural decoders, a convolutional network and a transformer, needed 0.22 to 0.52 milliseconds per round on an H100.

The neural decoders were trained only on emulator data, with the noise turned up fourfold, and applied to the hardware without fine-tuning. At distance 7, they matched Tesseract’s error rate within the statistics, although their fitted Λ values were lower, 7 and 8. Each used three models per code distance, one for each logical basis, trained to predict whether a memory experiment’s logical observable flipped. A decoder for a general computation has a harder job. The authors contrast this with Google’s AlphaQubit decoders, which were fine-tuned on hardware data. On ion traps, where generating large training sets on the machine is slow, teams can train decoders in simulation and keep hardware time for experiments.

The team did not measure the end-to-end latency from a measurement on Helios through the decoder and back to the control system. The authors note that this integration adds overhead. The headline numbers came from Tesseract, which the authors describe as too slow for real time.

A decoder on a slow machine has more time per round: Quantinuum’s decoders get tens of milliseconds per gate layer, while Willow’s have to keep pace with a new round every 1.1 microseconds. IonQ showed the same effect in September, when it decoded a simulated 408-logical-qubit trapped-ion computer in real time on a single laptop CPU, working to cycles of one to five milliseconds.

Trapped-ion resource estimates after this result

Quantinuum goes further in its blog, arguing that many published resource estimates are outdated because their authors assumed distance scaling and codes that do not apply to its architecture. For qubit counts on trapped ions, I agree: at Λ = 12, the logical error rate reaches $$10^{-12}$$ at distance 21, while Willow’s 2024 surface code would need 63.

Authors of trapped-ion runtime estimates assume operations far faster than Helios runs today. In its September estimate for computing a secp256k1 discrete logarithm on 19,397 trapped ions in about 26 days per attempt, which I analyzed, IonQ assumed a 200-microsecond operation cycle. Helios, built on a different architecture, spends about 35 milliseconds on a layer of gates, 175 times longer. At that pace, IonQ’s 26 days per attempt would stretch to about 12 years.

If Sol reaches the doubled speed Quantinuum targeted in its 2024 roadmap, the figure would be about six years. I rescaled IonQ’s schedule linearly for both figures. The Quantinuum team does not model how long a large algorithm would take on Apollo.

For the CRQC question, I read this paper as a reason to lower the qubit side of a trapped-ion estimate and to leave the time side where it was. Blume-Kohout’s under-a-million figure and Gidney’s distance 21 are both statements about qubit counts. A trapped-ion machine that meets a cryptographically relevant qubit budget would still need operations more than a hundred times faster than Helios’s to finish a run in weeks. Anyone who reads this result as a tightening Q-Day clock is counting on speed gains the authors do not claim.

The next experiments to watch

A fault-tolerant color-code computer needs syndrome extraction, two-qubit Clifford gates and magic-state preparation for the non-Clifford T gates, the authors write. In this paper they show the first two scaling below threshold. Quantinuum prepared magic states in the Steane code, the distance-3 member of the same color-code family, in 2025, with an infidelity of at most $$5.1 \times 10^{-4}$$ and with failed attempts discarded, as I reported then. In its blog, Quantinuum acknowledges that nobody has yet shown magic-state error falling with code distance.

On 15 October, Google published magic state cultivation on Willow in Science, preparing T states in a distance-3 color code and moving them into a distance-5 surface code, with a 40-fold error reduction over uncultivated states. That experiment ran at one size. Cultivation is built on color codes, the family Quantinuum has now scaled to distance 7.

The results I would watch for next:

• magic-state preparation in the color code at more than one distance, with error falling as the code grows;
• a Clifford-plus-T circuit with the decoder running inside the control loop, which the authors name as their next step;
• continuous error correction running for hours, a direct test of the 11-hour extrapolation;
• logical gates at distance 7, which need more qubits than Helios has and would fit on Sol;
• the paper on arXiv or in a journal, ideally with more runs at distance 7 to narrow the error bar.

Gidney summarized what the hardware needs as more qubits and more speed. Quantinuum has shown that its error rates are low enough to keep code sizes small. Sol, due in 2027 with a grid-shaped trap and a target of about twice Helios’s speed, will be the first test of how fast those rounds can get.

From the author