Engineering

Quantum Computing's Magic Trick Finally Works on Real Hardware

By Tony Coppellotti, founder and CTO, Gordion Solutions. 16 October 2026.

For twenty years, every credible design for a useful quantum computer had the same embarrassing line item: most of the machine would be spent preparing one special resource, and only a sliver would do the actual computing. On 15 October 2026, Google Quantum AI published a paper in Science showing a way round that. It is the kind of result that does not make a quantum computer appear overnight, but it changes how big one needs to be, and that is the number everyone has been waiting on.

This piece explains what they did, in plain terms, and why it matters beyond the quantum lab.

Why quantum computers need magic

A qubit is a fragile thing. Heat, stray fields and the act of controlling it all introduce errors, roughly one in every thousand operations on the best hardware available. Useful algorithms need billions of operations. So a real quantum computer has to be error-corrected: you spread one logical qubit across many physical ones and keep detecting and undoing mistakes faster than they pile up. Google's Willow chip is the leading demonstration of this working.

Here is the catch. Once you are inside an error-correcting code, most operations are cheap and safe. But that cheap set, on its own, can be simulated on a laptop. The one extra operation that gives a quantum computer its edge over classical machines, called a T gate, cannot be done directly inside the code without exposing the qubit to uncorrected errors.

The workaround, known since 2004, is to prepare a special helper state off to one side and consume it to perform the gate. Physicists named these helper states "magic states", and the name stuck. Every T gate in a program burns one. A real algorithm needs millions to trillions of them.

The problem that ate the machine

Making magic states clean enough has been brutally expensive. The orthodox method, distillation, takes fifteen noisy copies and refines them into one slightly better copy, then repeats in stages. Each stage needs its own patch of error-corrected qubits. By the time you reach the purity serious algorithms require, the factories dominate the floorplan.

Google's own estimates put magic state production at up to 95% of a fault-tolerant machine. Picture a data centre where nineteen racks in twenty exist only to feed the twentieth. That ratio, more than any other single factor, is why the million-qubit machines in the roadmaps look so far away.

Grow it, don't distil it

In 2024 three Google researchers, Craig Gidney, Noah Shutty and Cody Jones, proposed a different idea they called cultivation. Instead of refining many bad states into one good one, grow a single state carefully from the start and throw it away the moment anything looks wrong.

The analogy is growing a crystal rather than purifying a solution. You start small, where a clean state is cheap to prepare. You run a tight sequence of checks that confirm the state is what it should be while simultaneously watching the qubits underneath for faults. If any check fails, bin it and start again. If it passes, you expand it into a larger code, keeping the checks running, so protection increases while the error does not. Finally you graft the grown state into the surface code that the rest of the computer runs on.

The statistics work because the checks are strict. A state that has survived every test is very unlikely to be wrong. So you reach high purity with a tiny footprint and accept a low pass rate instead of a vast qubit count. On superconducting hardware, where qubits are expensive and repetition is cheap, that is exactly the trade you want.

What Google showed

The paper, led by Emma Rosenfeld with Gidney, demonstrates cultivation working on Willow for the first time. The cultivated magic states had a logical fidelity of 99.99%, meaning one error in ten thousand, which is a record. That is about 40 times fewer errors than preparing the same state without cultivation. The team then grafted the states into a larger surface code using 54 of Willow's 105 qubits, proving the method can connect to the architecture a full machine would use.

Two supporting results are as impressive as the headline. First, the final calibration of the chip was done by a reinforcement learning agent, trained for about four hours before each run, which improved both error rate and yield by roughly ten times. Second, the team discovered that the standard way of measuring a quantum state was giving physically impossible answers under these conditions, and worked out why: slow noise was interacting with the filtering in a way that could silently flatter the result. They invented a new measurement method, kickback tomography, that uses the cultivation circuit itself as the ruler. The field now has a more honest benchmark because of it.

Why this is a big deal

It shrinks the machine. If cultivation holds up at scale, the factory that was 95% of the computer becomes a modest sideline. Qubits that were going to make magic states can run the algorithm instead. Every resource estimate for fault-tolerant quantum computing gets rewritten downwards.

The gains compound as hardware improves. Cultivation's error falls with the cube of the hardware's error rate, because three faults have to coincide to slip past the checks. Google projects that halving Willow's physical noise would cut cultivated-state error to about 2 in 100,000. Each hardware generation buys more than it used to.

It validates the aggressive timelines. In 2025 Gidney published a resource estimate putting the factoring of RSA-2048 within reach of a machine under a million noisy qubits, down from twenty million in 2019. That estimate assumed cultivation worked. This is the first hardware evidence that it does.

AI is now tuning the quantum computer. A ten-fold improvement from machine-learned calibration says the near-term wins in quantum are partly a software problem. Expect this to become standard practice, and expect the groups with the best control software to pull ahead.

What it means outside the lab

For most organisations the practical implication is cryptographic. Public-key encryption, the RSA and elliptic-curve schemes that protect almost everything online, is precisely what a large quantum computer breaks. Nobody can break it today: that would need magic states a million times cleaner than 99.99% and hundreds of thousands of logical qubits. But results like this pull the date forward, and anything you encrypt now that must stay secret for a decade is already exposed to a harvest-now, decrypt-later attacker.

NIST's post-quantum standards exist, the UK's NCSC has set 2035 as the migration deadline for critical systems, and Google's own target for its infrastructure is 2029. If you have not inventoried where your organisation uses public-key cryptography, this paper is a good reason to start. It is a programme measured in years, and the clock is not on your side.

Beyond security, the promise of quantum computing in chemistry, materials and optimisation has always been gated on fault tolerance. Cultivation does not deliver those applications, but it removes one of the largest obstacles between here and there.

The honest footnotes

This is a demonstration, not a product. Only about 8% of attempts survived the checks, and that yield will need to rise. Everything ran on a 54-qubit patch of a single chip. When the grafted states were held in storage, errors were about seven times higher than simulation predicted, most likely from qubits leaking out of their computational states, which the experiment was not yet designed to catch. Google says all of this plainly and lists it as the next work. Rival approaches exist too: QuEra demonstrated the older distillation method on neutral-atom logical qubits in 2025, and Alice & Bob published a low-cost scheme for cat qubits. Cultivation's edge is overhead on superconducting hardware, and which hardware wins is still open.

None of that diminishes the result. For two decades the bottleneck was a theory problem with no hardware answer. Now it has one.

Tony Coppellotti is Founder and CTO of Gordion Solutions, which delivers software and AI assurance as outcomes.

Sources