Google Ran Magic State Cultivation on Willow and Cut Magic-State Error 40-Fold. The Test Covered Only the Protocol’s Smallest Version.

15 Oct 2026 – Google Quantum AI researchers reported in Science that magic state cultivation, a method for preparing the resource states a fault-tolerant quantum computer consumes to run non-Clifford gates, worked on the company’s Willow superconducting processor. The team said it used cultivation to cut the error of an encoded T state about 40-fold, to an upper bound of one to two in 10,000.

The paper, Magic-state cultivation on a superconducting quantum processor, has 296 authors from Google Research, four US universities, NASA Ames Research Center and the Universities Space Research Association, with Emma Rosenfeld and Kevin Satzinger as corresponding authors. It was submitted on 16 December 2025, a day after the team posted the results as a preprint on arXiv, and accepted on 1 October 2026.

The experiment used the smallest version of the protocol, built on a distance-3 code. Its upper bound on T-state error is 1,000 to 2,000 times the 10⁻⁷ error rate assumed for cultivated T states in a 2025 estimate by Craig Gidney, a Google Quantum AI researcher and the paper’s second author. Gidney’s estimate describes a machine that factors a 2048-bit RSA key with fewer than one million noisy qubits.

Why Fault-Tolerant Machines Need Magic States

Superconducting processors encode logical qubits in two-dimensional error-correcting codes such as the surface code and the color code. The native fault-tolerant operations in these codes, transversal gates and lattice surgery, produce only Clifford gates. Circuits that start from stabilizer states and use only Clifford gates and Pauli measurements can be simulated efficiently on a classical computer. Universal computation therefore needs at least one non-Clifford gate, usually the T gate. The T gate is applied by preparing a separate “magic state” and consuming it through gate teleportation.

Each magic state is used once. In a blog post accompanying the paper, Rosenfeld and Gidney wrote that some estimates put the share of a quantum computer’s capacity devoted to making magic states as high as 95%.

The paper said factoring an RSA-2048 key requires magic states with errors of about 10⁻¹⁰, while some quantum simulation and optimization problems need between 10⁻⁶ and 10⁻⁸. The standard route to those levels, magic state distillation, introduced by Bravyi and Kitaev, combines many noisy states into fewer clean ones using operations on logical qubits.

Gidney, Noah Shutty and Cody Jones proposed cultivation in a 2024 paper. A noisy T state is injected into a small color code and checked by a fault-tolerant measurement of the logical Hadamard operator. As the paper defines it, the T state is an eigenstate of that operator; the textbook definition differs by a Clifford rotation. Any attempt that shows an error is discarded and restarted, and a state that passes is moved, or “grafted,” into a larger code that stores it with a low error rate.

The 2024 paper estimated from simulations that cultivation could reach logical error rates as low as 2×10⁻⁹ at a physical noise level of 10⁻³, and suggested further distillation might never be needed.

What Google Ran on Willow

The team injected a T state into a distance-3 color code, identical to the seven-qubit Steane code, on a patch of Willow’s square grid of transmon qubits. Rosenfeld and Gidney designed the injection circuit and the measurement protocol, according to the paper’s author contributions. Injection alone kept 76% of shots after those with detected errors were discarded.

Using logical state tomography, the team found that adding the cultivation step moved the measured logical states onto the magic-state axis and closer to the target T state. Close to half of the attempts prepared at the T-state angle were kept, which the authors said was consistent with the 2024 theory for the distance-3 case. They said they expected a much higher retry rate for the distance-5 version of the protocol.

How Google Measured Errors Near One in 10,000

The authors wrote that standard tomography would need about 10⁸ shots to resolve errors near 10⁻⁴. They also wrote that postselected tomography can overstate state quality when noise is coherent. They used cultivation as its own measuring device instead, a method they named kickback tomography, which resolves an error near 10⁻⁴ to an uncertainty of about the same size with on the order of 10⁴ measurements.

One cultivation round prepared the state, a second measured its T-state component and a third repeated that measurement to check it for errors. Only shots with consistent results and no detected errors were kept. The reported error includes errors made during the measurement itself, which makes it an upper bound.

