Table of Contents
July 8, 2026 — Google Quantum AI and Google DeepMind published a Nature paper demonstrating that a reinforcement learning agent can calibrate a quantum processor using the error-detection events that quantum error correction already produces, steering the controls while error-correction cycles run rather than in dedicated tune-up passes. The study, led by Volodymyr Sivak and Alexis Morvan and credited to 299 authors in total, ran on Google’s Willow superconducting hardware. It is the first demonstration of reinforcement learning quantum error correction control at the scale of a full error-corrected processor; earlier experimental work applied RL to isolated gates and bosonic codes.
The agent manages more than 1,000 control parameters, the analog settings that specify how an abstract QEC circuit is translated into the waveforms that control the chip. Against artificially injected drift, its steering improved the stability of the logical error rate 2.4-fold; adding decoder steering brought that to 3.5-fold. Applied after Google’s full conventional calibration process and expert tuning, RL fine-tuning cut the logical error rate a further 20%, a result the team reproduced across five independent runs on each of two code types. Synthesizing these techniques produced what the authors describe as record error-corrected performance across any physical qubit modality: a distance-7 surface code with a logical error per cycle of 7.72(9)×10⁻⁴, decoded by the AlphaQubit2 neural network, and a distance-5 color code at 8.19(14)×10⁻³ with the Tesseract decoder. For comparison, Google’s December 2024 below-threshold result reported 0.143% per cycle at the same distance-7; the new figure is roughly half that, though the comparison stacks hardware maturation, a stronger decoder, and RL fine-tuning, and does not isolate any single advance.
Motivating the work is a scheduling conflict at the center of fault-tolerant quantum computing. Control parameters in a quantum processor drift, and the practice in QEC experiments to date has been to terminate error correction whenever the system needs recalibration. The algorithms that would make fault tolerance worth building cannot accept those halts: Craig Gidney’s 2025 resource estimate (my coverage; paper) has a cryptographically relevant quantum computer (CRQC) factoring RSA-2048 in under a week of continuous runtime on fewer than a million noisy qubits. A machine that must stop every few hours to retune cannot run that computation. The paper’s closing claim is “a quantum computer that learns from its errors and never stops computing.”
The method deliberately applies small, simultaneous perturbations to every control parameter while error-correction cycles run. Those perturbations shift the firing statistics of the code’s detectors, the parity checks whose flips flag errors, and the learning algorithm treats lower detection rates as reward, moving a probability distribution over all parameters toward better settings by policy gradient. Sparsity keeps the problem tractable: in the distance-5 experiment, each detector depends on an average of 302 parameters, and each parameter influences 18 detectors. Numerical simulations extending to a distance-15 surface code with roughly 40,000 parameters show an optimization speed independent of system size.
Under natural rather than injected drift, Fourier analysis of the experimental runs shows the steering behaves as a filter that suppresses low-frequency logical-error fluctuations by about 4 dB. The measured response time of the loop is roughly 130 learning epochs. In the hardware drift experiments, the steering ran across thousands of repetitions of a short memory circuit, with the logical state re-prepared on each run; steering through a single continuous logical computation was demonstrated in numerical simulation. Google states the technique already ran in its recent magic-state cultivation experiment, where it improved cultivation error by an order of magnitude. The paper appeared as an arXiv preprint on November 11, 2025, and completed peer review in June 2026; the reviewers Nature names include Marin Bukov, whose group studies reinforcement learning for quantum control. Supporting data are on Zenodo. The code is proprietary, and Google has filed related patent applications.
My Analysis
Every large quantum processor operating today runs on a schedule of interruptions. When I researched calibration operations for Quantum Systems Integration, the numbers fell in similar ranges across the vendors and labs I examined: pulse amplitudes and frequencies retuned every one to six hours, two-qubit gates roughly twice a day, a full recalibration about daily on a 100-qubit machine, with each full cycle costing an hour or more of machine time. The industry treats this the way mainframe operators once treated the daily preventive-maintenance window, as an unavoidable tax on computation. Datacenters eventually stopped scheduling downtime and learned to monitor condition instead. This paper is evidence, at the system level, that quantum computing can begin the same transition.
I rate it among the most consequential QEC papers since Google’s below-threshold demonstration in December 2024. The record error rates will get the headlines. The durable contribution is operational continuity. And the distance between the abstract’s framing and the experiments the team ran on hardware is where the rest of my analysis will spend its time.
Downtime is the bottleneck
Fault-tolerant algorithms need time. Gidney’s factoring estimate assumes under a week of uninterrupted runtime; quantum chemistry projections run to days or months. Nobody pauses Shor’s algorithm halfway through to re-run Rabi calibrations, because pausing destroys the logical state the whole exercise exists to protect.
The field has had three answers to that problem, none of them good. The first is hardware stable enough that drift stays small over a full computation, which no platform has achieved and which the physics of two-level-system defects makes doubtful. A second is architectural: schemes such as CaliQEC, presented at ISCA 2025, use code deformation to isolate drifted qubits for tune-up while computation continues around them, at a cost in qubit footprint and operational complexity. The third, a direct feedback loop from error detection to physical control, was piloted by Julian Kelly and colleagues at Google back in 2016 with a heuristic approach that did not scale.
Google’s new answer costs no extra qubits and no extra cycles. The exploration itself is the price—the agent must keep sampling slightly suboptimal settings to learn, and I will come back to what that costs. The scheduling problem also grows with the machine: more qubits mean more parameters, more aggregate drift, and a rising fraction of wall-clock time spent tuning, which is why the calibration-aware scheduling layer I described in my quantum operating system analysis exists at all. A control method whose optimization speed does not degrade with system size goes after the exact term that gets worse.
The surrogate objective is the clever part
You cannot optimize what you cannot measure, and the logical error rate fails as a mid-computation measurement three times over. The logical state is unknown during a real algorithm, so there is nothing to compare against. Resolving the rate takes exponentially more QEC cycles as codes improve, because the failures being counted become rare. And the parameter count grows with the square of code distance, already past 2,000 in the distance-7 experiment, which makes global optimization from one scalar hopeless.
Detector firing rates dodge all three problems. They are observable every cycle whatever the logical state, they resolve to a given accuracy in a cycle count that does not grow with code distance, and they decompose locally. Sivak’s team shows that, to good approximation, a small fractional change in the mean detection rate maps to a fractional change in the logical error rate (d+1)/2 times as large, where d is the code distance, and they verify the relation experimentally with finite-difference measurements rather than assuming it. That factor is the bridge that lets a cheap observable stand in for the expensive one.
Sparsity is the second ingredient. Each detector responds only to the gates inside its detecting region, so the whole problem decomposes into thousands of small, overlapping sub-problems, and the gradient-masking trick that exploits this comes from Sivak, Michael Newman, and Paul Klimov’s 2024 work on decoder priors. The payoff shows up in the scaling simulations: convergence speed independent of system size out to distance-15 and roughly 40,000 parameters. To my thinking this is the deepest result in the paper, because it addresses the only term in the calibration problem that grows without bound. The caveat is that it is a simulated result. Correlated drift, crosstalk that rewires the sparsity structure mid-run, and the classical data-rate ceiling between the fridge and the learner are absent from the simulation and present on real hardware at that scale.
What ran on hardware and what ran in simulation
The hardware experiments come in two flavors. Fine-tuning, the source of the 20% figure and the record error rates, ran on a fully calibrated processor and is unambiguous. Steering, the source of the drift-tracking claims, ran as thousands of repetitions of a short quantum-memory circuit, with the logical state re-prepared from scratch on every shot. The authors are candid about why that detail matters: because each shot starts fresh, the exploration noise inherent to learning, the deliberately perturbed policies the agent must sample, could do no cumulative damage. In a real long computation there are no fresh starts. Every suboptimal sample the agent tries degrades the one logical state you have.
The scenario the abstract sells, continuous steering during a single uninterrupted logical computation, was tested in simulation only, on a distance-3 surface code under sinusoidal drift. The simulations find a critical drift frequency, around 1/150 epochs, below which the aggregate performance of all sampled policies still beats a frozen policy. Slower drift than that, and real-time steering wins. Faster, and the loop cannot keep up.
So the honest scorecard reads: mechanism demonstrated on hardware, flagship scenario demonstrated in silico. Both halves are true. Only one of them is in the title.
The supplementary material contains the paper’s most forward-leaning claim, and it needs qualification before anyone repeats it. The team reports recovering full performance after deliberately randomizing the control policy to fully scramble the logical observable, and the discussion floats the eventual possibility of calibrating a processor for QEC ab initio by RL alone. Read the fine print, though. The randomization covered the parameters inside the agent’s own control space, applied on top of a machine that had already been through conventional bring-up; the preprint describes the setup as emulating a coarse calibration, and the paper accordingly claims the potential to replace elements of the traditional calibration stack rather than the stack itself. Recovering the waveform layer without physics models is a real result. Calibrated from scratch by RL it is not.
Injected drift, natural drift, and the missing wall-clock
The 3.5-fold stability headline needs decomposing. Control steering alone delivered 2.4-fold against injected drift, along with a 24% cut in the logical error rate. The jump to 3.5-fold (and 31%) came from steering the decoder’s priors as well, and that component runs on logical-error estimation, which the authors themselves note is not straightforwardly scalable to real time. They cite alternative decoder-steering approaches that could remove the limitation; none is demonstrated here. Under natural drift, the measured benefit is a 4 dB filter on low-frequency fluctuations, roughly a factor of 2.5 in power terms, and only at low frequencies. (The November preprint claimed 6 dB; peer review trimmed it to 4.) Real and useful. Smaller still than the abstract’s number.
Then there is the question the main text never answers: how long is an epoch? Everything about the loop’s agility is denominated in epochs, the 130-epoch response time, the 1/150-epoch critical drift frequency, and an epoch is a batch of candidate policies times some number of QEC cycles each, plus the overhead of reprogramming the classical controller between candidates. My back-of-envelope reading puts an epoch somewhere between seconds and minutes of wall-clock time, which puts the 130-epoch response anywhere from a quarter of an hour to the better part of a day. Either end of that range is well matched to thermal drift and instrument aging, and hopeless for the fast events.
The fast events are real. Fabrizio Berritta’s group at the Niels Bohr Institute showed in February that a transmon’s T1 can switch between metastable values on tens-of-millisecond timescales, telegraph noise from two-level-system defects that slower measurements had averaged into a comforting constant. The Google authors concede the point in their own terms: drift too fast for the loop, including the correlated bursts from high-energy particle impacts, must be handled at the hardware level. RL steering owns the slow, secular component of drift. To be fair, that is exactly the component that forces today’s scheduled recalibrations, so owning it is no small thing. The millisecond monsters remain unslain.
The agent is a Gaussian
A word on the ‘AI’ in this AI story. The policy the agent learns is a factorized multivariate Gaussian, a mean and a variance per parameter, updated by policy gradients from the evolution-strategies family and stabilized with proximal policy optimization and entropy regularization. The authors chose that simplicity deliberately, since the data rate out of a dilution refrigerator cannot feed a neural-network policy. (A pleasing coincidence in the references: the PPO algorithm this work borrows was co-written by Oleg Klimov at OpenAI, while the project itself was supervised by Paul Klimov at Google. No relation, as far as I know. The field runs on Klimovs.)
Calling this an AI agent is defensible and will be misread anyway. What runs in this loop is closer to adaptive stochastic optimization than to anything in the AlphaGo lineage the introduction invokes, and I mean that mostly as praise. The simplicity is why the convergence behavior is analyzable, why it can keep pace with the data rates the hardware provides, and why I believe the scaling claims more than I otherwise would. Vendors will sell it as the machine that thinks about its own errors. What it does is arithmetic on parity statistics, relentlessly, which in this industry is worth more.
There is also a quiet labor story here. Calibration specialists are among the scarcest engineers in quantum computing, people who spend years learning to coax a particular fridge and chip into behaving. This paper describes, politely, the beginning of their automation; the authors imagine future processors tuned up with no human experts in the loop at all. Every industrial transition I have studied says the expertise moves up a level rather than vanishing, from tuning the machine to tuning the learner. The job as it exists today has still been put on notice.
Where this lands on the CRQC map
In my CRQC Quantum Capability Framework, this work belongs to capability D.3, Continuous Operation, the requirement that a fault-tolerant machine sustain computation for hours to days without interruption. D.3 has long carried the thinnest experimental record of any capability on the framework, a box on the roadmap everyone deferred. One paper has moved it from speculative to plausible. Few capabilities have jumped a tier on the strength of a single publication.
Two neighboring capabilities move with it. On D.2, Decoder Performance, the record is as much AlphaQubit2’s as the RL agent’s, and decoder steering opens a new axis of adaptation even if its current form cannot run in real time; the color code, for all this tuning, still trails the surface code by an order of magnitude per cycle at these sizes. On B.3, Below-Threshold Operation, the authors argue that deep below threshold, performance becomes limited by a swarm of low-probability error channels that the physics models behind traditional calibration do not capture, which is why they consider model-free in-context tuning necessary rather than merely nice. When the team that runs the industry’s most exhaustive calibration stack says model-based calibration has a ceiling, that is an admission against interest, and I weight it accordingly.
The arithmetic of small gains also reads differently at CRQC scale. A 20% cut in logical error at distance-7 corresponds to roughly a 5 to 7% improvement in the error-suppression factor Λ, the multiple by which logical error shrinks per step up in code distance. Carry the same control-quality gain to distance-15 and compounding turns it into roughly a one-third cut in logical error, with the effect growing further at the distances a CRQC demands. The transfer is an assumption, since the team only fine-tuned at distance-7 and below, but it is the right way to size the result.
Add the usual floor-not-frontier correction: this technique was already at work inside Google, applied in the magic-state cultivation experiment, before the paper became public. What we can read in Nature is where the lab stood months ago.
Does any of this move Q-Day? Not the headline year, on its own. Qubit counts did not change, and the silicon is the same; the gains come from extracting more performance out of existing controls and decoders. What did change is that one of the standing objections to the multi-day logical runs assumed by every serious cryptanalysis estimate, my own benchmark methodology included, now has a demonstrated answer in outline. USTC independently demonstrated below-threshold operation at distance-7 seven months ago; expect the steering idea to be replicated and extended just as quickly, since it needs no new hardware, only detection events and tunable controls.
For defenders, nothing here changes this quarter’s work, and that is the point I keep making. Migration deadlines were never keyed to Q-Day forecasts. Google’s own security team set 2029 as its PQC migration horizon well before its quantum team removed this barrier, and the regulators, insurers, and standards bodies that set your clock moved earlier still. Papers like this one confirm the direction of their bet without changing your deadline by a day.
What I will watch next: the epoch-to-wall-clock conversion pinned down in public, replication on trapped ions or neutral atoms, and above all the first experiment that steers during a logical algorithm rather than a memory run. When that lands, D.3 moves from plausible to demonstrated. The machine that never stops computing does not exist yet. The learning, though, no longer stops.
