Quantinuum.com

Quantinuum has announced that its Helios trapped-ion quantum computer has achieved below-threshold color code operation, with each successive increase in code distance reducing logical error rates by a factor of 12 — and with independent validation from Sandia National Laboratories confirming that a scaled-up version of this architecture could reach fault-tolerant performance at a physically feasible qubit count.

At the highest code distance tested — distance 7, requiring 73 physical qubits per logical qubit — the logical error rate hit five errors per million operations (5 × 10⁻⁶ per syndrome extraction cycle). That figure, achieved on a commercial quantum processor already available to enterprise customers, now stands as the lowest published logical error rate across all quantum hardware platforms in the world.

The result closes a specific argument that Quantinuum's two prior TechTimes financial profiles left open: the company's 2029 Apollo fault-tolerant roadmap is not merely a corporate ambition. It now rests on a measured, independently verified engineering foundation. Robin Blume-Kohout, co-director of Sandia National Laboratories' Quantum Performance Laboratory, said the result has practical implications for the path ahead: a system scaled up from Helios could reach the reliability needed for fault-tolerant computation at a "feasible size" — meaning fewer than one million physical qubits — which would dramatically improve the real-world outlook for quantum computing.

What Quantum Error Correction Actually Measures

To assess why the factor-of-12 figure matters, it helps to understand what "below-threshold" means precisely.

A quantum computer operates by manipulating qubits — quantum bits whose fragile quantum states can be disrupted by thermal noise, electromagnetic interference, and the very act of measurement. Quantum error correction (QEC) addresses this by encoding a single "logical qubit" across many physical qubits, distributing the information so that errors on individual components can be detected and corrected before they corrupt the result.

The central insight of QEC is the threshold theorem: if the underlying physical error rate falls below a code-specific threshold value, increasing the number of physical qubits per logical qubit suppresses the logical error rate exponentially. Below that threshold, more qubits mean greater reliability. Above it, more qubits mean more errors — which is why demonstrating "below-threshold" operation is a qualitative milestone, not merely a quantitative improvement. This principle was established by Knill, Laflamme, and Zurek in 1998.

The suppression factor Λ (lambda) quantifies how far below threshold the system operates. Quantinuum's color code paper reports Λ = 12 (−2/+3) per step: for every step up in code distance, the logical error rate decreases by a factor of roughly 12. That is the number Blume-Kohout was responding to when he described fault-tolerant computation at feasible scale as plausible.

Color Code vs. Helix: Two Codes, One Architecture, Six Weeks

Today's result is Quantinuum's second world record in under six weeks, and the comparison between the two results illuminates the company's broader strategy.

On September 8, 2026, Quantinuum announced the experimental validation of Helix — its proprietary [[20, 2, 6]] C₄-Helix code, a concatenated architecture pairing a twisted toric code with a block code — on the same Helios hardware. Helix set a world-record logical error rate of 4.6 × 10⁻⁵ per logical qubit per cycle. Helix used only 10 physical qubits per logical qubit, making it exceptionally hardware-efficient.

The color code result uses more physical resources: distances 3, 5, and 7 require 13, 37, and 73 physical qubits per logical qubit, respectively, as detailed in the color code distance scaling paper. The tradeoff pays off in accuracy — the color code reaches a logical error rate roughly ten times lower than Helix achieved. Both codes demonstrate below-threshold behavior on the same commercial system.

That flexibility — running Helix and the triangular color code on the same Helios hardware within weeks of each other — is architecturally significant. Trapped-ion systems implement the color code's Clifford gates transversally, meaning the full Clifford group can be executed on logical qubits without ancilla overhead. That property, a structural feature of ion-trap all-to-all connectivity, does not transfer to superconducting architectures with fixed qubit wiring.

Why the Factor-12 Suppression Changes Apollo's Physical Qubit Math

The suppression factor does more than confirm the threshold theorem experimentally. It directly determines how many physical qubits Apollo will need.

The threshold theorem predicts that logical error rates scale as p_L ∝ (p / p_th)^((d+1)/2), where d is the code distance and p is the physical error rate. The suppression factor Λ = p_th / p. With Λ = 12, each additional code distance step roughly squares the improvement rate. Moving from d=5 to d=7, the distance scaling table confirms a drop from 3.8 × 10⁻⁵ to 5 × 10⁻⁶ — a factor of about 7.6, consistent with the measured suppression.

