Errors as Telemetry: How Google Taught Willow to Tune Itself

Last week I followed a paper where error correction quietly exposed its own weak point: memory noise, the errors that pile up while a qubit sits idle and waits. This week Google Quantum AI asked a stranger question, and it reframed the whole picture for me. What if the errors a quantum computer makes could help run it? The paper is "Reinforcement learning control of quantum error correction," out of Google Quantum AI and Google DeepMind, in Nature.¹ Its ambition sounds almost like plumbing: build toward a quantum computer that can stay calibrated without pausing a long computation for recalibration. That modest-sounding goal is one of the real obstacles standing between today's machines and the long algorithms a useful quantum computer will one day need to run. This is a first reading of a single new paper, told as a notebook entry: what the experiment did, what it cost, and what it might mean for an investor watching the quantum-computing field. It is my own opinion, written to learn in public, and it is not a valuation and not financial advice. Do your own research.

Why a quantum computer drifts out of tune

A quantum computer is an analog machine wearing a digital costume. Quantum error correction, or QEC, supplies the costume: many fragile physical qubits are woven into one better-protected logical qubit, and the machine is measured over and over so that errors surface as "detection events," small flags that something went wrong somewhere in the circuit. Those flags let a decoder infer and undo the damage.

But QEC only earns its keep if the hardware is kept quiet, with the physical error rate held below a threshold of roughly $10^{-3}$ to $10^{-2}$. The controls that hold it there are analog: microwave pulse shapes, frequencies, coupling strengths. And analog things drift, with temperature, with materials, with time. Today the fix is blunt: stop the computation, run a calibration routine, start again. For an algorithm meant to run for days or months, that is like shutting a jet engine off in mid-flight every hour to re-tune it. The quantum state is not a saved file you can reopen where you left off.

Errors as a learning signal

Here is the turn that caught me. The very detection events QEC generates to correct errors also carry information about how well the machine is tuned: a control that has drifted throws off more alarms. Google repurposes them. The same flags used to fix the logical state become a training signal for a reinforcement-learning agent, or RL agent, a control method that learns by trial and reward.¹

I had pictured something cleverer than what I found. This is not a neural network that reads the error pattern and predicts the right settings. It is an optimizer. It nudges more than 1,000 control parameters, runs many QEC cycles, checks whether the detection events rose or fell, and shifts the next batch toward the settings that produced fewer. Think of tuning an instrument by ear: turn the peg, listen, adjust, except the machine turns a thousand pegs at once and listens for a quieter rate of errors.

Hand-drawn blue-pen loop diagram. A box labeled Willow, nudged by a drift arrow, feeds into a QEC box that emits a row of small flags labeled detection events. The stream forks: an upper path through a decoder box returns a logical correction arrow to Willow, and a lower path through an RL agent box returns a red re-tune controls arrow, closing the loop, beside a red caption reading errors as telemetry. — Figure 1: The same error flags, put to two uses. Detection events from quantum error correction are used as usual by a decoder to apply the logical correction (upper path), and are also repurposed as a training signal for a reinforcement-learning agent that continuously re-tunes the hardware controls as they drift (lower path).

The clever part: steering on a shadow

The elegant move is what the agent optimizes. The number you actually care about is the logical error rate, or LER: how often the protected qubit fails per cycle. But you cannot use it as a live steering signal, for two reasons. First, logical failures become exponentially rarer as the code distance grows, which is the whole point of a good code, so estimating the logical error rate directly would take exponentially more data. Second, during a real computation the logical state is unknown, so you cannot even tell whether it just failed.

So Google steers on a shadow of the real quantity. The surrogate objective is the average rate of detection events across all detectors,

$$\hat{C} = \mathbb{E}[D],$$

where $D$ is the set of detectors. It is cheap to read live, and for the small control changes tested here, fewer alarms generally pointed toward fewer logical errors, making the alarm rate a practical proxy for the failure rate. One more property makes it scale: each detector depends only on the handful of controls physically near it, not on the whole machine. That locality is why, in simulation, the learning speed did not slow as the code grew.

What it delivered

Does it work? Yes, in three escalating steps.

First, as a polish. Starting from a machine already tuned by conventional automated routines and human experts, RL fine-tuning shaved a further 20% or so off the logical error rate on the distance-5 codes. Separately, the full stack pushed a distance-7 surface code to $7.72 \times 10^{-4}$ errors per cycle with the AlphaQubit2 decoder,² which the authors report as a record across any qubit technology. A year earlier Willow reported $1.43 \times 10^{-3}$ per cycle below threshold,³ so the full system is clearly moving forward.

