# Magic state cultivation on Willow: what it means, what's next

> On 15 October 2026 Google Quantum AI published in Science that magic state cultivation works on its 105-qubit Willow processor. Cultivated T states reached 99.99% logical fidelity, a 40-fold error reduction over plain injection, while keeping 8% of attempts, and were grafted from a distance-3 colour code into a distance-5 surface code on 54 qubits. Fidelity still has to improve by two to six orders of magnitude before useful algorithms can run on it.

URL: https://blog.bokvi.com/blog/magic-state-cultivation-willow/
Published: 2026-10-18
Tags: physics, hardware

**Google Quantum AI [published in Science on 15 October](https://www.science.org/doi/10.1126/science.aee7961) that magic state cultivation works on real hardware. On its Willow processor, cultivated T states came out with 40 times fewer errors than plain state injection and a logical fidelity of 99.99%, at the price of throwing away 92% of attempts. That matters because magic states were projected to eat [up to 95% of a fault-tolerant quantum computer](https://blog.google/innovation-and-ai/models-and-research/quantum-computing/magic-state-cultivation-quantum-computing/). If cultivation scales, the machine you need for a useful quantum algorithm gets a lot smaller.**

![A gloved hand holding Google's Willow quantum processor in its packaging, next to an illustration of a Bloch sphere with an arrow pointing between its axes](https://blog.bokvi.com/_astro/willow-chip-bloch-sphere.Cz-qqaL5_Z5qWa.webp)

*Willow, Google's 105-qubit superconducting processor, and the Bloch sphere where a T state sits halfway between the X and Z axes. Image: Google.*

## Why a quantum computer needs magic at all

Error-corrected quantum computers run on codes like the surface code, which spread one logical qubit over many physical ones and keep measuring parity checks to catch flips. Inside those codes one family of gates is cheap and naturally fault-tolerant: the Clifford gates, meaning Hadamard, S and CNOT. They are also, by the Gottesman–Knill theorem, exactly the gates a laptop can simulate efficiently. A circuit built only from them is not a quantum computer in any interesting sense.

To get past that you need one non-Clifford gate, and the standard pick is the T gate, a 45-degree rotation. The surface code cannot do it natively. The workaround, due to [Bravyi and Kitaev in 2005](https://arxiv.org/abs/quant-ph/0403025), is to prepare a special resource state, the T state, and teleport the gate into the computation using only Clifford operations and a measurement. The T state is what people call a magic state. Every T gate consumes one, and the state is destroyed in the process. So to first order the cost of a quantum algorithm is its T count, and the cost of a quantum computer is the cost of its magic state factory.

The catch is purity. The Willow paper puts the requirement at a magic state error of around 10⁻¹⁰ to factor an RSA-2048 key, and 10⁻⁶ to 10⁻⁸ for the chemistry and optimisation problems people actually want to run. No hardware prepares a state anywhere near that directly. The classical answer, magic state distillation, takes many noisy states, feeds them through a Clifford circuit that detects errors, keeps fewer but cleaner outputs, and repeats in levels. It works and it has been demonstrated, but it is expensive enough that Google's own framing is that distillation could occupy up to 95% of the machine. Craig Gidney and others have spent most of a decade whittling that number down.

## Cultivation is a filter, not a factory

In September 2024, Gidney, Noah Shutty and Cody Jones [proposed a different route](https://arxiv.org/abs/2409.17595). Instead of distilling many states into few, grow one. Start with a single noisy T state injected into the smallest useful colour code, distance 3, which is seven data qubits. The colour code is chosen because every single-qubit Clifford gate is transversal there: you apply it to each physical qubit independently, so errors do not spread. The T state is an eigenstate of the Hadamard operator, so measuring the logical Hadamard asks the state whether it is a T state without collapsing it to 0 or 1. The measurement is done by phase kickback: a T gate on every data qubit, the logical check folded down onto a single helper qubit, read out, and then the whole sequence run in reverse so the colour code's stabilisers come back and the helper qubits turn into flag detectors. If the answer is wrong, or any detector fires, discard and start again. Nothing is corrected. The state is filtered. Whatever survives is then grown into a larger code that can hold it.

The 2024 paper's pitch was that cultivation yields a T state for roughly the physical gate count of a lattice-surgery CNOT of equivalent reliability, and that its error drops so quickly with better hardware that "further magic state distillation may never be needed in practice." Gidney's May 2025 estimate that an RSA-2048 key could be factored with [fewer than a million noisy qubits](https://arxiv.org/abs/2505.15917) already leaned on it. Until this paper, all of that rested on simulation.

![Four stacked cards showing cultivation on Willow: inject one qubit into a distance-3 colour code, cultivate by folding the logical check onto one helper qubit, post-select keeping 8% of attempts, and graft into a distance-5 surface code](https://blog.bokvi.com/_astro/cultivation-pipeline.BALYQuXh_ZuvfJR.webp)

*The four steps as they ran on Willow, with the numbers from the paper. The 8% retention includes the extra checking rounds that were only there to measure fidelity.*

## What Willow actually measured

The experiment, led by Emma Rosenfeld with nearly 300 co-authors and [on arXiv since December](https://arxiv.org/abs/2512.13908), starts with the baseline nobody quotes in headlines. Inject a T state into the colour code and measure it without cultivating, and the logical error at the T state is 4.4×10⁻³. That is roughly the error of a single physical gate, which is the point: injection has no fault tolerance, so any slip on the one qubit that seeds the state becomes a logical error.

Add the cultivation round, with colour code error-correction cycles between rounds, and the logical error of the full circuit drops to between 1×10⁻⁴ and 2×10⁻⁴, an upper bound of 1(1)×10⁻⁴ on the state itself. That is the 40x. The full test circuit contains 216 two-qubit gates and 54 measurements, every one of them individually worse than the logical result. That is what fault tolerance looks like when it works. Remove the error-correction cycles from between the rounds and the error gets about 100 times worse, which tells you the colour code is doing real work rather than decorating the circuit.

The price is retention. Injection alone keeps 76% of attempts. Cultivation at the T angle keeps 8%, and that figure includes two extra cultivation rounds and three error-correction cycles whose only job was to measure the fidelity, so a production run would keep more.

![Horizontal bar chart on a log scale: cultivation with QEC cycles at one to two in ten thousand, injection only at 4.4 in a thousand, cultivation without QEC cycles about 100 times worse; below it, attempts kept: 76% for injection only and 8% with cultivation](https://blog.bokvi.com/_astro/cultivation-results.Es_7vY71_3G1fE.webp)

*Logical error and retention from the paper. Data: Rosenfeld et al., Science, 15 October 2026.*

Two details from the supplement deserve more attention than they will get. First, calibration: the team ran a reinforcement-learning agent over the control parameters for about four hours before taking data, which cut the error detection rate by around 30% and improved both the logical error and the retention rate by about an order of magnitude. Without it there is no result. Second, grafting: the cultivated state was moved from the distance-3 colour code into a distance-5 surface code, 54 qubits of Willow's 105, decoded with Tesseract because the hybrid code in between is not matchable. The purity survived the switch, which is a step the 2024 theory could only approximate, since simulating non-Clifford states at distance 5 is out of reach and the paper substituted Pauli states. The team is candid that idling in the grafted code ran about seven times worse than simulation, most likely leakage into higher transmon levels, and that the circuits had no leakage removal at all. The fidelity itself is in the same range as recent trapped-ion demonstrations, at superconducting speed.

## The data that looked unphysical

Google's blog post mentions that Rosenfeld's early data "seemed to defy the laws of physics". The supplement says what that meant: standard logical tomography returned Bloch vectors longer than one, a state purer than pure. The cause was coherent phase noise, slow qubit frequency drift and crosstalk, combined with post-selected tomography. Post-selection keeps different fractions of shots for each measurement axis, and with coherent rather than random noise that bias does not average out. The paper shows a perfectly pure seven-qubit state that comes out with a norm of 1.0016 in a noiseless simulation of the procedure.

The fix was partly engineering, echo pulses between pairs of Hadamards to cancel the slow phase, and partly a new instrument. Kickback tomography uses the cultivation circuit itself as the measuring device along the T axis: a second cultivation round acts as a check on the first, so the infidelity can be bounded with about 10⁴ shots instead of the roughly 10⁸ that standard tomography would need to resolve a 10⁻⁴ error. I think this is the quietly important part of the paper. As logical fidelities climb past what physical gates can do, measuring them becomes its own research problem, and the usual assumption that noise is Pauli and incoherent has to be checked rather than assumed.

## What has to happen next

The gap is still large, and the paper does not pretend otherwise. Willow is at 10⁻⁴. Chemistry and optimisation want 10⁻⁶ to 10⁻⁸. RSA wants 10⁻¹⁰. Four things decide how fast that closes.

**Physical noise, cubed.** Cultivation at distance 3 has fault distance 3, so the logical error scales as the cube of the physical noise strength. Halve the physical error and the state error falls by about eight; the paper projects around 2×10⁻⁵ from a two-times better processor, with the same tiny code. The 2024 paper also describes a distance-5 cultivation stage that the experiment did not attempt, which buys more. For the hardest targets a single light distillation pass may still sit at the end of the chain, but as a finishing step, not as the machine.

**Throughput.** Discarding 92% of attempts is acceptable for a factory that runs ahead of the computation and hands over states on demand, which is how magic states are consumed anyway. It is not acceptable if each T gate has to wait for a fresh attempt. Real-time T gates are on Google's own list of next steps, and retention will also rise as detectors fire less often.

**The plumbing.** Leakage removal units, which previous Willow experiments had and this one did not. Grafting into larger distances, where the idle error stops swamping the cultivation gain. Decoders for the hybrid grafted code, and the switch into a fully matchable surface code that the 2024 plan calls for after grafting.

**The assumptions underneath the scary estimates.** Gidney's sub-million-qubit RSA-2048 estimate assumes a gate error of 0.1%. The noise strength fitted to Willow in this experiment is about 2×10⁻³, roughly double that. So the estimate still describes hardware Google does not have, and today's result does not move the cryptography timeline on its own. What it does is replace one "assumed to work" line in that estimate with "measured to work at distance 3". That is how fault-tolerant quantum computing progresses now: not with a bigger qubit count on a slide, but with resource estimates turning, line by line, from simulation into data.

The number to watch is not the 99.99%. It is the 92% of attempts thrown away to get it, and how fast that shrinks as the hardware improves.