For comparison, Google Quantum AI's Willow superconducting processor — which previously held the best-published logical performance across hardware modalities in the color code family — demonstrated color code suppression of 1.56× per code distance step in a 2025 Nature paper (Lacroix et al.), operating in the distance 3 to 5 range. Quantinuum's Λ = 12 represents substantially stronger suppression per distance step on this code family.

What that means concretely: reaching the logical error rates needed for practically useful quantum algorithms — on the order of 10⁻¹⁰ per gate, roughly a billion times better than today's physical gates — requires fewer code-distance steps, and therefore fewer physical qubits per logical qubit, when Λ is larger. Blume-Kohout's specific assessment that fault-tolerant computation remains feasible at sub-million qubit scale is grounded in this suppression curve.

The error budget reported in the paper also points to where the next gains will come. Two-qubit gate error accounts for 43% of the logical error rate (1/Λ), memory and transport errors 36%, and mid-circuit measurement crosstalk 13%. Leakage — a failure mode specific to ion-trap systems where a qubit escapes its computational subspace — accounts for 41% of 1/Λ in aggregate across all channels. The hardware-level leakage repump scheme implemented on Helios-1, which optically returns leaked barium-137 ions to the computational subspace in parallel with ground-state cooling, achieves 6.5× leakage suppression per cycle with no added circuit runtime. Further gate fidelity improvements on future hardware generations — particularly reduced two-qubit gate error — directly shrink the dominant error term and would push the suppression factor higher.

How Helios Makes the Color Code Work

The Helios system on which these results were demonstrated was announced in November 2025 and peer-reviewed in a 2026 Nature paper by Ransford et al. The system implements 98 physical qubits using barium-137 (¹³⁷Ba⁺) ions — charged atoms suspended in an electromagnetic trap — in a quantum charge-coupled device (QCCD) architecture that physically shuttles ions between eight interaction zones through a rotatable storage ring.

That shuttling capability is not incidental to the color code result. The triangular color code's SWAP-superdense syndrome extraction circuit — the sequence used to detect error patterns — requires ions to be rearranged in specific orderings across three-round cycles. Helios's all-to-all ion connectivity implements these SWAP operations through software-level qubit relabeling, reducing syndrome extraction depth by one compared to alternative circuits. This is a case where the hardware architecture was specifically designed for the class of operations the error-correcting code requires.

With hardware-level leakage repump active, average two-qubit gate infidelity on Helios runs at approximately 8.4 × 10⁻⁴ with leakage reduction across all qubit pairs. That physical error rate — combined with all-to-all connectivity and the SWAP-superdense circuit — is what makes the color code's Λ = 12 suppression achievable: the physical hardware is already well below the color code's fault-tolerance threshold.

The paper also demonstrates that real-time decoding is now viable at this scale. Three streaming decoder architectures — a Frontier decoder implemented in WebAssembly, a convolutional neural network, and a round-token transformer — were tested on the experimental data. The CNN and RTT achieve sub-millisecond per-round latency on an NVIDIA H100 GPU, well below the syndrome extraction rate required for real-time operation. This clears a practical bottleneck that has kept error correction results confined to offline post-processing; Helios's real-time control stack already supports the WebAssembly decoder in principle.

Does Quantinuum Have the Full Fault-Tolerance Stack?

The color code result covers two of the three components required for universal fault-tolerant quantum computation in the Clifford + T model: logical memory and Clifford gates, both demonstrated below threshold.

The third component — below-threshold magic state preparation — has not yet been demonstrated in this experiment. Magic states are the resource required to implement non-Clifford T gates, which are necessary for a computationally universal gate set. Quantinuum describes magic state preparation as the "natural next step" following this result. Prior Quantinuum work on code-switching between quantum error-correcting codes demonstrated high-fidelity logical T-state preparation, but not yet combined with the below-threshold color code distance scaling shown here.

The paper also identifies what it would take to complete the stack: real-time decoding of syndromes during T-gate teleportation via magic state injection. The neural decoder latency results suggest this is within reach on current hardware, though it has not been experimentally demonstrated end-to-end.

What This Means for Competing Roadmaps

The result arrives as IBM, Google, and Microsoft are each pursuing 2029 fault-tolerant milestones on competing architectures.

IBM's Starling system — targeting 200 logical qubits capable of 100 million quantum operations by 2029 — uses quantum low-density parity-check (qLDPC) codes on superconducting hardware, an approach that requires different tradeoffs in connectivity and gate speed. IBM committed more than $10 billion to quantum computing in June 2026 to support this roadmap. Google's Willow processor, the prior leader in color code performance, demonstrated color code below threshold in a 2025 Nature paper at Λ ≈ 1.56. Microsoft is pursuing topological qubits — a fundamentally different physical approach — with its own 2029 fault-tolerance target.