Second, as a steersman. Google deliberately injected drift into several controls, letting the calibration go stale the way it would mid-computation, and let RL adapt on its own with the human experts kept out. It held the logical error rate about 24% lower, and its fluctuations 2.4 times smaller, than a frozen calibration; retuning the decoder inside the same loop pushed those figures to 31% and 3.5 times steadier.¹ That stronger result includes decoder steering based on estimates of the logical error rate, a step the authors say is not yet straightforward to scale in real time. It even clawed its way back after its control policy was deliberately scrambled.

The machine gets bigger; the learning does not get slower.

Third, and the result I keep circling back to, as a method that might not break at scale. In simulation the authors ran the scheme up to a distance-15 code with nearly 40,000 control parameters, and the fitted convergence rate did not slow as the system grew. The machine gets bigger; the learning does not get slower. If that survives real hardware, calibration may not become the wall that quantum computers hit as they grow.

The price

Now the honest half. To keep learning as the hardware drifts, the search can never fully settle. A technique called entropy regularization keeps it sampling alternative settings, and most of those alternatives are worse than the current best. To keep learning, the machine has to make mistakes on purpose.

To keep learning, the machine has to make mistakes on purpose.

In the hardware experiment, that does not endanger accumulated quantum work, because every measurement is a fresh, independently prepared run. A bad trial only spoils that one throwaway shot, although it still costs time, data, and some performance. A typical learning epoch tested 40 candidate policies across roughly four million QEC cycles before making one update. But in a single long computation there is only one state, the one carrying the answer, and exploring a bad setting could damage it. The authors are careful here: uninterrupted, real-time steering during a live algorithm is shown in simulation, not on hardware.

There is also a speed limit. After a sudden jolt, the fitted response time was about 130 learning epochs. With each epoch currently taking 1 to 10 minutes, the characteristic response is measured in hours. The authors estimate the raw data collection could shrink toward seconds per epoch in a streamlined system, but as it stands, slow drift can be followed and fast drift cannot. Abrupt correlated disturbances, such as rare high-energy particle impacts that upset superconducting chips, happen too quickly for the current controller to follow and must still be handled in the hardware.

The detection-event proxy was also validated near the operating point, not under every unfamiliar or strongly correlated noise mechanism.

Hand-drawn blue-pen figure with two panels. In the left panel, titled slow drift, a dotted target curve changes gradually over time and a solid control curve follows it closely, captioned RL keeps up. In the right panel, titled fast drift, the dotted target curve swings rapidly while the solid control curve lags behind, opening a widening gap, captioned in red drift wins. A note beneath both panels reads cost: mostly worse trials. — Figure 2: Where self-steering helps, and where it cannot. When the hardware drifts slowly (left), the agent tracks the change and holds errors down; when it drifts too fast (right), the learner falls behind and the gap must be closed in hardware. The price of tracking at all is exploration: to keep learning, the machine must keep trying settings that are mostly worse than its current best.

The investor's read

So I put on the investor's hat, and this is the first time I have written about Google Quantum AI in this notebook.

The most useful thing the paper reveals is not a number, it is a shape. The near-term future of this field is not quantum hardware replacing classical computers. It is a hybrid stack: fragile quantum hardware holds the state, while a surrounding wall of classical systems prepares it, controls it, decodes it, and now tunes it. This paper is a small proof that the classical wall is becoming as important as the qubits it surrounds.

If that is the shape, Alphabet is unusually positioned to build the whole thing in-house. It has the Willow processor. It has Google DeepMind, whose AlphaQubit family of neural-network decoders already reads Willow's errors with state-of-the-art accuracy.⁴² It has the control software. And it has custom AI silicon: the seventh-generation Ironwood TPUs, with an eighth generation now announced.⁵⁶ Few competitors own all of those layers at once. Tellingly, this very paper still runs its neural decoder separately from the RL controller, and does not yet put a TPU inside Willow's live control loop. The moment I will watch for is when those pieces fuse into one real-time system.

The credibility is real. Willow has a peer-reviewed below-threshold result,³ and Google has already demonstrated specialized quantum experiments that it argues are beyond practical classical simulation.⁷ This is not a company entering quantum computing through a press release. It has been building the hardware, software, and scientific base for years.