Without cultivation, the logical error at the T state was 4.4×10⁻³, close to the processor’s physical gate error rates. With cultivation it fell to between 1×10⁻⁴ and 2×10⁻⁴, about 40 times lower and below the error of any of the circuit’s 216 two-qubit gates and 54 measurements. The abstract gives the state fidelity as at least 0.9999(1).

About 8% of shots were retained in this configuration, a figure that includes the two extra cultivation rounds and three error-correction cycles used to measure the state. Simulations using SI1000, a simple depolarizing noise model, at strengths of 2.3–3.0×10⁻³ approximately reproduced the measurements. The error was about 100 times worse when the team removed the color code’s error-correction cycles.

The team tuned control parameters with reinforcement learning. Device drift moved the logical error by about 1×10⁻⁴ over roughly an hour, the paper said.

Moving the State Into a Surface Code

In a second experiment using 54 qubits, the team grafted the state from the distance-3 color code into a distance-5 encoding compatible with the surface code, the code Google used in its 2024 below-threshold experiment. The grafted code mixes color-code and surface-code stabilizers, which the matching decoders used for the surface code cannot handle, so the team processed the data with Tesseract, a search-based alternative.

Cultivated states stayed concentrated along the T-state axis after grafting. At the target T state, grafted cultivated states were about as far from a pure state as grafted injection-only states. The paper said idle errors in the distance-5 grafted code limited both. The logical error rate in the grafted code was about seven times higher than simulations predicted, which the authors attributed to qubits leaking out of their computational states. They described the grafting result as a proof of principle and did not report a fidelity for the grafted state.

What Google Says Comes Next

Rosenfeld and Gidney wrote in the blog post that the work produced T states with a “record logical fidelity of 99.99%” and called it the first demonstration of a practical solution to one of the field’s most severe resource bottlenecks. They said cultivation still had to be demonstrated at a larger scale and that many technical challenges remained.

The paper’s list of next steps includes real-time T gates, grafting into larger code distances, better decoders and a switch after grafting to a code that matching decoders can handle. It projects that halving the processor’s noise would bring the T-state error bound to about 2×10⁻⁵ with the same distance-3 code. It also cites two September 2026 preprints describing an error mechanism that reduces the protocol’s fault distance at very low noise.

Google is the assignee of two patent applications related to the work, according to the paper. The data and analysis code are available on Zenodo.

My Analysis

When I last updated the Capability C.2 page of my CRQC Quantum Capability Framework in November 2025, I rated magic state production the capability furthest from ready, and a hardware demonstration of cultivation was on my list of milestones to watch. A month later Google posted a preprint reporting the first and smallest version of it on Willow, which I discussed in The Error Correction Revolution. The Science paper is the peer-reviewed version of that experiment, and it now cites the newer theory work on cultivation’s weaknesses.

For most of my readers, the practical change is narrower than the first-day coverage suggests. The experiment adds hardware evidence behind the magic-state part of Google’s sub-million-qubit RSA-2048 estimate without changing the size of that machine. Some chemistry and simulation workloads need much less from each magic state than the RSA-2048 benchmark, which makes them plausible earlier targets for cultivation.

What the Experiment Establishes

Until Google posted this experiment in December 2025, every number for cultivation came from simulations, most of which used a stand-in. As the paper notes, theory studies routinely replace magic states with Pauli eigenstates to keep simulations fast, so the 2024 cost estimates were largely computed on a closely related S-type state that a classical computer handles easily. Willow ran the real T-state circuit with real device noise.

Four things now have hardware support:

1. The projective measurement works. Cultivated states lined up on the magic-state axis even when the injected state was prepared off-angle. The error at the T state dropped 40-fold.
2. A simple depolarizing noise model is adequate for modeling the distance-3 cultivation circuits. Simulations with it approximately reproduced the measured logical-state components and the error and acceptance rates. That does not show that Willow’s noise is depolarizing. The paper discusses three effects the model leaves out: coherent noise, leakage and possible time-correlated phase noise.
3. The error-correction cycles interleaved with the cultivation rounds are essential. Without them the error was about 100 times worse.
4. A cultivated state can be moved from a color code into an encoding compatible with the surface code on the same chip. The experiment did not show that the state kept its 10⁻⁴-level quality after the move: at the target state, idle errors in the grafted code limited cultivated and injection-only states alike.

