Seemingly tiny quantum errors may determine whether future quantum computers become useful machines or remain impressive but fragile experiments. On 15 October 2026, Google Quantum AI announced a significant result on its Willow processor: a technique known as magic state cultivation reduced the error of an essential logical resource by roughly 40-fold compared with the uncultivated version, and produced so-called T-states with a logical fidelity of about 99.99%.
The headline may sound as though Google’s entire quantum computer had become 40 times more accurate. That is not what the experiment shows. The reduction concerns the preparation of special quantum states used for universal fault-tolerant operations. Yet that is precisely why the result matters: these “magic states” are among the most costly components of an error-corrected quantum computer.
In quantum computing, the raw number of qubits readily makes for an eye-catching headline. But one million highly noisy qubits may be less useful than a far smaller system able to build stable logical qubits and perform millions of operations without errors ruining the calculation. The next stage of the quantum race is therefore not simply “who has the most qubits?” but who can make them reliable enough.
For related context, see Asteroid impact: what humanity can do if it discovers one only months in advance, which provides further relevant information.
Why quantum errors are so common
A classical bit can be 0 or 1, and can be copied, checked and regenerated relatively easily. A qubit can exist in a superposition of states and be correlated with other qubits through entanglement. Those properties give it computational power, but also make it extremely sensitive to its environment.
Electromagnetic noise, thermal fluctuations, imperfections in control pulses, unwanted interactions between qubits and natural decoherence processes can alter its state. Even intended operations—quantum gates, measurements and resets—introduce errors of their own.
In Willow’s initial technical specification, Google reported average single-qubit gate errors on the order of hundredths of a percent, and two-qubit gate errors on the order of a few tenths of a percent. These are notable figures for quantum hardware, but enormously high if the goal is to run algorithms requiring millions or billions of successive operations.
If each operation carries a small probability of error, a very long circuit quickly accumulates problems. Useful quantum computing needs a solution that makes the effective error far smaller than the error of each physical component.
A physical qubit is not the same as a logical qubit
This is one of the field’s most important distinctions. A physical qubit is the actual hardware element: a superconducting circuit, a trapped ion, a neutral atom or another controllable quantum system. A logical qubit is information protected by an error-correction code using several physical qubits or several quantum levels.
In a highly simplified sense, the idea resembles redundancy in classical systems. If information is distributed intelligently, it is possible to detect that one component has behaved incorrectly and reconstruct the logical state without directly measuring the quantum information being protected.
That final detail is crucial. In quantum mechanics, an unknown state cannot be copied at will, and a direct measurement can destroy superposition. Quantum codes use auxiliary measurements—known as syndromes—which reveal where an error may be without extracting the underlying logical value.
The Willow milestone: more qubits began reducing, rather than increasing, logical error
Google had already reached an important threshold before the 2026 result. In its Nature paper on Willow, the team demonstrated operation below the surface-code threshold: as the logical code was enlarged, the logical error rate fell exponentially.
This is the fundamental condition for scaling. If adding physical qubits creates more errors than the code can correct, a larger system becomes worse. If hardware operates below a certain error threshold, adding redundancy can progressively improve the logical qubit.
In plain terms, in a fault-tolerant quantum computer, more hardware must buy greater precision. Without this property, a processor with millions of qubits could merely be a very large machine producing unreliable results.
What magic states are—and why they have become such a major problem
Error correction does not automatically solve every operation required by a universal quantum computer. Many fault-tolerant architectures can perform a family of operations called Clifford operations relatively efficiently, but universal computation also requires non-Clifford operations, especially T gates.
A standard approach is to prepare special quantum states called magic states. They are consumed to implement T gates through a process known as gate teleportation. Once used, such a state cannot be recycled for the next operation.
The problem is cost. Traditional magic-state distillation methods start with many imperfect states and use complex circuits to produce fewer, high-fidelity states. For very large algorithms, magic-state factories could take up a dominant share of a machine’s physical resources.
Google notes that some estimates have put this cost at up to around 95% of the physical capacity of a fault-tolerant quantum computer. If that burden can be reduced, the same practical task could require substantially less hardware.
What “magic state cultivation” means
Magic state cultivation seeks to obtain a very clean logical state directly, rather than passing through the large distillation factories traditionally designed for this purpose. Conceptually, the protocol starts from an imperfect state in a relatively small code and performs a series of very stringent checks.
If the checks detect indications of an error, the attempt is discarded. If the state passes the tests, it is progressively “cultivated” and transferred into a larger code capable of protecting it for later use.
It resembles an industrial process with rigorous quality control: rather than repairing every defective product, it aggressively filters batches and retains only results meeting the criteria. The difference is that these checks must be designed to protect the quantum information.
The 2026 result: error reduced by about 40-fold
In the experiment published in Science, the Google Quantum AI team implemented the protocol on Willow superconducting hardware. Compared with states prepared without cultivation, the protocol reduced error by roughly 40×.
The resulting T-states had a reported logical fidelity of about 0.9999, or 99.99%. One important detail is that the protocol retained only around 8% of attempts. The rest were rejected by the error checks.
The advance is therefore not “getting any state 40 times better for free”. There is a cost in rejected attempts, time, measurements and auxiliary qubits. The potential advantage is that the method could be much more efficient than conventional distillation when integrated into a larger fault-tolerant architecture.
The experiment also demonstrated a transfer—“grafting”—between a distance-3 color code and a distance-5 surface code, showing that a cultivated state can be moved into a code type better suited to storage and subsequent operations.
Why 99.99% is not yet enough for every algorithm
99.99% sounds close to perfect. But if an algorithm needs millions or billions of operations, an error in one out of every ten thousand uses may still be too high. Large-scale fault-tolerant computing requires logical error rates that can fall far below this level, depending on the algorithm and architecture.
That is why researchers talk about scaling, rather than the record of a single experiment. They must show that fidelity remains high as the number of qubits grows, as many states are produced in succession and as those states are consumed by long algorithms.
Google itself stresses that magic state cultivation must be demonstrated at a larger scale before it can become a practical component of a universal machine.
Why “one million qubits” can be a misleading metric
The quantum industry uses several hardware technologies, and there is no simple conversion between the qubit counts of two different processors. A qubit with long coherence, highly accurate gates and strong connectivity may contribute more to a useful system than a much larger number of noisy qubits.
More importantly, fault-tolerant applications will be measured in logical qubits and logical operations, not merely physical components. IBM, for example, describes its 2029 Starling target in terms of roughly 200 logical qubits and 100 million quantum operations. Those values say more about the kind of algorithm that may be possible than the chip’s simple size.
In 2026, Microsoft also proposes the concept of “scalable logical qubits”, assessed across four dimensions: reliability, scale, capability and performance. The message is the same: a logical qubit is not useful simply because it can be created once; it must be maintained, operated universally, decoded in real time and replicated in hundreds or thousands of instances.
The race is not only between Google, IBM and Microsoft
In 2026, advances in error correction are coming from several directions. Researchers demonstrated in Nature Physics correction of a logical qubit encoded in the internal states of a single atomic ion, reducing errors by up to about 2.2-fold and extending the qubit’s lifetime.
Other teams are working with bosonic qubits, neutral atoms, trapped ions, superconducting qubits and qubits with detectable erasure errors. It is not yet clear which architecture will dominate, or whether commercial systems will combine several techniques.
That makes comparisons based on raw qubit counts even more problematic. Two machines with 1,000 qubits may have radically different performance, connectivity and error-correction costs.
AI is beginning to help control quantum errors
In July 2026, a Google Quantum AI team published a reinforcement-learning system in Nature for controlling error correction. The algorithm was trained to calibrate processor parameters with the aim of reducing error-detection events.
This highlights an important convergence: quantum processors need extremely fast classical software for calibration, decoding and feedback, while machine-learning methods can optimise that infrastructure. A fault-tolerant quantum computer will not be an isolated box, but a hybrid system surrounded by a vast amount of classical computation.
InfoBuz has separately examined emerging technologies that could change life by 2030, where quantum computing appears alongside AI and biotechnology. The progress in 2026 shows that genuine advances do not come only from new qubits, but from the entire control, correction and software stack.
Error correction should not be confused with error mitigation
Today’s quantum computers often use error mitigation methods. These do not protect information through a fully fault-tolerant code; instead, they seek to estimate and statistically compensate for noise effects after a circuit has run.
Error mitigation can improve results on current hardware, and IBM reported hybrid methods in 2026 that significantly reduce either effective error or sampling cost. But there is a fundamental difference: for arbitrarily long algorithms, mitigation does not provide the same exponential scaling of protection that below-threshold error correction can offer.
The coming years will most likely combine techniques: hardware-level noise suppression, mitigation, post-selection, logical codes and progressively greater fault tolerance.
How much hardware could a better protocol save?
A useful quantum computer is not limited only by the number of qubits on a chip. Each physical qubit requires control, readout, cooling and integration. In superconducting architectures, hardware operates at extremely low temperatures, while wiring and electronics become engineering challenges as the system grows.
If an error-correction technique reduces by a factor of ten or one hundred the number of physical qubits needed for the same logical operation, the effect may be far more important than adding a new chip with a few hundred qubits.
That is why magic state cultivation is of interest even if the experiment uses a small fraction of the size of a future machine. It addresses a cost multiplier that recurs very often in a universal algorithm.
What problems would genuinely require fault-tolerant computing?
The aim is not to build a quantum computer for web browsing or spreadsheets. Advantages are expected in problems with very difficult quantum or combinatorial structure: the simulation of molecules and materials, quantum chemistry, certain optimisation tasks, and cryptographic or mathematical algorithms.
For many of these applications, the required circuits are far longer than today’s noisy hardware can support. For that reason, demonstrations of “quantum advantage” on specific benchmarks should not be confused with a fault-tolerant computer able to run arbitrarily long industrial algorithms.
InfoBuz has also presented the major technologies that could change the world by 2030. In quantum computing, error correction is likely to be the point separating scientific promise from utility at scale.
Are we close to a universal quantum computer?
Closer than a few years ago, but not there yet. Google has demonstrated below-threshold correction and now magic-state cultivation on Willow. IBM says it is pursuing a large-scale fault-tolerant system in 2029. Microsoft and its partners are working on logical qubits and architectures that can be replicated.
These are industry targets, not guarantees. Scaling can uncover new problems: crosstalk, losses, manufacturing defects, the demands of classical control, correlated errors and limits in cryogenic systems.
The most sound way to view progress is as a sequence of thresholds: better physical qubits, below-threshold logical qubits, logical operations, magic-state production, real-time decoding, many connected logical qubits and, ultimately, useful algorithms that run long enough to outperform classical alternatives.
Why the 40× result may matter more than a qubit-count record
If a manufacturer announces a chip with one million qubits tomorrow, the right question is not just “how many?” We need to know the error rate, gate fidelity, connectivity, coherence time, the speed of the correction cycle and, above all, how many useful logical qubits it can support.
Google’s result addresses one of the most expensive stages of a universal architecture. If magic state cultivation scales, the same logical capability could be achieved with far less hardware than through traditional methods.
That is the difference between building a large machine and building one that can calculate correctly. In quantum computing, reliability may be worth more than the raw number of qubits.
Frequently asked questions about quantum errors
Did Google reduce all errors on the Willow processor by 40-fold?
No. The roughly 40× reduction was measured for the error of magic states produced through the cultivation protocol, compared with uncultivated states.
What fidelity did the experiment achieve?
Google reports a logical fidelity of about 99.99% for T-states, with around 8% of attempts retained after filtering by the protocol.
What is a logical qubit?
It is a unit of quantum information protected against errors through redundant encoding across several physical qubits or degrees of freedom.
Why is having more qubits not enough?
Because a larger system also creates more opportunities for errors. Hardware must operate below the threshold at which the error-correction code improves, rather than worsens, logical performance.
Are commercial fault-tolerant quantum computers already available?
Not at the scale needed for large universal algorithms. There have been demonstrations of logical qubits, correction codes and fault-tolerant operations, and companies are pursuing larger systems towards the end of the decade.
Will millions of physical qubits be needed?
That is possible for some architectures and applications, but the figure depends greatly on hardware quality, the correction code, the algorithm and the cost of preparing resources such as magic states. Advances such as cultivation could substantially reduce that requirement.
Sources and transparency
- Science – Magic state cultivation on a superconducting quantum processor, 15 October 2026
- Google Quantum AI – Bringing the magic, 15 October 2026
- Nature – Quantum error correction below the surface code threshold
- Nature – Reinforcement learning control of quantum error correction, 8 July 2026
- Nature Physics – Error correction of a logical qubit encoded in a single atomic ion, 13 July 2026
- IBM Quantum – The continuous path from error mitigation to fault-tolerant quantum computing, 15 September 2026
- Microsoft Quantum – logical-qubit demonstrations and utility-scale quantum, 3 August 2026
- PRX Quantum – Efficient Magic State Cultivation, 22 January 2026








Discuția cititorilor
Ai o opinie sau o întrebare despre acest articol? Spune-ne ce crezi.
Fii primul care deschide discuția.
Te rugăm să păstrezi un limbaj civilizat și să discuți la subiect. Comentariile spam sunt filtrate automat.