Most of the levers that improve a quantum computer's performance are made of metal, glass, and laser light. Better optics, tighter control, cleaner gates. They are slow to pull, expensive, and bounded by physics and engineering.

Decoding is not one of those levers. A decoder is software. It can be improved, replaced, or retrained without touching the machine it runs on, and a better decoder lowers the logical error rate of hardware that has not changed at all. That makes it one of the few places in the fault-tolerance stack where a research result can translate into a performance gain almost immediately.

This post draws on "State of the Art in QEC," a talk by Michael Gullans of QuEra Computing at the QuEra Quantum Alliance 2026 Annual Meeting (QQA 2026). The talk surveyed where decoding stands today and highlighted a recent machine learning result worth paying attention to.

What a Decoder Actually Has to Do

A fault-tolerant computation produces a continuous stream of mid-circuit measurements. That stream is called the syndrome, and it is the only window into what is going wrong inside the machine while the machine is running. Every operation carries some probability of error. On neutral-atom systems, the syndrome also carries information about detected atom loss, since atoms occasionally escape the trap and the system needs to know which ones.

A decoder is a function from that measurement record to an estimate of which errors actually occurred. The estimate then drives conditional logic: corrections applied, or correction frames tracked, as the program proceeds.

Doing this optimally is NP-hard in general. Quantum low-density parity check (qLDPC) codes are the practical escape hatch. They have enough structure, and enough locality, that high-performing decoders are relatively straightforward to find despite the worst-case result.

The Landscape, Roughly in Order of Ambition

Lookup tables. For small codes, you can precompute the answer. Every syndrome pattern maps to a stored correction. Fast and exact, until the table gets too large to hold.

Matching decoders. For the surface code specifically, minimum-weight perfect matching is highly performant and well understood. It is the workhorse that much of the field's intuition was built on.

Belief propagation. For general qLDPC codes, the standard approach comes straight out of classical coding theory. BP is fast and scales well, but on quantum codes it often needs a post-processing step to resolve cases it cannot settle on its own.

Mixed-integer programming. Classical optimization tooling has gotten remarkably good, and MIP-based decoders are now accurate enough to be treated as a practical option rather than a theoretical reference point. The cost is computation time.

Machine learning decoders. The newest entrant, and the reason the frontier is moving. ML decoders can approach the accuracy of integer programming approaches while decoding far faster at inference time.

Speed Against Accuracy, and the Hierarchical Answer

Those five families sit along a single frontier. Faster decoders are less accurate, more accurate decoders are slower, and no single point on that curve is right for every syndrome the machine produces.

The useful observation is that most decoders return more than an answer. They return a confidence in that answer. That makes escalation possible: run the fast decoder first, accept its output when it is confident, and hand the case up to a slower, more accurate decoder only when confidence is low. Since the hard cases are a small fraction of the total, the hierarchy runs near the speed of its fastest stage while inheriting much of the accuracy of its slowest.

This is the structure QuEra is building toward for real-time decoding, and it is worth repeating that the whole scheme can be developed and tuned independently of the hardware, then dropped into a running system.

Why Machine Learning Fits This Problem Unusually Well

Decoding is computationally hard, and small software improvements meaningfully reduce logical error rates, which is a good setup for learned approaches. Three properties make it more than that.

The cost is front-loaded. Training is expensive; inference is cheap. That is precisely the shape you want when the decoder has to keep up with a machine in operation.

Training data is not a bottleneck. The noisy Clifford circuits at the heart of error correction can be simulated efficiently on classical computers, which means large, labeled training sets can be generated in simulation without consuming hardware time or waiting for hardware to exist. Open tooling makes this concrete: the Bloqade logical simulation toolchain pairs hardware-informed noise modeling with Stim, Tsim, and PyQrack backends, then feeds syndrome data to decoders through the sinter interface.

And the transfer from simulation to experiment has a floor under it. Training on one noise model preserves the effective distance of the code, which bounds the achievable error rate on a different noise model, including real experimental noise. That bound is a guarantee of some degree of generalization, not a guarantee of identical performance. Whether a decoder trained in simulation hits the same numbers on hardware still has to be validated experimentally. This is a general property of decoding, not a quirk of the machine learning approach.

The Headline Result: A Cascade Decoder from Harvard

The result Gullans highlighted comes from Harvard collaborators, not from QuEra. It is worth stating the attribution plainly, because the significance of the number invites loose repetition.

The Harvard team built what they call a cascade decoder for the bivariate bicycle code and the toric code. The design insight is architectural rather than brute force: both codes carry substantial built-in symmetry, and the neural network was constructed to respect it. Matching the architecture to the structure of the code meant comparatively simple networks were enough.

Against the prior state of the art for these codes, belief propagation with a post-processing step, the cascade decoder reduced the logical error rate by close to a factor of twenty, in the regime around one percent physical error rate. It decodes in microseconds. Neutral-atom clock speeds run on the order of milliseconds, so microsecond decoding is comfortably inside the budget for real-time operation on this hardware.

A factor of twenty in logical error rate, from software, on unchanged hardware. That is the case for treating decoding as a first-class part of the roadmap.

The caveats are real and the talk named them. Machine learning methods come with limited theoretical guarantees compared with the algorithms they are displacing. Networks generally have to be designed and validated per code family and per gadget, which is engineering overhead that accumulates. And distribution shift between training and deployment remains a live concern.

The Other Direction: Learning the Machine from Its Own Syndromes

There is a second, quieter use for all this syndrome data. Instead of using it only to find errors, you can use it to characterize the system producing them.

Using experimental data from a GHZ-state preparation with Steane codes, researchers were able to learn a circuit-level noise model for the entire system, and to accurately predict the experiment without access to the logical measurement outcomes. Related work covers both physical and logical noise, and both Clifford and non-Clifford circuits.

The practical value here is operational. A machine that can infer its own noise model from data it is already generating can detect drift as it happens and support verification of fault-tolerant circuits over time. For systems meant to run long computations in production environments, that is closer to a requirement than a nicety.

Why This Matters for the Road to Fault Tolerance

Every logical error rate improvement that comes from decoding is an improvement that does not have to be bought with more physical qubits or better gates. It compounds with the architectural advantages neutral atoms already bring to fault-tolerant workloads, and it arrives on a software release cycle rather than a hardware one.

That is why decoding sits alongside the hardware work rather than behind it. QuEra's multi-year collaboration with NVIDIA spans CUDA-Q integration, real-time quantum-classical interfaces, and AI-accelerated decoding and calibration, and fast real-time decoding is one of the peer-reviewed building blocks underpinning the roadmap to Libra, QuEra's 256-logical-qubit fault-tolerant system built from over 10,000 physical qubits, arriving on Amazon Braket in 2028.

The decoder is the part of a quantum computer that anyone can improve, today, without a laboratory. Given how much of the logical error rate it controls, that is a remarkably good place for the field to be putting effort.