Cultivating record-fidelity magic states with lattice surgery on publicly accessible IBM quantum computers

Quantum error correction promises to make large-scale quantum computation possible. It also introduces a formidable cost.
One of the most painful tasks in building and running a large-scale fault-tolerant quantum computer comes from the need to generate special “magic states” enabling universal algorithms to be run. Google recently hit a major milestone with a beautiful demonstration of magic-state cultivation using its Willow processor, until now the only quantum processing unit (QPU) on which magic-state cultivation had been demonstrated.
In our most recent work using publicly accessible IBM Quantum Nighthawk processor, our performance-management infrastructure software, and newly demonstrated protocols, we go even further, delivering 10x lower state error, and setting a total of three performance records along the way. And we show a clear path to efficient magic-state factories for large-scale fault-tolerant quantum computing.
The problem with magic states
Today’s quantum processors support a rich set of native operations, delivering huge flexibility and efficiency in algorithmic execution while hardware exists at modest scales. So-called fault-tolerant architectures typically support only a much more restricted set in order to ensure errors don’t grow in an uncontrolled fashion as systems grow in size.
Translating algorithms into that narrow class of operations can increase circuit depths by orders of magnitude, turning a compact computation into an enormous circuit constituting a huge number of “building-block” operations and supporting subtasks. A major source of that overhead is the need for magic state factories.
In universal fault-tolerant quantum computation, we have to implement an unusual (non-Clifford) operation called the T gate, which often cannot be executed directly on logical qubits protected by quantum error correction (QEC). As a result, we require that the gates be “injected” using specialized auxiliary resource states, also known as magic states.
Generating magic states with fault-tolerant-grade fidelity is notoriously demanding. In early resource estimates, magic state factories took up more than 90% of a machine’s physical qubits. Better protocols have recently cut that share sharply, but factories remain a substantial part of the cost of fault-tolerant algorithms.
Lowering magic-state-factory overhead is among the most critical milestones on the road to practical large-scale quantum computing.
A new path to high fidelity: cultivation
In our latest manuscript, Q-CTRL researchers report the first experimental demonstration of magic state cultivation with lattice-surgery escape. The demonstration connects cultivation, a method for preparing high-quality magic states, with the lattice-surgery operations needed to provide the state with greater QEC protection.
The work sets three new experimental records. It achieves the lowest reported error rate for magic state cultivation, the lowest per-round logical error rate after escape in magic-state cultivation, and the highest-fidelity magic state demonstrated in a surface code.
First introduced in 2024, magic state cultivation provides a low-overhead alternative to traditional magic state “distillation” by avoiding the need for large physical qubit arrays. The protocol proceeds in two stages:
- Refinement: A noisy logical magic state is prepared (injected) non-fault-tolerantly on a compact, error-detecting code. Subsequent measurements verify the state and project it onto the ideal state. Any run that produces unexpected measurement outcomes or detects an error is immediately discarded.
- Escape: Once verified, the refined state is fault-tolerantly transferred, or "escapes", from the compact code into a larger quantum error-correcting code, where it is stored with full fault tolerance until consumed by a circuit.
Where that refined state ends up depends on the escape strategy used:
- Grafting (deforming the code): The compact code is deformed into a hybrid color-and-surface code. In the only prior hardware experiment, demonstrated on Google’s Willow processor, the process stopped in a "non-matchable" code, meaning the critical process of decoding (identifying errors for correction action) cannot be executed using efficient techniques. We extend the previous experiment with a further deformation that makes the code “matchable” and compatible with the most efficient “minimum-weight perfect matching” decoders.
- Lattice surgery (teleporting the state): The cultivated state is teleported into a surface code using the exact same operations surface-code processors already use to execute logic. Proposed in 2025, this route had never been demonstrated on physical hardware until now.

Benchmark results: breaking records at every stage
Executed on an IBM Quantum Nighthawk processor, our lattice-surgery protocol delivered state-of-the-art performance across all four evaluation phases. Achieving this level of performance stems from coupling an efficient protocol and next-generation hardware with a tightly optimized execution pipeline. Our approach involved custom compilation, strategic layout selection to map operations onto the best-performing qubits, interleaved dynamical decoupling to actively suppress environmental noise, and deployment of an upgraded decoding procedure to resolve errors more accurately. Together, these layers ensured that the routines ran cleanly enough to preserve logical advantages.
- 10x lower cultivation error: The cultivated T state achieved a logical error probability of 2 × 10⁻⁵, a fidelity of 0.99998, while retaining 25% of shots. Compared to the previous benchmark set on Google’s Willow, this represents roughly 10 times lower error at 3 times higher acceptance rate.
- Record surface-code fidelity: Immediately after lattice surgery, the state transferred into the surface code with a fidelity exceeding 0.99 (at up to 16% retainment via decoder confidence postselection). The prior reported record for a magic state in a smaller surface code was ~0.91.
- Record memory fidelity: After 10 full rounds of error correction, fidelity remained resilient at 0.991 (5% retainment), with a logical error rate of just 0.14% per round. Because the lattice-surgery route goes directly into a standard surface code, it is fully compatible with the most efficient decoder—processing syndrome data over 1,000x faster than the decoder required by grafted codes.


Our cultivation and grafting circuits are very similar to those of the first cultivation experiment, executed on Google’s Willow processor, so the two experiments can be compared side by side. The performance gains shown below span most of the metrics by which a fault-tolerant implementation is measured.
These are very significant increases in performance over the prior records using a publicly accessible quantum computer. There’s no special “behind-the-wall” access used to implement these experiments.
A practical path to magic-state factories
An effective magic-state factory must satisfy two demands at once: prepare high-fidelity resource states, and preserve them in memory using a decoder fast enough to track real-time errors for later consumption.
Our results demonstrate that lattice-surgery escape meets both criteria using the native operations and efficient decoders a surface-code architecture already relies on, demanding no exotic circuitry, prohibitively expensive decoding algorithms, or downstream code conversions.
The head-to-head comparison with grafting highlights an essential principle for fault-tolerant architecture design: a code transformation must be evaluated across its entire path, not just where it lands. Errors compound during intermediate steps, ultimately compromising the quality of the generated state. Although grafting eventually reaches a “decoder-friendly” code, the detour it takes sacrifices fidelity and demands slow decoding along the way. Lattice surgery takes the direct path, avoiding both overheads.
Building on this demonstration benchmarking a distance-5 implementation, the roadmap forward is clear:
- Scaling surface codes to larger distances on higher-qubit-count platforms.
- Consuming cultivated states directly in fault-tolerant logical T gates via real-time decoding and active feedforward.
At Q-CTRL, we work to make quantum technology useful by improving what quantum hardware can deliver. These results bring that approach to one of fault-tolerant quantum computing’s most demanding building blocks and advance the effort to reduce the resources practical quantum computation will require.
To explore the complete experimental protocols and benchmarks, read our technical manuscript arXiv:2611.22035.
Interested in applying these methods to your own error-correction pipeline? Contact us.