What makes Quantinuum's successive records notable is the platform they ran on: both the Helix and color code results were demonstrated on Helios, a commercial system already deployed to enterprise customers and, as of August 2026, being deployed as an Oracle Cloud service. The question for enterprise and research institutions evaluating quantum readiness is no longer whether below-threshold error correction is theoretically achievable. The question is which architecture reaches commercially useful fault-tolerant operation first — and at what physical qubit cost.

"With this result, we've proven that we have the error-correction architecture and trapped-ion technology required to achieve universal fault-tolerance," said Dr. Rajeeb Hazra, CEO of Quantinuum. "We have reduced error rates tenfold in rapid succession using a different code on the same commercial hardware, demonstrating the flexibility of our error-correction architecture. We've crossed the threshold necessary for exponential improvements in accuracy, reinforcing our path to Apollo and how we can help users unlock commercial value from quantum at scale."

Sol, Apollo, and What Comes Next

Today's color code result is framed by Quantinuum as a direct validation of its path toward Apollo, the company's planned fifth-generation quantum computer, targeted for 2029 and described as a universal, fully fault-tolerant system capable of running circuits with millions of gates across hundreds of logical qubits.

Between Helios and Apollo sits Sol, an intermediate system expected with approximately 192 physical qubits and a 2D QCCD grid architecture operating at roughly twice Helios's speed. Sol's trap chips completed fabrication at Honeywell's facility and returned for product validation, reportedly without showstoppers. The path from today's Helios result to Apollo's commercial fault-tolerant claims now has a measurable suppression curve to build on: Λ = 12, sub-million-qubit feasibility confirmed externally, and a real-time decoding architecture already operational on current hardware.

The technical gap that remains — below-threshold magic state preparation combined with the color code — is the next milestone the quantum computing community will be watching for.

Frequently Asked Questions

What does "below-threshold quantum error correction" mean, and why is it a milestone?

Below-threshold operation means the physical hardware's error rate has fallen below the critical value at which adding more physical qubits per logical qubit actually makes logical performance worse. Below that threshold, the opposite is true: larger codes suppress logical errors exponentially. The threshold theorem, established by researchers including Knill, Laflamme, and Zurek in 1998, predicted this behavior theoretically. Demonstrating it experimentally on commercial hardware — with a suppression factor (Λ) of 12 per code distance step — is the first concrete evidence that the exponential improvement curve is accessible on a system you can actually buy.

What is the difference between a logical qubit and a physical qubit, and why does the ratio matter?

A physical qubit is the actual hardware component — in Quantinuum's case, a single barium-137 ion. It has a measurable error rate from noise, decoherence, and imperfect gates. A logical qubit encodes a single piece of quantum information across many physical qubits using an error-correcting code, so that individual physical failures can be detected and corrected. The ratio of physical to logical qubits determines how much hardware a fault-tolerant computer needs. Quantinuum's color code demonstration used 13 physical qubits per logical qubit at distance 3, scaling to 73 at distance 7. The suppression factor of 12 per distance step is what determines how many distance steps — and therefore how many physical qubits — Apollo will need to reach commercially useful error rates.

How close is Quantinuum to a fully fault-tolerant quantum computer?

The color code result demonstrates below-threshold scaling for logical memory and logical Clifford gates, two of three components required for universal fault-tolerant computation in the standard architecture. The third component — below-threshold magic state preparation, needed for T gates — has not yet been combined with the color code distance scaling shown here. Quantinuum describes it as the next step. Independent assessment from Sandia National Laboratories confirms the full stack is achievable at physically feasible scale (fewer than one million physical qubits). The company targets Apollo for 2029, with an intermediate Sol system expected around 2027.

How does this result compare to what Google, IBM, and Microsoft have shown?

Google's Willow superconducting processor demonstrated the color code below threshold in a 2025 Nature paper, achieving an error suppression factor of approximately 1.56 per code distance step. Quantinuum's factor-of-12 suppression on the same code family is substantially stronger. IBM's competing 2029 fault-tolerance roadmap (Starling) uses quantum LDPC codes on superconducting hardware, a different architectural tradeoff. Microsoft is pursuing topological qubits with its own 2029 target. All three hardware approaches are converging on the same 2029 window; the Sandia assessment suggests Quantinuum's ion-trap approach may reach the milestone with fewer physical qubits than superconducting alternatives would require.