No Bare Qubits: JPMorgan and Quantinuum Run Whole Algorithms on Fully Error-Corrected Hardware

On October 12, a joint team from JPMorgan Chase and Quantinuum published results that move quantum error correction out of the laboratory stunt category and into something that looks like engineering. The paper, Fault-tolerant execution of error-corrected quantum algorithms by Michael A. Perlin and collaborators, describes complete quantum algorithms, optimization and linear-equation solving among them, executed end to end on Quantinuum’s H2 and Helios trapped-ion processors with every component protected by error correction. No bare qubits anywhere in the circuit.

That last detail is the news. Researchers have shown error-corrected gates before, and they have run small algorithms on top of partial protection. This is the first demonstration, the authors say, in which whole algorithms ran with exclusively fault-tolerant components, from state preparation through every gate to the final measurement. The largest circuits used 12 logical qubits built from 97 physical qubits, and even at 2,132 two-qubit gates the system still produced better-than-random results.

What the experiment actually did

The team chose the Steane code, written [[7,1,3]], a well-studied scheme that encodes one protected logical qubit in seven physical ones and can correct any single physical error. It is not the most economical code in use today, but it has a property the researchers needed: every operation in the set can be performed fault-tolerantly, meaning errors that strike mid-computation do not cascade into the kind of correlated failures that defeat protection.

The algorithms were real ones. The team ran the Quantum Approximate Optimization Algorithm, or QAOA, on circuits from five to twelve logical qubits, and the Harrow-Hassidim-Lloyd algorithm, HHL, on the Poisson equation. They also tested the LABS problem and binary portfolio optimization, a direct nod to the bank on the author list. Every logical operation ran on hardware, with emulators used only for benchmarking beforehand.

The headline numbers are worth reading carefully. The largest QAOA circuits, with 12 logical qubits and 97 physical qubits, contained 2,132 physical two-qubit gates and still yielded better-than-random performance. Circuits with up to 8 logical qubits and 9 logical T gates performed roughly on par with their unencoded counterparts, which means the error correction was costing almost nothing at small scale. The researchers report near-break-even performance overall: protection nearly paying for itself.

Why the T gate matters

The most important single result in the paper is not an algorithm at all. It is one gate. A logical T gate, which is required for universal quantum computation under the Steane code, achieved a fidelity of 0.960(6) on Quantinuum’s H2-1 processor, corresponding to an infidelity of roughly 2.6(4) × 10^-3. A previous non-fault-tolerant implementation of the same gate had an infidelity of 14 × 10^-3. That is more than a fivefold improvement in error rate for the gate that quantum computers find hardest to protect.

To see why that matters, consider the asymmetry at the heart of quantum error correction. Most quantum gates are relatively easy to protect because they belong to a family called the Clifford gates, which play nicely with the stabilizer codes researchers use. The T gate does not. It is a non-Clifford gate, and you cannot do universal quantum computation without it, so any fault-tolerant computer must solve the hard problem of making non-Clifford gates reliable. The JPMorgan and Quantinuum result is a concrete demonstration that the hard gate can be built fault-tolerantly at an error rate low enough to be useful.

The T gate is the one gate quantum computers find hardest to protect. This team cut its error rate more than fivefold, fault-tolerantly.

The improvement came partly from a better way to prepare the |H⟩ state that the fault-tolerant T gate consumes, using a repeat-until-success procedure with an optimized retry limit. The team also used dynamic circuits with measurement-dependent feedback, where mid-computation measurement results steer the operations that follow. The discarded-result rate from the repeat-until-success step fell to near zero, which matters for scaling: a scheme that throws away most of its runs cannot grow into a long computation.

A second study says the plumbing is improving

Error correction lives or dies on mid-circuit measurement, the checks the computer performs on itself while computing. Those checks are essential and, inconveniently, themselves error-prone. A separate study posted to arXiv on October 8 by J. A. Montañez-Barrera and Kristel Michielsen of Germany’s Jülich Supercomputing Centre benchmarked exactly this, comparing ten processors from Quantinuum, IBM and IQM on the operations behind error correction.

The comparison favored Quantinuum’s machines. On the IBM processors tested, tasks using mid-circuit measurements had effective error rates roughly an order of magnitude higher than the same task without measurements, meaning the checks were expensive. On Quantinuum’s, the extra errors were comparable in scale to ordinary two-qubit gate errors, meaning the checks were cheap.

The study’s Helios-1 results went further. The processor retained meaningful output across three families of error-correction codes, including tests with 91 data qubits in triangular color-code structures and circuits containing as many as 2,950 mid-circuit measurements. It did not demonstrate successful error correction at those sizes, the authors are explicit, but the circuits preserved useful information rather than drowning in noise.

What this does not prove

Three caveats deserve equal billing with the results. First, the paper appeared as a journal manuscript, not a peer-reviewed publication, and independent groups have not yet reproduced the experiments. Second, better-than-random is a real but modest bar: it shows the logical circuits carry signal, not that they outperform a classical computer or even, consistently, their own unencoded versions. Near break-even is not beyond break-even, and the team is honest about that.

Third, nothing here changes the timeline for practical quantum computing. Twelve logical qubits running small optimization problems are a universe away from the hundreds or thousands of logical qubits needed for commercially relevant chemistry or materials science. The paper’s claim is narrower and more durable: the complete stack of fault-tolerant components works end to end, and the components keep getting better. That is how an unreliable technology becomes a reliable one, by assembling protected pieces that each measurably improve and then learning to operate the whole assembly.

Why a bank is building quantum computers

It is worth asking why JPMorgan Chase, which holds no quantum hardware of its own, keeps showing up in the author lists of serious quantum papers. The answer is that optimization is one of the few places where quantum algorithms and financial problems meet naturally. Binary portfolio optimization, choosing which assets to hold under constraints, is the kind of combinatorial problem QAOA was designed to attack. The bank has been investing in quantum research for years as a hedge on the moment the machines become capable, and papers like this one are how it measures how far away that moment is.

Fault-tolerant quantum computing is no longer a pile of isolated gate demonstrations. It is, for the first time, a running system, small, slow, and fragile by any commercial standard, but running. The question now is whether the curve of improvement is steep enough to scale it. For the first time, there is a full stack on which to plot that curve.