Google Quantum AI's Willow Teaches Itself to Fix Errors Without Stopping

Quantum computers have a calibration problem. Because they are fundamentally analog machines, their control parameters — the frequencies, amplitudes, and phases of the signals that drive the qubits — drift constantly. Quantum error correction only works when errors stay rare enough, which requires continuously adapting those parameters to shifting hardware conditions. The current solution is to halt the computation and recalibrate, but useful quantum algorithms will need to run for days or months. Stopping to retune every few hours makes that impossible.

Google Quantum AI just published a fix. In a paper in Nature titled "Reinforcement learning control of quantum error correction," the team demonstrated that a quantum computer can tune itself in real time without ever pausing the computation.

Using error data twice

Quantum error correction (QEC) works by encoding one logical qubit across many physical qubits and running parity checks to detect failures. Those checks produce a stream of binary signals called error detection events — a continuous readout of where and when errors occur. Until now, that data went to a decoder (like Google's own AlphaQubit) to determine what corrections to apply. The decoder answers "what went wrong?" but never asks "why?"

Google's approach gives the QEC process a second job. Error detection events still drive the decoder, but they also feed a reinforcement learning agent that watches the error stream, learns which control parameters to adjust to reduce it, and keeps tuning — all while the computation runs. The agent answers the "why?" in real time.

How the system works

The framework uses a multi-objective policy-gradient RL algorithm, which optimizes a parameterized policy by following the gradient of a reward signal. Rather than measuring the logical error rate directly (expensive), the agent uses the average rate of error detection events as a surrogate. That choice is deliberate: detection events are cheap to observe and locally sensitive to calibration quality, which is what makes the approach scalable.

The control loop runs as follows:

• The quantum processor runs QEC cycles and emits a stream of error detection events
• A classical decoder (AlphaQubit or Tesseract) reads those events and applies logical corrections
• Simultaneously, the RL agent reads the same event stream as a reward signal
• The agent updates over 1,000 analog control parameters — frequencies, amplitudes, phases — to push the error rate down
• This happens continuously, without halting the computation

Results on Willow

Google tested the approach on its Willow superconducting processor. The RL agent reduced logical error rates by about 20% beyond conventional calibration and made performance 3.5 times more stable under artificially introduced hardware drift.

The 20% figure is worth sitting with. It represents improvement on top of exhaustive expert human tuning — meaning the agent found calibration adjustments that experienced quantum physicists, applying physical intuition and manual iteration, had missed.

Combined with Google's other techniques, the system set new records for logical error rates on superconducting hardware:

• Surface code: 7.72 × 10⁻⁴ average logical error per cycle for a distance-7 code
• Color code: 8.19 × 10⁻³ average logical error per cycle for a distance-5 code

Fewer than one error per thousand correction cycles in the surface code. That is a record for superconducting hardware.

Does it scale?

Google ran numerical simulations up to 449 qubits with tens of thousands of control parameters to test whether the approach holds at larger sizes. The results are encouraging: the number of training iterations required does not grow with system size. The reason is physical. Error detection events are locally sensitive to nearby control parameters, so the agent's learning signal stays informative regardless of how large the chip gets.

What this changes about quantum computing assumptions

Google's Willow chip had already confirmed below-threshold quantum error correction in hardware in December 2024, meaning that adding more qubits reduced errors rather than compounding them. Below-threshold performance only holds, though, as long as the hardware stays well-calibrated. Drift erodes it. This new work functions as a stability layer on top of that earlier result, keeping the system in the regime where error correction actually works.

The paper also challenges assumptions baked into most quantum computing roadmaps:

• Calibration and computation are separate phases. This paper collapses that boundary. The two can run simultaneously.
• Human experts set the ceiling for calibration quality. The RL agent beat exhaustive expert tuning by 20%, and the gap may widen as the agent matures.
• Better hardware is the only path to lower logical error rates. The researchers argue that real-time learning from error data opens a scalable optimization path independent of hardware improvements.

Google is not alone in this direction. Q-CTRL has partnered with NVIDIA on AI-driven quantum control, while Rigetti and Quantum Machines are pursuing their own automated calibration pipelines.

Where this leads

The researchers suggest that, with sufficient development of the learning framework, a quantum processor could eventually be calibrated for QEC entirely by RL, with no reliance on traditional calibration routines or human experts. That would represent a fundamental shift in how quantum computers are operated, and it now looks like a plausible engineering target. The full technical writeup and the arXiv preprint are both publicly available.