By: Harry Buhrman, Chief Scientist

Quantum computing is often framed as a race to the most qubits, the fastest gates, and the biggest benchmarks.

But a race needs a destination. In the fault-tolerant era, that means solving a valuable problem faster or at a lower cost than the best classical approach—and the time to solution is ultimately what matters most.

In this context, gate speed metrics have received a lot of attention. While gate speed is a meaningful component of the overall quality of a quantum computer, what actually matters most is fidelity. As we all know, speed on its own matters little if we don’t arrive at the correct destination. 

Fidelity has emerged as the most important foundation for success in quantum computing. Higher fidelity means fewer errors in the underlying physical operations. Combined with quantum error correction, higher fidelity can reduce the number of additional qubits and operations needed to make computations reliable. This reduction in overhead can lower costs and shorten the time to deliver a useful answer—even compared with systems that have faster gates but lower fidelity.

Fast Gates Do Not Guarantee Fast Answers

‍Consider a simple example. In an independent-error model, a computation with 10,000 operations, each with an error rate of 10⁻³, or 99.9% fidelity, will experience about ten faults on average that can render the computation useless.

Now make every gate ten times faster without changing its error rate. You still get ten faults. You just get them ten times sooner.

Speed matters, but the relevant measure is the total time required to obtain a trustworthy and useful result. Getting to that point requires performance in many different and connected areas such as state preparation, measurement, error correction, repeated runs, and other work needed to complete the computation.

Gate speed alone cannot establish which system performs best. A fast machine that cannot reliably finish a sufficiently large computation cannot deliver commercial value.

Why Fidelity Changes the Resource Equation

‍Quantum error correction protects information by encoding it across multiple physical qubits. That protection requires resources: additional qubits, measurements, operations, and classical processing. These techniques work better when the underlying physical operations are reliable enough that increasing error protection reduces the logical error rate. 

This requirement is known as the fault-tolerance threshold, the point below which physical error rates are low enough that adding protection reduces logical errors. Faster gates can shorten the computation, but they cannot replace the physical fidelity needed to cross that threshold. 

At Quantinuum, our latest error-correction results on Helios demonstrate this principle. Using our error-correction architecture, logical memory errors fell exponentially as we increased protection. Across the tested code sizes, the fitted error reduction was about twelvefold for each increase of two in code distance. In the largest quantum-memory experiment, the estimated failure rate was about five in a million per error-correction cycle.¹ This demonstrates how high-fidelity physical operations and effective error correction work together to make quantum information more reliable as protection grows.

The next question is what that reliability enables. How large a computation can a system complete, and how quickly can it deliver the result?

A New Performance Benchmark

The Quantum Universal Operations Performance System, or QUOPS, provides a standardized way to assess both. This architecture-neutral benchmark gauges performance by measuring computational “reach” and speed.²

“Reach” measures how large a benchmark circuit a system can execute successfully. Speed measures how quickly it executes that circuit, in effective quantum operations per second. QUOPS uses wall-clock time and accounts for extra samples and discarded runs caused by noise.

Together, these measures provide a common basis for comparing what different quantum systems deliver and tracking progress toward better time to solution.

Quantinuum’s H2 and Helios systems executed substantially larger benchmark circuits than Google’s Willow and IBM’s Boston. These superconducting systems sometimes achieved higher effective operation rates, but on smaller circuits, which means that they are not computationally comparable.

Superconducting systems can use error mitigation to tackle larger computations, but at a steep cost in speed. The QUOPS study estimates that the additional repetitions can make effective processing thousands of times slower. Some computations remain beyond the system’s reliable reach, even with mitigation. In those cases, faster gates may deliver no useful answer at all within practical limits on time and cost.

Useful applications require speed on much larger circuits. For example, the study estimates that factoring RSA-2048 or calculating FeMoco’s ground-state energy within five days would require roughly 100,000 times the computational reach demonstrated by today’s physical-qubit processors. Some machines approach the estimated speed requirement, but only on small circuits. The challenge is to sustain that speed at the required scale, including the additional work needed for error correction.

Larger uncorrected circuits accumulate more errors. Protecting them requires extra qubits and time. Reliability and speed must therefore scale together, and QUOPS offers a way to track both. 

Higher Fidelity Makes Larger, Reliable Computations Possible

Improving fidelity can reduce the extra qubits and operations needed for error correction, lowering the time, cost, and resources required for useful computation. The benefit comes from reaching the required reliability with less protection, leaving more resources available for the computation itself.

Helios brings together the physical performance and error-correction capabilities needed to pursue those savings. In our paper published in Nature we showed that the system achieved an average single-qubit gate fidelity of 99.9975% and average two-qubit gate fidelity of 99.921% across its operational zones, while scaling the trapped-ion architecture to 98 fully connected physical qubits.³

The latest color-code experiments build on that physical performance. Alongside the logical memory results, protected two-qubit Clifford operations also became more reliable as protection increased. This connects improvements in the underlying hardware to improvements in logical computation.