Other groups can reuse kickback tomography to benchmark magic-state preparation routinely, since at this error level it needs about 10,000 times fewer measurements than standard tomography. Google has also published the data and analysis code. In a September preprint, Aaron Hoyt and colleagues reanalyzed Google’s grafting records with an extra postselection step and reported 34.7% lower tomography infidelity at the cost of rejecting an extra 30% of grafting-stage shots.

What the 99.99% Figure Does and Does Not Mean

Google’s blog calls the 99.99% fidelity a record. The paper calls the fidelity state of the art and “similar to recent demonstrations in trapped ions.” Quantinuum, whose quantum computers use trapped ions, posted two magic-state preprints in June 2025, and I covered both when they appeared.

Quantinuum’s 7×10⁻⁵ is lower than Google’s bound but was measured in a distance-2 code that can detect a single-qubit error and cannot correct an arbitrary one. The Steane-code experiment is the closer comparison. Its error-corrected bound is higher than Google’s, and when the decoder also discards shots with detected errors, its bound falls to 1.5(1.1)×10⁻⁴, which overlaps Google’s range.

The methods differ as well: Google used kickback tomography, both Quantinuum teams benchmarked pairs of magic states, and the Steane-code team added single-copy logical tomography. The acceptance figures count different things, so none of them is a factory yield. On distance-3 codes, Google’s bound and Quantinuum’s error-detected bound cannot be told apart within their uncertainties, and calling either one a record goes further than the data allow.

The paper’s own case for the result is speed, since it matches the trapped-ion fidelities on hardware that runs error correction much faster. On neutral atoms, the QuEra, Harvard and MIT team’s 2025 logical magic state distillation tested the older route that cultivation is designed to shorten or replace.

Some of the first-day coverage, much of it on cryptocurrency news sites, treated the 8% retention figure as the cost of making a clean state. Decrypt wrote that only about 8% of attempts “passed every check” and concluded that more than nine in ten tries are thrown away for every clean state. In this experiment, every check included the two extra cultivation rounds and three error-correction cycles used to measure the state. The preparation step on its own kept close to half of the attempts at distance 3, in line with the 2024 theory.

Discards do become a real cost at the next size up. The authors expect a much higher retry rate at distance 5. Citing the 2024 paper, they also write that most of cultivation’s spacetime cost would come in the escape stage that grows the state into a large code. Willow has run that stage only up to distance 5.

How Much of Google’s RSA-2048 Estimate Depends on Cultivation

In a May 2025 paper, Gidney cut the estimated cost of factoring RSA-2048 from the 20 million noisy qubits of Gidney and Ekerå’s 2019 estimate to fewer than one million. He attributed the reduction to three changes: approximate residue arithmetic from Chevignard, Fouque and Schrottenloher, yoked surface codes for storing idle qubits, and magic state cultivation, which let him give less space to magic state distillation.

The compute region in Gidney’s physical layout runs six magic state factories. Each factory cultivates T states at a logical error rate of 10⁻⁷, at a cost of about 30,000 physical qubit-rounds per state. It feeds eight of them into one round of 8T-to-CCZ distillation, which produces the doubly controlled Z (CCZ) states that power the algorithm’s Toffoli gates. That distillation step suppresses the error quadratically, giving CCZ states below 10⁻¹², low enough to ignore against the 6.5 billion Toffoli gates in the algorithm.

By my arithmetic from his layout, the six factories occupy 72 distance-25 surface code patches, about 97,000 of the design’s 898,000 physical qubits. Gidney noted that his factories are much smaller than the 15-by-8 factories of the 2019 estimate because cultivation replaced the first stage of distillation.

The 10⁻¹⁰ figure in the Science paper describes the states the algorithm consumes at the end of that pipeline. In Gidney’s design, cultivated T states only have to reach 10⁻⁷, because distillation follows. Coverage that set Willow’s 10⁻⁴ against 10⁻¹⁰ and called the gap a factor of a million held cultivation to the standard of the final states, which Gidney’s design does not ask of it.

Willow’s measured upper bound is 1,000 to 2,000 times the 10⁻⁷ target. That ratio sets a bound that includes measurement error against a modeled operating point, so it gives only a rough idea of the remaining distance.

