Home » Quantum Computing » Google’s Magic State Cultivation Cuts Quantum Errors 40-Fold

Google’s Magic State Cultivation Cuts Quantum Errors 40-Fold

Google kept just 8 percent of its attempts to grow this quantum state. Here’s why that tradeoff might still be worth it.

Abstract glowing microchip representing Google's magic state cultivation quantum experiment

“We’ve shown that magic state cultivation works on Google Quantum AI hardware.” That’s the opening line Google researchers Emma Rosenfeld and Craig Gidney used on October 15, 2026, to describe a new experiment on the company’s Willow quantum chip. The claim is real, and a peer-reviewed paper in the journal Science backs it up, not just a press release. Google ran the test on actual hardware, not a simulation, and reports a 40-fold cut in the error rate for one of quantum computing’s most expensive ingredients. That part is verified. What hasn’t happened yet is a working, large-scale, fault-tolerant quantum computer. Here’s what the result actually shows, and where the evidence runs out.

What a magic state is, and why it’s so costly to make

Quantum computers need more than simple error-corrected logic gates to do truly universal computing. Some operations require a special ingredient called a “magic state,” a carefully prepared quantum state that unlocks gate types ordinary error correction can’t reach on its own. Each magic state gets consumed the moment a circuit uses it, so a useful quantum computer needs a constant, fresh supply.

That supply is brutally expensive to make clean. The Quantum Insider, reporting on Google’s study, notes that some resource estimates put magic-state production at up to 95 percent of a fault-tolerant machine’s total qubit budget. That figure describes projected overhead, not something Google measured on Willow itself, but it explains why researchers have spent years hunting for a cheaper way to grow these states.

Gidney, along with Noah Shutty and Cody Jones, proposed one such shortcut back in 2024: a process called cultivation. Instead of distilling many noisy states together the traditional way, cultivation injects one noisy state into a small patch of qubits, runs repeated measurements, and throws out any attempt that shows a flaw. What survives gets grafted onto a larger error-corrected code for actual use.

What the magic state cultivation experiment actually showed

Google ran this cultivation process on its 105-qubit Willow processor and compared the results against magic states made the older way. The cultivated states came out about 40 times cleaner. For one type of magic state, called a T-state, the team reports a logical fidelity of 99.99 percent, meaning an error rate no higher than roughly 1 in 10,000.

The team didn’t stop at making one clean state. They also tested whether a purified state could move between different error-correction codes on the same chip, a process called grafting. Using 54 qubits, they shifted a state from a smaller distance-3 color code onto a larger distance-5 surface code, the kind of code real fault-tolerant machines are expected to use. Reinforcement learning helped tune the process. Google says that training, roughly four hours for the headline result, improved both the error rate and the share of attempts that succeeded by about a factor of ten each.

There’s an interesting wrinkle in how they measured any of this. Rosenfeld’s account on Google’s blog describes an early benchmark that looked impossibly good, until the team traced it to electrical drift and temperature noise skewing their test equipment. They built a new measurement method, which they call kickback tomography, specifically so the reported number is a conservative lower bound rather than an inflated one.

“An important, incremental advance toward practical quantum computing” is how The Quantum Insider summed up the result after reviewing the published study.

Not the only team chasing this bottleneck

Google isn’t alone in trying to shrink the overhead of error correction. The company’s own researchers published a separate preprint earlier this month proposing a modular chip design that could cut error-correction overhead roughly tenfold, in simulation, by linking smaller chips instead of refining one big one. Alice & Bob takes a different route entirely. Its cat qubits suppress one common error type in hardware before correction even starts, which is part of why the company has been testing GPU-based decoding for its own error-correction codes. According to Quantum Zeitgeist’s reporting on an earlier preprint of this same cultivation work, trapped-ion machines have already reached comparable fidelities for some operations, though superconducting chips like Willow tend to run faster. No single approach has pulled ahead for good. Teams are attacking the same wall from several directions at once.

Where the evidence stops

  • Cultivation keeps only a fraction of its attempts. Quantum Zeitgeist’s reporting on the preprint puts the retention rate at around 8 percent, meaning most tries get thrown away before one clean state survives. That overhead isn’t part of the 40x headline number.
  • In a separate storage test, the logical error rate ran about seven times higher than simulations predicted, mostly from a problem called leakage, where a qubit slips outside the states the code expects. Google flags this as unfinished work.
  • The reported 40-fold gain applies to one task: preparing this specific state. It isn’t a measurement of the whole processor getting 40 times better.
  • Some real applications, including the kind of code-breaking math people worry about for encryption, would need error rates between 1 in a million and roughly 1 in 10 billion. That’s several orders of magnitude past what’s been shown here.
  • Google’s own paper, as reported by The Quantum Insider, states plainly that the work “does not necessarily establish that the resource problem has been solved at a practical scale.”
  • No outside lab has repeated this result. The only check so far is Science’s peer review, not independent replication.

Why It Matters to You

This result won’t change your electric bill or speed up your phone. The benefit, for now, is indirect and years away. If cultivation keeps working at larger scale, it could let researchers build smaller, cheaper error-corrected quantum computers than today’s resource estimates assume. That matters because every wasted qubit is a cost someone eventually pays, whether that’s a university lab, a hospital system, or a government research program. The most talked-about long-term stake for ordinary people is encryption: today’s banking and messaging security rely on math that a mature, fully fault-tolerant quantum computer could eventually crack. This result nudges that timeline forward a little, but Google’s own numbers show the error rates needed to actually threaten real-world encryption are still far out of reach. The more grounded hope, still unscheduled, is in drug and materials research, where a working fault-tolerant machine could eventually help scientists test candidate molecules faster than classical supercomputers do today.

The next thing worth watching is whether Google, or a competitor, can hold this error rate while scaling cultivation up by ten times or more, and whether they can fix the leakage problem that showed up in storage. If that happens within the next year or two, fault-tolerant quantum computing stops sounding like a research promise and starts looking like an engineering schedule. Until then, treat every new error-rate headline the way this one deserves to be treated: ask what fraction of attempts got thrown away to get there.

Sources

Related Reading