A flexible error-correction architecture creates further opportunities to improve efficiency. Our recent Helix and color-code demonstrations used the same Helios hardware to explore different balances of accuracy and physical-qubit requirements. That flexibility allows us to evaluate which codes best suit different computational tasks as systems scale.

However, we continue to push ahead and accelerate the development of machines, such as Apollo, where quantum utility comes into play at scale. Decoding in the new color-code benchmarks was performed offline, and we are now turning our attention to integrating error correction, magic-state resources and real-time control into longer, reliable computations.

While that work continues, today’s systems can already contribute to scientific research. NISQ systems have advanced algorithms and hardware, enabled certified randomness, and supported studies of quantum magnetism and superconducting pairing correlations. These results leave room for useful applications before fault tolerance, even as error correction provides the scalable path to larger, reliable computations.⁴

The goal is to combine these capabilities so that larger computations can run reliably within practical limits on time and resources. Fidelity provides the foundation, and optimizing the full system turns that foundation into better time to solution.

Fidelity First. Then Optimize Time to Solution.

‍Scaling quantum computation requires continued progress in fidelity. As physical operations move further below threshold, increasing error protection can suppress logical errors more effectively, enabling longer, more demanding computations.

Speed must improve alongside that reliability. Advances in transport, cooling, measurement, compilation, and parallel execution can reduce the time and total cost of solving useful problems. These improvements become increasingly valuable as systems gain the reliability needed to complete larger computations.

Our latest Helios results are proof points on the path to Apollo, our planned universal fault-tolerant quantum computer, expected by 2029. The goal is to translate these gains into systems that can solve industrially relevant problems faster or at lower cost than the best classical approach.

Industrial partnerships help connect that progress to problems that matter, from understanding high-temperature superconductivity to how molecules interact to accelerate drug discovery. They bring practical research questions into the development process and help identify where improving quantum capabilities could deliver useful results beyond the reach of classical computing alone.

Our motto is simple: fidelity first, with speed built on that foundation.

References & For Further Reading

‍[1] A. Lavasani et al., "Quantum error correction well below the color code threshold," arXiv:2610.24077 [quant-ph] (2026). doi:10.48550/arXiv.2610.24077.

[2] T. Proctor et al., "Benchmarking the computational power of quantum computers," arXiv:2609.12146 [quant-ph] (2026). doi:10.48550/arXiv.2609.12146.

[3] A. Ransford et al., "A 98-qubit trapped-ion quantum computer with all-to-all connectivity," Nature 655, 81-86 (2026). doi:10.1038/s41586-026-10676-4.

[4] M. Liu, R. Shaydulin, P. Niroula et al., "Certified randomness using a trapped-ion quantum processor," Nature 640, 343-348 (2025). doi:10.1038/s41586-025-08737-1.

     S. Dasu et al., "Computing with many encoded logical qubits beyond break-even," arXiv:2602.22211 [quant-ph] (2026). doi:10.48550/arXiv.2602.22211.

      E. Granet et al., "Superconducting pairing correlations on a trapped-ion quantum computer," arXiv:2511.02125 [quant-ph] (2025; revised 2026). doi:10.48550/arXiv.2511.02125.

Quantinuum and GE Vernova’s Advanced Research Center are launching a collaboration to apply quantum computing to one of the research community’s most consequential challenges: understanding the behavior behind high-temperature superconductivity. Advances in this field could, over the long term, transform the energy sector by enabling lighter generators, more compact and powerful motors, and electricity infrastructure that carries more power and better withstands faults.

The research will focus on Fermi–Hubbard modeling, a framework for studying how interacting electrons give rise to complex material properties. By combining Quantinuum’s full-stack quantum computing capabilities—including access to the company’s Helios computer—with GE Vernova’s expertise in material science and engineering simulation applied to industrial applications, the collaboration will bring an industry perspective to a promising area of quantum research.

Why superconductors matter for energy

As energy systems grow, the size, weight, and performance of electrical equipment become increasingly important constraints. High-temperature superconductors offer potential ways to address those limits through their ability to carry large electrical currents without resistance under suitable operating conditions.

Potential applications span power generation, electricity grids, and industrial electrification. Superconducting generators could reduce the weight and footprint of industrial equipment. Superconducting windings could also help make utility generators and industrial or marine propulsion motors more compact and efficient. In electricity networks, superconducting cables could carry more power through constrained spaces, while fault current limiters could help protect equipment during short circuits.

Realizing those benefits more widely depends on overcoming challenges in cooling, material performance, manufacturing, and cost. Better understanding of the physics behind high-temperature superconductivity could help inform the search for materials with more practical operating characteristics.

Why quantum computing may offer new tools for understanding high-temperature superconductivity

High-temperature superconductivity involves the collective behavior of strongly interacting electrons. Accurately modeling these systems is exceptionally difficult: the interactions that make them scientifically interesting also make important aspects of their behavior computationally challenging.