When Gidney published the estimate in May 2025, nobody had run cultivation on hardware. Google’s December 2025 preprint, now peer reviewed, added a hardware test at the smallest size, and the test agrees with the simulations. That is evidence for one component of the estimate, and it changes none of its numbers.

What Willow Showed Against What a Factory Needs

The two noise models differ, so the first row shows only the order of the gap.

Noise and code distance

The Google team projects that halving Willow’s noise, which would bring it close to Gidney’s assumption, would get distance-3 cultivation to an error bound of about 2×10⁻⁵. That projected bound is still 200 times the 10⁻⁷ design assumption. Reaching 10⁻⁷ will take the distance-5 version of cultivation, much lower physical noise, or both, and the team expects distance 5 to need many more retries.

Real-time decisions

Google filtered Willow’s shots after the experiment. In a factory, the decision to keep or discard each state has to be made in real time, before the state is used, with only the syndrome information available at that moment.

In a Harvard and MIT preprint, Rohan Mehta, Varun Menon, Hengyun Zhou, Mikhail Lukin and J. Pablo Bonilla Ataides timed their decision method at a median 25.3 µs per shot on one core of an Apple M4 processor, for a fault-distance-3 surface-code cultivation protocol, against 15.5 µs for the standard calculation it improves on. Superconducting qubits run an error-correction cycle about every microsecond, so at that speed a state would idle for around 25 cycles while the decoder decides whether to keep it. That benchmark comes from a different protocol run in simulation, so I use it only to illustrate the timing problem.

Mehta and colleagues wrote that on superconducting hardware both methods may need dedicated acceleration such as FPGAs, or the waiting could dominate cultivation’s cost. In my analysis of Google’s cryptocurrency resource estimate, I treated attacks on transactions in progress as plausible for fast-clock machines such as superconducting ones. For cultivation, a faster clock means less time for each keep-or-discard decision.

Grafting at scale

On Willow, the team moved the state into a distance-5 code whose error rate was seven times the simulated value, which the authors attributed to leakage. Gidney’s layout uses distance-25 patches, and the 2024 cultivation design grows the state into a distance-15 code. Google has worked on removing leakage in its earlier error-correction experiments. The authors expect leakage reduction units to address the problem here.

Consuming the state in a gate

No cultivated state was consumed in a logical gate on Willow. In the Dasu et al. experiment, Quantinuum used its magic states to run a logical controlled-Hadamard gate with an infidelity bound of 2.3×10⁻⁴, give or take 0.9×10⁻⁴, against about 10⁻³ for the physical gate. Google lists real-time T gates as future work.

Continuous operation

Factoring in Gidney’s design takes nine to ten runs of the quantum circuit, each lasting about 12 hours, for close to five days in total. During a run, each factory produces a CCZ state every 150 µs. The six together deliver one every 25 µs. By my arithmetic that is about 320,000 accepted T states per second across the six factories, before counting rejected cultivation attempts.

Willow’s logical error drifted by about the size of the result itself within an hour, and the team relied on reinforcement-learning calibration for the last gains in performance. Holding error rates steady through 12-hour runs is a separate capability, the one I track as continuous operation.

New Theory Papers Add to Cultivation’s Cost

Three groups have revised cultivation’s error and cost estimates in preprints posted since mid-September.

Tim Chan, Armands Strikis, Zhu Sun and Zhenyu Cai showed that the T-state double-check circuits in cultivation at distances 3 and 5 have fault distances of 2 and 3, not 3 and 5. The fault distance is the smallest number of faults that can produce an undetected logical error. Certain hook errors turn coherent after the final double check, a mechanism the S-state stand-in used in most simulations does not have. Chan and colleagues note that the distance-3 double check used in Google’s experiment has the same fault distance of 2.

Kwok Ho Wan and Ainhoa Zapirain computed the error rates of both cultivation circuits exactly and reached the same conclusion. For a distance-3 circuit like Google’s, a fault distance of 2 means the error falls roughly with the square of the physical error rate at low noise, where the design intended the cube.

Chan and colleagues also designed flags that restore the distance-5 double check’s fault distance of 5. In the full distance-5 preparation circuit they simulated, the flags raise the fault distance from 3 to 4, which is what that circuit was designed for. At a noise level of 10⁻³, adding the flags lowers the error before the escape stage by a factor of 4.9 and raises the attempts per accepted state by a factor of 1.36.

