Google's 99.99% is one magic state, with failed runs thrown away

Magic state cultivation ran on real hardware. The 99.99% is the fidelity of a single prepared state, with an uncertainty as large as the error, not the accuracy of a quantum computer.

Research desk Google Quantum AI, Science Read on 16 October 2026

A logarithmic ruler of magic-state error from 1 in 100 to 1 in 10 billion. Marks at 4.4 in 1000 for an injected state, 1 in 10,000 for the cultivated state Google reports, a band from 1 in a million to 1 in 100 million for some simulation tasks, and 1 in 10 billion for factoring RSA-2048, with arrows for 40 times better and 1,000,000 times still to go. — A ruler, not the paper's data. The four marks are numbers from the preprint; the 1,000,000 times gap is our division.

The headline, and what it measures

On 15 October 2026 Google Quantum AI announced that its 105-qubit Willow chip had produced “magic states” with 99.99% fidelity, about 40 times fewer errors than the same chip managed without the new method. The paper, Magic state cultivation on a superconducting quantum processor, is in Science (doi 10.1126/science.aee7961). The same work has been on arXiv since 15 December 2025 as arXiv:2512.13908, with 295 authors. We read the preprint in full. The Science text is not open, so where we lean on it we say so.

Social posts turned this into “Google hits 99.99% accuracy”. That is not what the paper reports. The number is the fidelity of one prepared quantum state, a single logical qubit in a special state called a T state. It is not the accuracy of the chip, of its gates, or of a calculation.

What a magic state is

A quantum computer built on error-correcting codes can run some operations cheaply, directly on the code. The rest, in particular the T gate, cannot. The standard workaround is to prepare a special resource state, a magic state, and spend it to perform the gate. Each magic state is used once. A long algorithm needs a great many of them, and they have to be extremely clean.

The usual way to make clean ones is distillation: start with many noisy magic states and boil them down to fewer, better ones. The paper says that for factoring an RSA-2048 key the states need an infidelity near 10^-10, and that distillation sets a substantial resource bottleneck. Google’s blog repeats an estimate that magic-state production could take up to 95% of a machine. That is a planning estimate, not something measured on Willow.

What cultivation does instead

Magic state cultivation is a 2024 proposal by Craig Gidney, Noah Shutty and Cody Jones. Instead of distilling many states, you make one in a very small code patch and check it hard. The steps, as the paper describes them:

Inject a rough T state into a tiny colour code (distance 3, seven data qubits plus helper qubits).
Cultivate: use a helper qubit to measure the state along the T axis. A wrong answer, or any error alarm in the circuit, means the attempt is thrown away and restarted.
Reverse the circuit, so the code returns to its starting checks and every step doubles as another error detector.
If nothing fired, graft the state into a bigger surface code, where it can sit safely.

Google ran the first three steps on Willow and tested the graft from a distance-3 colour code into a distance-5 surface code on 54 qubits. The paper presents this as an experimental study of the protocol on a superconducting chip. The first figure below is the paper’s own picture of the circuit.

Figure 1 of the paper. Panel A shows the small colour-code patch on the chip with an inject label and a Bloch sphere with an arrow near the z equals x line. Panel B shows the cultivation circuit: a T gate, a controlled operation with a helper qubit prepared in plus, and a measurement that keeps the state only on a plus one result. Panel C shows fourteen small frames that fold the logical measurement down onto one qubit and then unfold it again. — Fig. 1 of Rosenfeld et al., arXiv:2512.13908 (licence CC BY 4.0, reproduced unchanged). A: the patch. B: the cultivation circuit. C: the measurement folded onto one qubit (frames 1 to 7) and unfolded (8 to 14).

The numbers, and how they were measured

Fidelity 0.9999(1). The bracket is the uncertainty in the last digit. The paper puts it as an upper bound on the error of 1(1)×10^-4: the error could be close to zero, or about twice 10^-4. The uncertainty is as large as the value.
40 times. The same measurement circuit without cultivation has a logical error of 4.4(2)×10^-3. Dividing 4.4×10^-3 by 10^-4 gives about 44, which the paper states as roughly 40. It is a comparison on the same chip, for state preparation only. It is not a 40-fold gain in the whole processor.
8% retained. The result counts only attempts in which no alarm fired. In the paper’s fidelity-measurement circuit, which includes two extra cultivation rounds and three error-correction cycles used to bound the answer, about 8% of the data survives. The measuring circuit is not the circuit you would run to simply produce a state, so 8% is not a clean price per state. In the plain cultivation experiment (Fig. 2D) a little under half the runs survive, as read off the plot by us.
How it was measured. Ordinary state tomography needs about 10⁸ shots to resolve an error near 10^-4. The team built a method called kickback tomography that uses cultivation to measure itself, with about 10⁴ shots. Their first data seemed to break physics. Drift in the lab electronics and temperature had invalidated the benchmark, so they added control and rebuilt it, as Google’s blog describes.

Figure 2 of the paper. Panel B plots the measured logical state on a circle: red crosses for injection only sit on the circle edge, while cyan diamonds for cultivation line up along a diagonal pointing at a yellow star, the magic state. Panel C zooms in on the star. Panel D plots the fraction of data retained against the injected angle: about 0.76 for injection, and a wave peaking near 0.45 at the T angle for cultivation. — Fig. 2 of Rosenfeld et al., arXiv:2512.13908 (CC BY 4.0, unchanged). B: red crosses are injected states anywhere on the circle; cyan diamonds are the cultivated states, collapsed onto the line that points at the magic state (star). D: how much data survives the filter.

What our figure shows

The top figure is a ruler, not data from the paper. It puts four numbers from the preprint on one logarithmic scale: 4.4 in 1,000 for the injected state, 1 in 10,000 for the cultivated state, the 10^-6 to 10^-8 band the paper names for some simulation and optimisation tasks, and 10^-10 for RSA-2048. The distance from the cultivated state to the RSA mark is 1,000,000 times. That division is ours.

In plain words

Imagine you need a perfectly cut gem and your cutting is shaky. Distillation is cutting hundreds and combining the best bits. Cultivation is cutting one, inspecting it under a bright light after every step, and tossing it the moment anything looks off. The ones that pass are very good. The cost is the ones you tossed.

What this does not show

It is not a 99.99% accurate quantum computer. It is one logical state, on a few dozen qubits, with failed runs removed.
It is not close to breaking encryption. The paper’s own number for RSA-2048 is about 10^-10. The result is 10^-4, a million times short, and a full factoring run needs far more than one good state. Your Bitcoin keys are not newly at risk.
The storage test fell short of simulation. The preprint says the grafted-code results differ from its simulation and suggests qubit leakage as a possible cause. The Quantum Insider, covering the Science version, reports the logical error rate about 7 times higher than simulated, with leakage the likely main cause. We have not read that number in the paper ourselves.
Not the first at this fidelity. The paper says the result is similar to recent trapped-ion demonstrations, and credits superconducting chips with being faster.
It is Google’s own result. We found no independent replication. The paper lists larger distances and real-time T gates as work still to do.

What the authors do claim is specific: cultivation works on hardware, and because the error should scale roughly as the cube of the physical noise, halving the noise would push the state error to about 2×10^-5.

Why a reader of this site should care

This is the same discipline as every claim here: ask 99.99% of what. Compare it with IonQ’s five-nines claim, which measures something different again. It sits next to the other error-correction results on this desk, the trapped-ion logical error rates and the lattice surgery on superconducting chips, and behind the idea of a logical qubit.

Sources

We read the sources above ourselves. Where a figure or number is ours, the article says so. If you find a mistake, tell us: a wrong sentence here gets logged like any other.