The Fermi–Hubbard model captures essential features of those interactions in a simplified mathematical framework. Although it is not a complete description of a material used in  industrial applications, it provides a foundation for investigating mechanisms associated with high-temperature superconductivity.

Quantum computing offers a promising way to explore the physics. Quantinuum researchers have already measured superconducting pairing correlations—including s-wave and d-wave pairing—in Fermi–Hubbard models simulated on the Helios quantum computer. These results demonstrate the ability to prepare and probe quantum states relevant to superconductivity research, establishing a foundation for further investigation.

The collaboration with GE Vernova will build on that foundation, bringing industrial expertise to the selection and interpretation of research questions.

Connecting quantum capabilities with industrial expertise

The research will be enabled through access to Quantinuum’s full-stack capabilities, including cloud-based access to Helios, the world’s most accurate quantum computer¹, and Nexus, Quantinuum’s developer platform. Nexus connects quantum hardware with the software tools researchers need to develop and run applications in a unified environment.

GE Vernova’s Advanced Research Center brings the expertise in material science,  engineering, and industrial applications to the research and development activity.  

“High-temperature superconductors could help us overcome important limits on the size, weight, and efficiency of electrical equipment, but understanding and improving these materials remains a significant scientific challenge,” said Jonathan Owens, PhD, Senior Scientist, Computational Materials Physics at GE Vernova. “By combining our materials simulation and industrial expertise with Quantinuum’s quantum computing capabilities, we can explore new approaches to these difficult problems while building the expertise to assess where quantum computing can make a meaningful contribution.”

The collaboration also extends GE Vernova’s exploration of quantum computing into a new area of materials research while supporting the development of its internal quantum talent. Its previous published work includes investigations of quantum algorithms for carbon-capture materials using simulated quantum processors.

Building toward industrial value

Translating insights from simplified models into practical materials requires sustained scientific and engineering work. Industrial expertise helps connect that effort to the properties, operating conditions, and manufacturing considerations that ultimately determine a material’s usefulness.

For Quantinuum, this collaboration is an opportunity to advance quantum simulation with an industrial collaborator that understands both the potential applications and the barriers to adoption. It brings together demonstrated computing capabilities, a challenging materials problem, and the expertise needed to connect scientific progress with industrial requirements.

The research collaboration aims to deepen understanding of this field and explore how quantum computing may contribute to future energy technologies.

¹ Based on two-qubit gate fidelity as of December 31, 2025.

From Oracle's Quantum AI Compute beta program to upcoming Helios installation milestones and Oracle AI World, our partnership continues to gain momentum.

When Quantinuum and Oracle announced a strategic partnership earlier this year, the goal was not simply to deploy a quantum computer in the cloud. It was to create a practical path for bringing quantum computing into the enterprise environments where AI, data, and high-performance computing (HPC) already come together.  

By combining Oracle Cloud Infrastructure (OCI)'s AI, data, and cloud capabilities with Helios, Quantinuum's most advanced quantum computer, we're helping lay the foundation for hybrid quantum AI computing at enterprise scale. The partnership reflects our belief that some of the most valuable future applications will emerge when quantum computing, AI and classical HPC work together to tackle problems that remain difficult to solve today.  

Oracle Opens Early Access for Quantum AI Compute

That vision is now being put into practice. This month, Oracle launched the OCI Quantum AI Compute Beta Program, giving select organizations an opportunity to begin evaluating how quantum computing fits into existing workflows and computational challenges.

Through the program, approved participants will gain cloud-based access to Helios, the world's most accurate commercial quantum computer, alongside OCI's GPU and HPC infrastructure. For organizations exploring quantum computing, this creates a practical starting point: access to industry-leading hardware within an enterprise cloud environment, without the need to build specialized infrastructure of their own.

The goal is to help organizations understand where hybrid quantum AI workflows may create value across areas such as drug discovery, materials science, energy, financial modeling, and optimization.

For many organizations, the starting point is not quantum technology itself. It's a business or research problem. Where are today's approaches reaching meaningful limits? Which workloads consume disproportionate resources? And where could a new computational capability create an advantage?

Organizations interested in participating can apply through Oracle's OCI Preview Programs portal. Oracle will review applications and select participants based on eligibility, capacity and program requirements.

Quantinuum and Oracle Leadership Takes the Stage at Oracle AI World

The opportunity for hybrid quantum-AI computing will be a major topic at Oracle AI World 2026.  

In a main stage session, "Powering the Next Era of Enterprise AI," Larry Stack, Chief Commercial Officer at Quantinuum, will join Mahesh Thiagarajan, Executive Vice President and Head of Oracle Cloud Infrastructure, to discuss how quantum computing, AI and classical HPC can work together to address some of the world's most computationally demanding challenges.