The flags need couplings between next-nearest neighbors, and the authors present them as a proof of concept that they do not intend to be built as drawn. Google’s Science paper cites the Chan and Wan preprints.

Mehta and colleagues looked at the escape stage. Published cultivation estimates assumed that the decision to keep a state could use information from a final, noiseless measurement of the finished state. A real factory cannot take that measurement without destroying the state it wants to keep.

With only the information available mid-circuit, the authors found that fault-distance-3 color-code cultivation performed almost exactly as the idealized estimates assumed. The fault-distance-5 color-code protocol reached 10⁻⁷ with about 10% more spacetime volume per accepted state and needed about 3.7 times the volume to reach 10⁻⁹. A surface-code variant needed about five times the volume to reach its 2×10⁻⁶ target. They list Gidney’s RSA-2048 estimate among the architecture proposals whose costs could rise. Their simulations use the same Clifford stand-in for the T state that the earlier estimates used. The authors name an exact T-state simulation with mid-circuit postselection as future work.

Taken one at a time, the results suggest a small penalty at the 10⁻⁷ level Gidney’s design uses for cultivated states. The penalty is larger for designs that rely on cultivation alone to reach 10⁻⁹ or lower. The combined cost is still open. None of the three papers simulates real T-state cultivation with the flag fix, a realistic escape stage and mid-circuit decisions together, so their figures are not a revised cost for Gidney’s machine. The claim under most pressure is the 2024 paper’s suggestion that distillation may never be needed, which Gidney’s own RSA-2048 design does not rely on.

Applications That Need Less From Each Magic State

Factoring RSA-2048 needs final magic states with errors near 10⁻¹⁰. The Science paper cites quantum simulation and optimization algorithms that need magic-state errors between 10⁻⁶ and 10⁻⁸, including a 2025 paper on electronic structure simulation. If halving Willow’s noise brings distance-3 cultivation to about 2×10⁻⁵, as Google projects, the remaining gap to the least demanding of those targets, 10⁻⁶, is a factor of 20. That makes these workloads plausible early candidates for cultivation without any distillation. Magic-state quality is only one requirement, though: gate and logical-qubit counts and the strength of classical methods determine which applications reach useful scale first.

In my Quantum Utility Map series I test quantum applications against realistic resource estimates, including drug discovery and catalysis in Quantum Chemistry’s Honest Ledger. The Error Correction Revolution covers cultivation together with qLDPC codes.

What This Means for Q-Day Planning

Willow has 105 physical qubits. Gidney estimated that his machine would need about 898,000 at less than half of Willow’s noise, running the circuit for about 12 hours at a time. This experiment adds no qubits and changes no published resource estimate. In my view it strengthens the evidence for one component of the sub-million-qubit design for a cryptographically relevant quantum computer. The integrated design and its operating assumptions remain untested, and the result does not change how I see the timing of Q-Day.

Gidney addressed timing himself in the 2025 paper. He agreed with the initial public draft of NIST’s IR 8547, which proposed deprecating quantum-vulnerable public-key algorithms at the 112-bit security level, RSA-2048 among them, after 2030, and disallowing quantum-vulnerable algorithms at every security level after 2035. I covered that draft when it appeared. Gidney wrote that he did not expect sufficiently large quantum computers by 2030 and preferred that security not depend on progress being slow.

Those dates, and the others regulators have set since, are what migration plans should be built on. A magic-state result at distance 3 does not change them.

Cultivation Milestones to Watch

• Distance-5 cultivation on hardware, with its retry rate reported.
• A keep-or-discard decision made mid-circuit at superconducting speed, with the state still usable afterwards.
• Grafting into codes larger than distance 5, with leakage removal running.
• A cultivated T state consumed by a gate on another logical qubit.
• Several states produced in sequence by the same patch, the first step toward continuous output.
• A version of the flag fix for T-state fault distance that works with nearest-neighbor couplings, tested on hardware.

I will update the Capability C.2 page as these arrive. The six factories in Gidney’s design together supply about 320,000 cultivated T states per second at 10⁻⁷. Willow has produced and measured them one at a time, with an error bound near 10⁻⁴.

From the author