Google Quantum AI demonstrates magic state cultivation on a superconducting processor

A Google Quantum AI team has demonstrated magic state cultivation on a superconducting quantum processor, an approach that had previously rested largely on theoretical proposals. According to the paper, submitted to arXiv on 15 December 2025 by Emma Rosenfeld, Craig Gidney, Alexis Morvan and a long list of co-authors, cultivation reduced the error of a prepared magic state by a factor of 40 and reached a state fidelity of 0.9999(1), while retaining 8% of attempts. The work subsequently drew attention on Hacker News.

The non-Clifford gate problem

Quantum error correction protects information by spreading it across many physical qubits, and the surface code is the leading candidate architecture for doing this at scale. The catch is that a code makes only some operations cheap. Clifford gates, the family a surface code can apply fault-tolerantly, are not universal on their own; a general-purpose quantum computer needs at least one non-Clifford gate, and, per the paper, paying for that gate is one of the biggest overheads in most error-correction architectures.

The usual workaround is magic states: specially prepared auxiliary states that can be consumed on demand to enact non-Clifford gates. Raw magic states come out noisy, so current plans rely on distillation, in which large dedicated circuits merge many noisy copies into a few clean ones. Distillation works on paper but is resource-intensive, and it is widely expected to consume a substantial share of a future machine's qubits and runtime.

From distillation to cultivation

Cultivation, the approach tested here, skips the factory. Instead of purifying many states from scratch, the processor grows a single high-quality magic state inside an error-correcting code: a candidate state passes through successive checks, attempts that show signs of error are discarded, and the survivors emerge progressively cleaner.

The arXiv paper presents cultivation as an efficient alternative to distillation, but notes that verifying its underlying assumptions is a difficult step beyond the quantum memory experiments that have dominated error-correction demonstrations to date. Storing information in a code is one thing; actively transforming states between codes and certifying their quality fault-tolerantly is another.

What the experiment showed

According to the paper, the team implemented the full cultivation procedure on their superconducting chip, including code-switching, in which the cultivated state is transferred into a surface code so that a larger computation can make use of it. To evaluate the result, they developed a fault-tolerant measurement protocol that bounds the magic state's fidelity rather than reading it out directly, since a direct measurement would consume the state.

The headline numbers: cultivation cut the error in the state by a factor of 40, landing at a fidelity of 0.9999, with the parenthetical digit indicating uncertainty in the last decimal place. About 8% of attempts survived the process, roughly one in twelve, so there is a clear trade-off between quality and yield. The authors' stated conclusion is that the results experimentally establish cultivation as a viable answer to one of quantum computing's most significant challenges.

Why it matters

Estimates for large fault-tolerant machines routinely identify magic state production as a dominant cost, with distillation hardware potentially taking up a large fraction of the total qubit budget. If cultivation keeps working as codes scale up, non-Clifford gates become dramatically cheaper, which shrinks the machine required for any given application.

This is a demonstration at research scale, not a scalable fault-tolerant computer: an 8% yield and 40-fold error suppression must hold and improve at larger code distances. But by putting measured numbers behind cultivation on a superconducting processor, the result moves a central assumption in fault-tolerance planning out of theory and into experimental territory.