Google Quantum AI Shows “Magic State Cultivation” Working on Its Willow Chip, Cutting Errors About 40-Fold

Google Quantum AI says it has shown that a technique called magic state cultivation works on real quantum hardware, reducing errors by about 40 times on its Willow processor. The result targets one of the biggest costs on the road to useful quantum computers, though Google says the method still has to be demonstrated at a larger scale.

The work was described in a Google blog post by research scientist Emma Rosenfeld and quantum software engineer Craig Gidney on 15 October 2026, and published the same day in Science.

The “magic state” problem

Quantum computers are extremely prone to errors, so practical machines will need quantum error correction, which spreads information across many physical qubits to catch and fix mistakes. Many basic operations are relatively easy to protect this way. But to achieve what Google calls “universal” quantum computing, able to run any useful program, a machine also needs a particular kind of operation that is much harder to error-correct.

The usual workaround is to prepare special resources called “magic states” and use them to carry out those operations. The catch, Google says, is that making high-quality, error-corrected magic states is very resource-heavy. “Some estimates have shown that up to 95% of a quantum computer’s entire capacity might need to be dedicated to making them,” the post says, citing estimates it does not name. And each magic state can be used only once, making them a scarce resource.

Researchers have spent about 20 years trying to bring that cost down. The paper’s abstract describes the usual approach, distillation, as “resource-intensive.”

What cultivation does

Magic state cultivation was proposed in 2024 by Google Quantum AI researchers Craig Gidney, Noah Shutty and Cody Jones, building on an idea from earlier research. Google describes it as acting like a filter. A noisy state is placed into a small region of the chip, then a series of carefully coordinated measurements checks for errors and throws away flawed attempts. What survives is “an exceptionally pure, low-error quantum state” that can be moved into a larger, more useful error-correcting code.

According to the paper’s abstract, cultivation “reduces the error by a factor of 40, with a state fidelity of at least 0.9999(1) (retaining 8% of attempts).” In other words, most attempts are discarded, but those that pass are of very high quality. Google’s blog calls the result T-states, a common type of magic state, “with a record logical fidelity of 99.99%.”

The team also showed it could switch between two types of error-correcting code inside the hardware, “grafting states from a distance-3 color code to a distance-5 surface code.” Colour codes suit cultivation, while surface codes are, in Google’s words, “another, more established method.” The abstract describes this as “code-switching into a surface code.”

Update, 15 Oct 2026: Science paper details, and a tip credit (40x is an error cut, not a cost cut)

A tip that helped surface wider attention to this result came via @StockSavvyShay on X (verified via the X API on 15 October 2026). That post summarised Google’s Willow magic-state work and said production cost fell by about 40x. That cost framing is wrong for the 40x figure. Both Google’s blog and the Science paper (arXiv HTML) describe an error reduction of about 40-fold, not a cost reduction. TSN is keeping the tip credit for discovery, and correcting the metric.

From the paper’s abstract and experimental text:

• Cultivation “reduces the error by a factor of 40,” with a state fidelity of at least 0.9999(1) (the abstract writes “0.9999(1)”; Google’s blog rounds this as 99.99% logical fidelity for T-states).
• About 8% of attempts were retained after post-selection (“retaining 8% of attempts”).
• The 40x error reduction is relative to state injection (the paper: “roughly a 40-fold improvement in state infidelity, relative to state-injection”).
• The cultivated state was code-switched / grafted into a distance-5 surface code (abstract: “including code-switching into a surface code”; body: grafting from a distance-3 colour code into a distance-5 surface-code-compatible encoding).

None of those lines turns the 40x into dollars, qubits saved, or factory cost. Larger-scale demonstrations are still required, as Google already said in the original post above.

A measurement puzzle along the way

The work was not straightforward. Google says that when Rosenfeld first tested the protocol, the data “seemed to defy the laws of physics.” After months of checks, she traced it to an incorrect assumption in the team’s usual measurement method: lab noise caused by electrical equipment drift and temperature changes was undermining the benchmark.

The team added extra control to reduce that noise and invented a new benchmarking technique that uses cultivation to measure itself. The abstract describes this as a “fault-tolerant measurement protocol to bound the magic state fidelity.”

Google’s framing, and its caveat

Google calls the result “the first demonstration of a practical solution to one of quantum computing’s most severe resource bottlenecks.” The paper’s abstract says the results “experimentally establish magic state cultivation as a viable solution.”

Google is also clear about the limits. “We still need to demonstrate magic state cultivation at a larger scale to make it realistic for practical quantum computing, and plenty of technical challenges remain,” the post says.

What’s still unknown

Google has not said how many qubits a full-scale version would need, or how much cultivation would shrink a practical quantum computer compared with distillation. Neither has it given a timeline for a larger demonstration. Independent replication on other hardware has not yet been reported.

What to watch

Watch for larger-scale cultivation experiments, for other groups testing the technique on different hardware, and for updated estimates of how many qubits useful quantum algorithms will need.

What this means

• A key bottleneck tackled. Cultivation cut magic state errors about 40-fold on real hardware.
• High quality, many discards. Fidelity reached 99.99%, but only about 8% of attempts were kept.
• Not yet at scale. Google says larger demonstrations and further technical work are still needed.

Sources

1. Emma Rosenfeld and Craig Gidney, “Bringing the magic: Google breaks open a bottleneck in quantum computing”, Google blog, 15 October 2026
2. Rosenfeld, Gidney et al., “Magic state cultivation on a superconducting quantum processor”, Science, 15 October 2026
3. Shay Boloor (@StockSavvyShay), tip post on X, 15 October 2026. https://x.com/StockSavvyShay/status/2110796415589032431
4. Rosenfeld, Gidney et al., “Magic state cultivation on a superconducting quantum processor”, Science / arXiv:2512.13908. https://arxiv.org/html/2512.13908 ; also https://www.science.org/doi/10.1126/science.aee7961

Related stories

• Quantum Hardware Check: DARPA’s Final Test Stage, Universal Quantum’s $100m Round and New Error-Correction Results
• Quantum Roundup: A 42-Qubit Molecule Simulation, a Chip That Holds Photons, and Oratomic’s $775 Million
• IBM Research Says Open AI Agents Sped Up a Quantum Decoder Chip Design 52 Times for About $26
• IBM Quantum Launches “Directed Execution” in Beta: Mitigate Errors on Your Own Side, Run Circuits as You Direct