The discussion will focus on a core question many organizations are asking: where should they start? Rather than leading with technology, the conversation will explore how organizations can identify high-value problems, establish today's performance baseline, and evaluate where quantum computing ultimately provides an advantage.

Later in the day, Quantinuum and Oracle experts will take a deeper look at how bringing Helios into OCI provides managed access to quantum computing natively within an enterprise cloud environment to support hybrid quantum-AI workflows.

Building Momentum Toward Hybrid Quantum-AI Computing

The collaboration between Quantinuum and Oracle continues to progress from vision to execution.

With Helios advancing toward installation, Oracle's Quantum AI Compute program now open for early access, and enterprise interest growing around hybrid computing, the pieces are coming together. Organizations now have a practical way to begin exploring quantum computing through cloud-based access to Helios alongside AI, HPC, and existing enterprise workflows.

We look forward to continuing the conversation at Oracle AI World 2026 and working with customers who want to better understand where hybrid quantum-AI computing can create real-world value.

We're excited to continue that conversation at Oracle AI World 2026 and to help customers begin exploring what's possible through the OCI Quantum AI Compute Beta Program.

By: David Hayes, Sr. Director of Computational Design and Integrated Software

Two recent announcements from Quantinuum and Google mark important progress toward fault-tolerant quantum computing.

Because both announcements focus on reducing errors, it may be tempting to compare the numbers directly. But these results are not the same. They measure different parts of the fault-tolerance challenge and answer fundamentally different technical questions.

This week, we reported a world-record error-correction result, using our error-correction architecture on Helios to deliver a logical fidelity of 99.9995%, equivalent to just five errors per million operations and representing a 100x reduction in errors compared to the best published result across any other modality—reported by Google Quantum AI in 2024.  

Last week, Google reported a 99.99% magic-state fidelity result using a new cultivation technique, citing a 40x reduction in errors.

As fault-tolerant quantum computing matures, understanding what is being measured becomes just as important as understanding the headline number itself. Google's work measured the fidelity of a resource used in certain fault-tolerant operations. Our work measured the fidelity of the logical computation that consumes those resources.

Across the published results, Quantinuum demonstrates state-of-the-art performance in fault-tolerance, combining record logical computational fidelity with substantial advantages in resource efficiency. Understanding starts with examining what each study measured, what it achieved, and the resources it required.

Quantinuum's World-Record Result: Measuring the Accuracy of a Logical Computation

This week’s result measured how accurately an error-corrected logical quantum system can execute a computation.

To achieve the result, we used a well-known “color code” within our error-correction architecture. The error rate is 10 times lower than Quantinuum’s own world record achieved last month and 100 times lower than the best published result across all other hardware modalities—the 2024 Google result.

The study also demonstrated that logical errors fell exponentially as code distance increased. Code distance is a key measure of how quantum information can be protected as an error-correction system scales.

Each increase tested in the study reduced the remaining logical error rate by a record factor of 12, demonstrating exponentially effective error suppression as the code grows, a critical capability for scalable fault-tolerant quantum computing.

Together, these results demonstrate how Quantinuum's highly accurate trapped-ion hardware and flexible logical architecture can drive rapid gains in computational accuracy. They also show that fault-tolerant performance can be achieved with substantially fewer physical qubits than competing modalities.

The result places Quantinuum within the target logical-performance range required for Apollo, our planned universal fault-tolerant quantum computer targeted for 2029.

Google's Result: Advancing Magic-State Preparation

Google's latest paper focused on a different aspect of fault tolerance: the preparation of high-fidelity magic states.

Magic states are an important resource required for certain operations in a fault-tolerant quantum computer. Generating them efficiently is widely recognized as one of the key engineering challenges facing large-scale fault-tolerant systems, particularly for certain modalities.

Google's work introduced a new approach known as cultivation, designed to improve the fidelity of magic-state preparation while reducing the resources required to produce those states. The study demonstrated a magic-state fidelity of 99.99% using a protocol that retained approximately 8% of attempts while discarding the remainder. This post-selection process was a key contributor to the reported 40x reduction in error rate.

The study did not measure the fidelity of a larger logical computation that incorporates those magic states into an end-to-end algorithm. Instead, it focused specifically on the creation and refinement of the resource itself.

That distinction is important because preparing a high-fidelity resource and demonstrating the performance of a logical computation are different milestones on the path to fault tolerance.

Directly Comparing Quantinuum and Google’s Magic-State Results

Quantinuum's latest logical computation result should not be compared directly with Google's latest magic-state result. It should be compared against the distance scaling result published by Google in 2024.

That said, we have published studies measuring an analogous magic-state capability examined in Google’s latest work.

In a 2025 study, we achieved 99.993% magic-state fidelity with an 85% retention rate, compared with the 99.99% fidelity and approximately 8% retention reported in Google’s latest work. Our result also required fewer physical qubits and fewer operational steps, resulting in significantly lower space-time overhead.

That combination of smaller qubit and operational steps footprint, along with substantially higher retention means fewer resources are consumed preparing each usable magic state.

