A qubit is a promise of simplicity. Two states, zero and one, and nothing in between to worry about. That promise is what makes the whole edifice of quantum algorithms possible. But the physical objects we build qubits from, whether superconducting circuits or trapped ions, are not naturally two-level systems. They are more like ladders with many rungs, and engineers simply agree to use only the bottom two. When a qubit slips onto a higher rung, it has leaked, and leakage is a different and more dangerous kind of error than the usual flips and phase slips.
Why the third level is always there
Take a transmon, the workhorse of the superconducting world. It is an anharmonic oscillator, which is a fancy way of saying its energy rungs are not evenly spaced. The gap between the ground state and the first excited state differs slightly from the gap between the first and second. That unevenness is deliberate. It lets control pulses address the zero-to-one transition without accidentally driving one-to-two. But the second excited state never goes away. It sits just above, a little attic the qubit can wander into if a pulse is too strong, too fast, or slightly off frequency.
Fast gates make the problem worse. Shorter pulses have broader frequency content, and that spectral spread can clip the one-to-two transition even when it is aimed squarely at zero-to-one. There is a real tension here: teams want gates that finish quickly to beat decoherence, but the quicker the gate, the more it risks knocking the qubit up the ladder. Pulse-shaping tricks like DRAG, which adds a carefully tuned correction to the drive, exist largely to keep that leakage in check.
Why leakage is worse than an ordinary error
A bit flip or a phase flip keeps the qubit inside its computational space. Error correction is built to catch exactly those events. The parity checks of a surface code assume every qubit is still a qubit, still answering zero or one when measured. A leaked qubit breaks that assumption. It is no longer in the alphabet the code understands.
Worse, leakage tends to spread. A qubit stuck in its second excited state interacts with its neighbors differently than a well-behaved qubit would. Two-qubit gates can shuttle the problem sideways, corrupting partners that were perfectly fine. And because the error-correcting cycle does not naturally reset a leaked qubit, it can linger for many rounds, quietly poisoning every measurement it touches. A single leakage event can masquerade as a storm of correlated errors, which is exactly the kind of thing decoders struggle with most.
Pumping the qubit back down
The fix is a dedicated maneuver known as a leakage reduction unit. The idea is to insert operations that take any population sitting in the second excited state and return it to the computational space, usually to the ground state, without disturbing qubits that were behaving. One common approach swaps the leaked state into a reset channel, draining the stray energy the same way a qubit is wiped between runs. Another uses a nearby readout resonator or an auxiliary qubit as a sink.
These units cost something. They take time, they can introduce their own small errors, and they have to be scheduled around the rest of the error-correction cycle. The art is making leakage removal cheap enough that it is worth running every round. Google's surface-code experiments have leaned heavily on this, publishing data showing that without active leakage handling, the logical error rate creeps up as the code grows, undoing the whole point of scaling.
A quieter benchmark
Leakage rarely shows up in headline numbers. A company will advertise two-qubit gate fidelity of 99.5 percent, but that figure often folds leakage into a single error budget. Separating out the leakage rate matters, because leakage behaves so differently under error correction. A gate with slightly lower raw fidelity but almost no leakage can outperform a flashier gate that occasionally sends qubits up the ladder.
As machines push toward thousands of physical qubits, leakage stops being a nuisance and becomes a design constraint. Fast gates, strong couplers, and dense layouts all raise the odds of a qubit slipping off its two rungs. The teams that win the fault-tolerance race will be the ones who not only keep their qubits coherent but keep them, stubbornly, inside their own lane.