And now the caution. Quantum contributes no material revenue today, filed in Alphabet's annual report as a moonshot, a frontier bet rather than a business.⁸ For an investor, that cuts both ways. It is nowhere near moving Alphabet's earnings, but Alphabet can fund a long and uncertain quantum program without depending on quantum revenue or repeated capital raises. That patience may be its single biggest advantage in this field.

Where I land

Error correction is becoming more than a shield. It is becoming telemetry.

Two hats, one conclusion. As a physicist, I came away a little disappointed that the "AI agent" is disciplined trial and error rather than a mind that predicts, and then more impressed the longer I sat with what that trial and error pulls off across a thousand drifting knobs. As an investor, the line that stays with me is this: quantum error correction is becoming more than a shield. It is becoming telemetry, a live readout of the machine's health that the surrounding classical system can act on. If that is where the field is heading, then the classical machinery wrapped around the qubits may end up mattering as much as the qubits themselves, and Alphabet happens to own an unusual amount of it. Important, and unusually well-funded, but still early.

Sources & notes

V. Sivak, A. Morvan, M. Broughton, et al. (Google Quantum AI and Google DeepMind), "Reinforcement learning control of quantum error correction," Nature (2026). DOI: 10.1038/s41586-026-10759-2. Source for all quantitative claims here unless noted otherwise: the physical error threshold near $10^{-3}$ to $10^{-2}$; the surrogate objective as the average detection-event rate; the exponential suppression of logical error with code distance and, for small control changes, the proxy relation between the detection-event rate and the logical error rate; the more than 1,000 controlled parameters; the 20% fine-tuning improvement on the distance-5 codes and the distance-7 surface-code record of $7.72 \times 10^{-4}$ per cycle; the 24% and 2.4-fold steering results, rising to 31% and 3.5-fold with decoder steering, and the note that decoder steering relies on logical-error-rate estimates not yet straightforward to scale in real time; recovery from a scrambled control policy; the distance-15, roughly 40,000-parameter scaling simulation and its size-independent fitted convergence rate; entropy regularization and exploration noise; the roughly 40-policy, four-million-cycle learning epoch; the fitted response time of about 130 epochs, 1-to-10-minute epochs, and the estimated few-seconds-per-epoch streamlined figure; and the point that uninterrupted real-time steering, and mitigation of fast correlated drift, are shown in simulation or left to hardware.
A. W. Senior, et al. (Google DeepMind and Google Quantum AI), "A scalable and real-time neural decoder for topological quantum codes," preprint at arXiv:2512.07737 (2025). AlphaQubit2, the neural-network decoder used for the distance-7 surface-code record reported in the paper read here. A preprint, not yet peer-reviewed.
Google Quantum AI and Collaborators, "Quantum error correction below the surface code threshold," Nature 638, 920-926 (2025). DOI: 10.1038/s41586-024-08449-y. The earlier Willow result, reporting a distance-7 surface code at about $1.43 \times 10^{-3}$ logical error per cycle and error suppression that grows with code distance.
J. Bausch, A. W. Senior, F. J. H. Heras, et al. (Google DeepMind and Google Quantum AI), "Learning high-accuracy error decoding for quantum processors," Nature 635, 834-840 (2024). DOI: 10.1038/s41586-024-08148-8. The original AlphaQubit neural-network decoder; its successor, AlphaQubit2, is cited separately above.
Alphabet Inc., 2025 Annual Report, shareholder letter, which describes Ironwood as the company's seventh-generation Tensor Processing Unit and says it is now shipping. Company statement, cited to describe Alphabet's own AI-infrastructure roadmap.
Google, "Our eighth generation TPUs: two chips for the agentic era" (April 2026), and Alphabet Inc., 2026 First Quarter Earnings Call. Google announced the eighth-generation TPU 8t and TPU 8i platforms. Company statements, cited to describe Alphabet's current TPU roadmap.
D. A. Abanin, et al. (Google Quantum AI), "Observation of constructive interference at the edge of quantum ergodicity," Nature 646, 825-830 (2025). DOI: 10.1038/s41586-025-09526-6. The "Quantum Echoes" experiment on Willow, reporting a verifiable speed advantage over classical supercomputers on an out-of-time-order-correlator task.
Alphabet Inc., Annual Report on Form 10-K for fiscal year 2025, "Moonshots" discussion, which lists quantum computing among frontier technologies pursued as long-term bets alongside efforts such as Waymo and Isomorphic Labs, and does not report it as a revenue business. Company framing, cited to convey Alphabet's own positioning of quantum computing.