Google has taught its quantum chip to self-adjust while it computes

A quantum computer constantly goes out of tune. Not once a year: continuously, while it works. Until now, the solution was always the same: stop the computation, manually recalibrate, restart. Google Quantum AI has just published in Nature, on July 8, a method that eliminates this pause: the machine self-adjusts on the fly, learning from its own mistakes. Announced result: about 20% fewer errors and 3.5 times better stability.

This is the kind of announcement that doesn't make much noise because it doesn't break any speed records. It simply solves a plumbing issue that prevented these machines from running for more than a few hours at a time.

The problem: a machine that goes out of tune by itself

A quantum chip manipulates qubits (the qubit is the quantum equivalent of a bit, except that instead of being worth 0 or 1, it can hold a mixture of both until it is read). To control them, we send them electrical signals that need to be finely tuned in frequency, amplitude, and phase. Thousands of adjustments, literally.

Except these adjustments don't stay good. The temperature shifts slightly, a component ages, and yesterday's perfect value becomes today's mediocre value. This is called drift (the parameters slowly move away from their optimal point without warning). Imagine a piano with a thousand strings that goes out of tune by itself while you play, and the tuner who has to interrupt you every two hours. That's the atmosphere.

The trick: recycle a signal that already existed

What makes the paper clever is that it doesn't add any sensors. It reuses data that the machine was already producing and half-throwing away.

To survive its own errors, a quantum computer continuously runs a correction code (it spreads a single useful piece of information across dozens of physical qubits, allowing it to detect and fix an error without having to read the information itself, which would destroy it). This code continuously spits out error detections: small signals that say "something happened here" without specifying what exactly. Normally, this is only used to fix the ongoing computation.

Google gives these detections a second job: feeding a reinforcement learning agent (an AI that doesn't learn from a fixed dataset, but by trial and error, keeping what reduces its error score and discarding the rest). The agent reads the stream of errors, turns the knobs, checks if it gets better, and repeats. More than 1,000 control parameters adjusted live, on the Willow chip, without ever pausing the computation.

The numbers

On a system already calibrated by human experts, the agent still scrapes off 20% of the logical error rate (the frequency at which an error passes through the correction and truly corrupts the result). This is the most telling figure: it's not 20% taken from a poorly tuned machine, it's 20% taken from the best manual calibration available.

The researchers then intentionally injected drift into the hardware to see who holds up. With the agent at the controls, stability is 3.5 times better. And during these tests, the error rates drop below one error per thousand correction cycles with the surface code, and one per hundred with the color code (two competing ways to organize the correction, the first being more economical, the second more practical for certain operations).

The point that interested me the most is elsewhere, in the simulations: they scaled up to about 40,000 parameters to control, and the number of iterations needed for the agent to learn does not increase with the size of the system. In other words, it doesn't collapse when the machine grows. For a technology whose entire bet is to move from 100 qubits to hundreds of thousands, this is exactly the property we want to see.

A useful reminder: Willow is the 105-qubit chip that Google released in December 2024, which showed that the error rate decreased when adding qubits instead of exploding. Here we are not changing the hardware, we are changing the way to operate it.

What it really means

Let's stay clear-headed about two things. First, the drift in the stability test was artificially introduced by the researchers, which is convenient for clean measurement but remains a laboratory scenario. Second, the authors themselves write that they need tighter integration between the agent and the processor, and better learning methods, to go further. Translation: it's a nice demonstration, not a finished product.

Personally, what I like about it is the frugality of the solution. No new hardware, no additional sensors, no extra qubits to pay for. Just a stream of data that we had right under our noses and were only using halfway, connected to an AI that turns the knobs better and more often than a human. If you want to dig deeper, Google's post is here, the free version of the paper is on arXiv, and The Quantum Insider has made a more detailed summary than mine.