As fault-tolerant systems scale, those efficiency advantages become increasingly important because they directly affect the amount of hardware required to perform useful computations.

The Bigger Picture

Taken together, these results establish Quantinuum’s leadership in demonstrated fault-tolerant performance: record logical computation fidelity, alongside a directly comparable magic-state result that achieves higher fidelity with substantially lower resource overhead.

That combination—computational accuracy and the efficiency with which it is achieved—is critical to delivering reliable answers to useful problems at a practical scale.

Ultimately, customers do not buy two-qubit gate fidelities or magic states. They buy answers.

Forward-Looking Statements

This blog post contains forward-looking statements within the meaning of the Private Securities Litigation Reform Act of 1995. These include statements about our technology roadmap, our expected logical performance, and the planned timing and capabilities of future systems, including Apollo. Words such as "target," "expect," "plan," and similar expressions identify forward-looking statements. These statements are based on our current expectations and involve risks and uncertainties that could cause actual results to differ materially. Those risks include challenges in developing, manufacturing, and scaling our quantum computing systems. For a discussion of these and other risks, see the "Risk Factors" section of our most recent Quarterly Report on Form 10-Q and our other filings with the SEC, available at ir.quantinuum.com. Forward-looking statements speak only as of the date of this post, and we undertake no obligation to update them except as required by law.

• Record accuracy: Using Quantinuum’s logical error-correction architecture, Helios achieved a logical memory fidelity of 99.9995%—just five uncorrectable errors per million operations—reducing logical memory errors tenfold compared with Quantinuum’s September record and more than 100-fold compared with the superconducting record.
• Errors fall exponentially as protection grows: Each tested increase in code distance reduced logical memory errors by an average factor of 12, and logical gate errors by an average factor of 9, demonstrating the exponential error suppression needed to scale toward longer, more reliable quantum computations.
• A flexible path to fault tolerance: Successive breakthroughs using different codes within the same logical architecture, on the same commercial Helios hardware, demonstrate how accuracy and qubit efficiency can be optimized as Quantinuum advances toward Apollo in 2029.

‍‍
Recently, we started making the case that the NISQ¹ era is coming to an end. At Quantinuum, we’ve already demonstrated numerous QEC codes, all the primitives needed for logical computation, steadily declining logical error rates, and full computations at the logical level.

To truly leave the NISQ era, though, we need to demonstrate a “megaquop” machine – a quantum computer that can run over a million operations error-free. With our latest result, we are on the cusp of this monumental achievement: using Quantinuum’s logical error-correction architecture, Helios achieved a logical memory fidelity of 99.9995%— or a million operations with only 5 uncorrectable errors, a new world record. This logical error rate is ten times lower than our September record and more than 100 times lower than the record achieved on a superconducting system.

Coming after September’s Helix-code demonstration on the same Helios hardware, this result shows how our flexible logical architecture and highly accurate trapped-ion technology support rapid improvements in accuracy.

These results indicate that an Apollo-scale machine could reach the fault-tolerant quantum advantage regime using 30x fewer physical qubits than other leading approaches, reinforcing our path to Apollo, our first universal fault-tolerant quantum computer.

A quantum memory that lasts

At Quantinuum, we don’t have delicate qubits that can only hold their state for milliseconds at a time. We’ve already shown quantum memories lasting over 20 seconds. However, this latest result takes it to a whole new level: we have demonstrated the most robust quantum memory ever recorded.

This latest result was enabled by something scientists call “distance scaling”, a key result in quantum error correction (QEC) theory: the prediction that error rates should be suppressed exponentially as longer distance codes (more physical qubits per logical qubit) are used.

In experiments using color codes of distance 3, 5 and 7, Helios (with code written in Guppy) reduced the logical failure rate by an average factor of 12 each time the code distance increased. At distance 7, the system achieved a logical fidelity of 99.9995% per syndrome-extraction cycle, equivalent to a failure probability of just 5 × 10⁻⁶. This nearly “six nines” result sets a new record for logical accuracy through quantum error correction.

