Google's 99.99% magic-state result is old data from a small, filtered test
Science published Google's magic-state cultivation result on 15 October, but the data has been public since December 2025. The error is about 1 in 10,000 in just 8% of attempts. That is a real cost cut, measured at the front of a much longer process.
A fault tolerant quantum computer cannot run useful programmes with only the gates its error correcting code supplies for free. It needs one more gate. That gate runs on special resource states, called magic states, which are costly to make and can be used only once. Google's own blog notes that some estimates put up to 95% of a machine's capacity on producing them.
A cheaper way to make them matters. On 15 October the company said that magic state cultivation works in practice on its Willow processor, cutting errors about 40 times. The cost cut is real, but the headline fidelity describes a filtered state on a small patch of qubits.
The result predates the announcement. The experiment appeared as a preprint on arXiv on 15 December 2025, with Craig Gidney and about 300 co authors. Google's blog calls the paper published in Science. Google says the Science paper carries the same experiment, so the data have been public since December 2025.
The "40 times" is measured against state injection, the simplest way to prepare a magic state. The comparison is not with distillation, the incumbent method that turns many noisy states into one cleaner state.
In the preprint, injection leaves an error of about 4.4 in 1,000. The cultivated circuit "hovers between 1x10^-4 and 2x10^-4". Dividing one by the other gives between 22 and 44 times, which the paper rounds to roughly 40 times.
The "99.99%" figure is filtered. The abstract reports a fidelity of 0.9999(1) while "retaining 8% of attempts". That means 92% of runs are thrown away, so that circuit needs about 12.5 runs for each one kept.
The paper's figure is "an upper bound of 1(1)x10^-4 error, after discarding instances with detected errors". So the number describes the survivors. Injection alone kept 76% of its data, in a shorter circuit, so cultivation buys its lower error by being far pickier. That is the idea Gidney, Shutty and Jones proposed in 2024: catch flawed attempts early and discard them.
The retention figure matters for the bill as much as the error does. The 8% belongs to the kickback tomography circuit, the measurement run that adds two extra rounds of cultivation and three error correction cycles. A factory would not need those extra rounds. The paper gives no retention for a factory stage, so the true cost per state is still open.
The paper says the error of the full circuit "hovers between" 1 and 2 in 10,000. For the state itself it quotes an upper bound of 1(1) in 10,000, which is where the headline comes from. So the 22 to 44 times is the gain in circuit error, and a reader should treat it as a range rather than a single number.
Scale is the other limit. The paper's simulations of the grafting experiment, which places the cultivated state inside a larger error correcting code, cover 54 qubits. Google's 2024 Willow post set a separate target of a logical qubit error of 1 in a million. It said that would need more than a thousand physical qubits per surface code grid. That is a different quantity from the magic state error, so the two should not be stacked. Both show the distance between a clean small patch and a clean machine.
Closing that gap depends on hardware noise. The paper expects the error to scale as the cube of the physical noise strength. It says that halving the noise should bring the upper bound to about 2x10^-5. Quieter hardware is therefore the lever: it reduces magic-state error at the cube, while adding qubits alone pays back more slowly.
Willow's earlier record shows why that lever works. In December 2024 Google reported on a 105 qubit chip that its logical error fell by a factor of 2.14. That happened with each step in code distance from 3 to 5 to 7. Code distance is the size of the error correcting grid, so that was the first sign below threshold, where a bigger grid helps rather than hurts.
Yet the cultivated state did worse than expected inside a larger code. When it was grafted into a distance 5 surface code, the preprint's supplement reports a logical error rate about seven times higher than simulations expected. That came from a memory experiment, which idles the grafted code for extra error correction cycles. The authors say the main source is likely leakage, where a qubit drifts out of its working states.
Cultivation was never meant to finish the job. Distillation is the incumbent route, and the paper calls cultivation an alternative to it. In practice cultivation replaces the first distillation round, while later stages still polish the state. A state at 10^-4 is what those later stages, a small distillation round or a larger code distance, convert to something far cleaner at modest cost. The front stage is the claim, and it holds.
So far, the result is one filtered state in a small patch. The preprint warns that post selected tomography, which measures only the runs that were kept, can overestimate purity when noise is coherent. Google's blog says it still needs to demonstrate cultivation at a larger scale. The cost of the whole chain at useful size has not been measured.
The paper lists grafting into larger code distances and real time T gates as future work. Until a larger distance run is published, 1 in 10,000 after discarding most attempts is the figure on the table. The 2x10^-5 that halved noise would give is a projection.