To measure the failure rate of something that rarely fails, you must run it for a long time. This ensures that you get reasonable enough statistics to feel comfortable that your measured value isn’t just a statistical fluctuation (scientists call this 'averaging down’ the uncertainty in your measurement).

When you only get an error 5 times in a million rounds, this often means ‘averaging down’ for a long time to even see an error².

“We felt a mix of excitement and suspense every time the results came in. When errors are this rare, each one really matters."

- Dr. Adam Reed, Lead Physicist, Commercial Operations

More than a memory: high-fidelity logical gates

The team also explored logical computation, measuring 2-qubit Clifford gate fidelity at increasing code distance. In this case, the team measured a suppression factor Λ of 9 when stepping the code distance up from 3 to 5, proving again our hardware’s exponential error suppression³.

If one assumes a “Clifford + T” model of universal computation (with T gates teleported via magic state injection), then a fully fault tolerant processor built with this code will have three crucial components:

1. Magic state preparation
2. Two-qubit Clifford gates
3. Syndrome extraction gadgets.

This work demonstrates high accuracy implementation and below threshold scaling of the latter two, and we demonstrated the first in a separate paper (with the same code) back in 2025.  Teleporting T gates via magic state injection will require real-time decoding, which we first demonstrated back in 2021 and have been refining ever since – in fact, this work shows that this is viable for near-optimal decoders. There is still work to be done, however: nobody has yet demonstrated below threshold scaling for magic state preparation.

We’ve already put almost everything together in the Helix code. Soon, we will be integrating all these color-code components into increasingly large, reliable computations. Our ability to fully employ multiple codes is a testament to our powerful error correction architecture.

World-record logical fidelities come from world-leading physical fidelities‍

Distance scaling is great in theory, but it is rarely demonstrated because it only works when the underlying hardware noise falls below a certain threshold. This is known as the “threshold theorem.” Basically, until the physical layer has low enough noise levels, QEC will just add more noise than it takes away.

Helios’ incredible performance – with a ‘suppression rate’ Λ of 12 (for memory) and 9 (for Clifford gates) - is a clear demonstration of our world-leading physical fidelity, which puts us well below the ‘threshold’.

The rate Λ captures the exponential suppression in error rate with increasing code distance⁴: increasing the code distance once gives an 12x reduction in logical error, increasing the distance twice gives 144x, three times 1728x, and so on. In contrast, a machine with a Λ of 2 gives you a 2x reduction, then a 4x reduction, then 8x, and so on – a much slower gain. The magnitude of Λ is crucial for how well quantum computers can scale, and this is the largest Λ ever measured.

This effect shows up in the best error rates, too. The previous state of the art color-code error rate (at distance 5) was 0.819% per cycle. Helios, in contrast, showed an error rate of 0.0005% with a distance 7 code, a 1,638x improvement⁵. This massive improvement is due to our excellent physical fidelity, improved scaling behavior, and our ability to go to a longer distance code (in this case, d=7 vs d=5)⁶.

Comparing at the same code distance, the previous best demonstrated error rate was using a surface code. In this case, the researchers demonstrated an error rate of 0.0772% per cycle with a distance 7 code. In this case, Helios shows a 154x improvement⁷.

‍

Figure 4. Animation of logical qubit growth with increasing code distance. The white circles represent physical qubits, and the animation shows how logical qubits are formed at color code distances of 3, 5, and 7.

Our trapped-ion qubits lead to significant resource savings

On top of our new record in fidelity, the scaling with code distance reveals something very important: our QCCD⁸ approach is expected to reach utility scale with far less resources than other modalities.

This all comes down to the value of Λ, which describes how quickly error rates decrease with increasing code distance. The most comparable result, done in a superconducting architecture with the color code, had a Λ of 1.56, while Helios demonstrated a Λ of 12. This means that we can hit a ‘utility scale’ error rate, say 10^-12, with shorter distance codes - which translates to far less physical qubits.

Mathematically, this is a straightforward calculation: you take a known error rate at a given distance (call this LER_d), then you compute LER_d×Λ^(x-d)/2, then find whatever code distance is needed to get to your desired error rate.  

The plot above compares state-of-the-art color code implementations on Helios and a superconducting architecture. For an error rate of 10^-12, indicated with a horizontal black line, the superconducting system would need a code distance of 109 to achieve the target error rate, while our computers would only need a code distance of 21⁹.

Translating this into a physical qubit requirement to generate 100 logical qubits, the superconducting processor would need ~900,000 physical qubits while our QCCD processors would only need ~30,000, a ~30x resource savings. This also brings in timelines: building a 30,000-qubit processor is much more likely in the near term than a 900,000-qubit processor.

In our recent blog about the Helix QEC architecture, we pointed out how our targeted physical fidelities will keep advancing our logical fidelities. That holds here as well: with the physical fidelity improvements targeted for Sol and Apollo, we will see an improved LER_d and Λ, meaning that we can achieve target error rates at even shorter distance codes than above. This brings in timelines further: even fewer physical qubits will be needed.

Finally, we have access to codes that cost less qubits in the first place. These ‘high encoding rate’ codes require connectivity beyond what is available in fixed qubit superconducting systems. With our reconfigurable qubits, we can implement exotic entangling schemes that allow for a single physical qubit to be shared amongst several logical qubits, further improving resource estimates and bringing in the timelines to large scale utility.
‍
Our Sol system, coming next year, will continue to reduce these costs by moving us to a grid-shaped trap, shortening transport and cooling times, while enabling full connectivity at a larger scale.

‍

Figure 6. A qubit moves through a prototype grid trap, demonstrating the precise control and dynamic qubit transport that enable all-to-all connectivity in our QCCD architecture. This is footage from an operating device, not an artist’s rendering.

An important takeaway is that a lot of resource estimates that claim we will need X qubits or Y gates to do some algorithm are outdated; as they rely on assumptions about distance scaling and QEC codes that are not relevant to our QCCD architecture. With our high fidelity and full connectivity, we will be able to achieve target applications sooner than expected (compared to many external estimates), needing fewer qubits and fewer gates overall.

Helios as a pathfinder

Figure 7. Qubits are rearranged within a prototype grid trap using broadcast control signals, demonstrating our solution to quantum computing’s “wiring problem.” This approach dramatically reduces the number of control signals—or “wires”—needed to route qubits, overcoming a critical barrier to scaling into the megaquop regime. We first demonstrated this capability in 2024. The video shows real qubits in motion—it is not an artist’s rendering.

This result reflects more than the performance of an exceptional QPU. It is the product of a cross-functional, full-stack team working in close coordination, using Helios as a pathfinder for our next generation systems.

For example, one challenge every leading quantum computing platform faces is leakage: an unwanted process that takes the system out of the two qubit states used for computation. Leakage is especially damaging for QEC codes, which are built to fix errors within those two states and are not equipped to handle a qubit that has left them. Moreover, all subsequent operations on a leaked qubit quietly fail — a single leak can lead to a cascade of correlated errors which could result in a logical failure.

On Helios, the team built a mid-circuit fix: ‘leakage repump’, which returns leaked qubits back into the computational states as ordinary, correctable errors — improving our logical error rate by over an order of magnitude and enabling our distance-scaling demonstration.

Another example is ultra-efficient decoding. Syndrome data must be interpreted quickly enough to correct errors before the quantum information degrades. The team evaluated several approaches, including machine-learning decoders developed by Quantinuum’s AI team, ultimately demonstrating accurate decoding with sub-millisecond latency, which is 10-100x faster than needed to get corrections.

Both of these point to Helios operating in pathfinder mode: helping us understand how to extract the best performance from this generation of hardware, while translating those lessons into the next. That knowledge cannot come from simulation alone – we need to build and test real hardware to continue advancing. As Lead Physicist Dr. Adam Reed put it,  "When we push Helios to its limits, we often learn something the simulations didn't tell us."

By bringing together our theory, facilities, AI, and hardware teams, we pushed our trapped-ion hardware into a new performance regime—showing how our flexible logical architecture, tailored decoders, and highly accurate trapped-ion hardware work together to advance our path to Apollo in 2029.

¹ Noisy Intermediate-Scale Quantum
‍

² In practice, we ran for 580,000 shots (29k shots, each one having 20 rounds, and observed 3 failures), which gave us just enough statistical confidence to claim the ultimate error rate.
‍

³ As you can see in Figure 3, the suppression factor has error bars of +8 and -4, meaning it could be much better or closer to the 12x we measured in the other experiment.
‍

⁴ With the color code, only odd code distances are available.
‍

⁵ The previous state of the art demonstration of distance scaling with the color code (with a maximum distance of 5) showed an error rate of 1.1% per cycle, in which case Helios shows a 2,200x improvement.
‍

⁶ If you want to compare these demonstrations at the same distance, Helios showed an error rate of 0.004% with a distance 5 code, which is a 204x improvement.
‍

⁷ The previous state of the art demonstration of distance scaling with the surface code (with a maximum distance of 7) showed an error rate of 0.143% per cycle, in which case Helios shows a 286x improvement.
‍

⁸ Quantum Charge Coupled Device
‍

⁹ It might look like we need a shorter distance code, but recall that only odd code distances are available with the color code. To hit the teraquop regime, we need slightly more than a code distance of 19. The next highest distance is 21.

• Our team, in partnership with HQS Quantum Simulations, just published what we believe to be the most accurate¹ large-scale quantum simulation of Nuclear Magnetic Resonance (NMR) to date, pointing the way to new frontiers in computational chemistry.
• NMR is a widely used analytical technique that can require significant computational costs to interpret, costs that can balloon quickly on classical systems.
• In this result, the joint team ran an end-to-end simulation on System Model H2, reproducing key spectral features that previous demonstrations were unable to capture.

Nuclear magnetic resonance (NMR) spectroscopy is one of the most powerful analytical techniques in modern science. From identifying drug candidates to understanding battery materials, it allows researchers to probe the local atomic structure of molecules and materials with remarkable precision.

Interpreting NMR experiments often requires simulations that are just as challenging as the experiments themselves. As the number of interacting nuclear spins grows, the computational cost of simulating these systems increases exponentially on classical computers. Quantum computers, which naturally represent and evolve quantum states, offer a fundamentally different approach.

In our latest work, we demonstrate the most accurate large-scale digital NMR simulation performed on quantum hardware to date. Using Quantinuum's System Model H2, we carried out an end-to-end simulation of a classically challenging NMR experiment, reproducing key spectral features that previous hardware demonstrations were unable to capture.

Why simulate NMR?

NMR is a cornerstone of chemical analysis. Researchers use it to determine molecular structures, characterize new compounds, and study how atoms interact with one another.

These capabilities make NMR indispensable across industry. In pharmaceutical research, NMR helps identify and characterize drug candidates. In materials science, it reveals the local atomic environments that determine material properties. Battery researchers, for example, use NMR to study cathode materials such as lithium cobalt oxide, allowing them to monitor how the material changes during charging and discharging and ultimately improve battery performance.

In many cases, the experimental spectrum is only part of the story. Simulations help scientists interpret complex spectra by revealing which atomic interactions give rise to the observed peaks. They provide the link between an experimental measurement and the underlying molecular structure.

The classical challenge and the quantum solution

The difficulty lies in the physics.

An NMR experiment measures the dynamics of interacting nuclear spins. Every additional spin rapidly increases the size of the quantum state that must be represented (in the case of a spin-½ particle, every spin doubles the state). As a result, exact classical simulations become exponentially more expensive as the system size grows.

Today's best classical methods are remarkably sophisticated. Exact simulations are typically limited to systems of around 25 interacting spins, while advanced approximation techniques can often extend calculations to roughly 40–50 spins for many practical problems.

Those approximations have made classical NMR software extraordinarily effective for conventional liquid-state spectroscopy. In fact, our collaborators on this project are developing one of the leading classical simulation packages and noted that, despite the success of our quantum experiment, the current spectral resolution is still insufficient for routine use by practicing spectroscopists. Resolving the fine structure needed for many real-world analyses would require substantially longer simulations—and therefore much deeper quantum circuits than current hardware can yet support.

This highlights both the progress and the remaining challenge. Quantum computers are beginning to produce meaningful NMR spectra, but practical utility will require larger quantum computers and increased simulation depth.

In the longer term, interacting spin systems are among the most natural applications for quantum computers. Instead of storing the exponentially large quantum state explicitly, a quantum computer represents it directly in its physical qubits. For spin-½ nuclei, the mapping is particularly efficient: each nuclear spin corresponds directly to a single qubit. Higher-spin nuclei require only a small number of additional qubits.

This does not eliminate every computational challenge—longer simulations still require deeper quantum circuits—but it avoids the exponential memory bottleneck that limits classical simulation.

For NMR, this makes quantum simulation an especially compelling long-term application.

Our experiment

Working with collaborators at HQS Quantum Simulations, we implemented a complete quantum workflow for simulating an NMR experiment on Quantinuum's H2 trapped-ion quantum computer.

Rather than stopping at Hamiltonian simulation alone, we reproduced the entire computational pipeline:

• constructing the nuclear spin Hamiltonian,
• compiling efficient quantum circuits,
• simulating the spin dynamics through Trotterized real-time evolution,
• applying targeted error-suppression techniques,
• reconstructing the free induction decay, and
• generating the final NMR spectrum through Fourier analysis.

The benchmark molecule, 1,2-di-tert-butyl-diphosphane, is a well-known challenge for NMR simulation. After applying hardware-efficient model reduction, we simulated an effective 21-spin Hamiltonian using a 42-qubit (21 system qubits and 21 ancilla qubits) computation on System Model H2.

Our deepest circuits reached over 1,400 two-qubit gates and simulated 70 Trotter steps, corresponding to approximately 29 ms of physical evolution time.

Most importantly, the resulting spectrum reproduced the key benchmark features of the classical reference calculation, including a characteristic double-peak structure that previous quantum hardware demonstrations had failed to recover.

This represents the most complete hardware demonstration of digital NMR simulation reported to date.

Why trapped ions mattered

Achieving this result depended not only on the quantum algorithm but also on the underlying hardware.

Large Hamiltonian simulations require long, high-fidelity quantum circuits. Quantinuum's trapped-ion architecture provides all-to-all qubit connectivity, high-fidelity gates, and effective error-suppression techniques that allowed us to preserve the spectroscopic features throughout the computation.

The close agreement between hardware, emulator, and classical reference calculations demonstrates that deep quantum simulations of chemically meaningful systems are becoming increasingly feasible on today's hardware.

Looking ahead

To make quantum NMR genuinely useful for practicing spectroscopists, future systems will need substantially deeper circuits.

Our experiment simulated approximately 29 ms of evolution time, producing spectral features with a resolution of roughly 0.07 ppm, a very promising start.

Reaching that scale will require continued improvements in hardware fidelity, error correction, and quantum algorithms.

Nevertheless, this work demonstrates that digital quantum simulation of realistic NMR experiments is no longer purely theoretical. It establishes a practical end-to-end workflow, validates key algorithmic techniques, and shows that quantum computers can already reproduce chemically meaningful spectral signatures.

As quantum hardware continues to improve, applications such as molecular spectroscopy, materials characterization, and chemical simulation are becoming increasingly realistic targets for practical quantum computing.

¹ Based on a study of existing literature