The whole premise of a qubit is that it holds one bit of quantum information in two states, conventionally labeled 0 and 1. It is a tidy abstraction. The trouble is that almost nothing in nature comes with exactly two levels and nothing more. Real hardware is built from objects with a whole ladder of energy states, and engineers simply agree to use the bottom two rungs and pretend the rest do not exist. Sometimes the hardware does not cooperate. Energy slips out of the computational pair and into a higher state, and the qubit stops being a qubit. This is leakage, and it is one of the quieter but nastier problems in quantum computing.
Where the extra rungs come from
Take the transmon, the superconducting circuit that dominates most large machines. It behaves like a slightly floppy pendulum, an oscillator whose energy levels are not evenly spaced. That uneven spacing, called anharmonicity, is what lets control electronics address the 0 to 1 transition without accidentally driving 1 to 2. But the third level, usually written as 2, is still sitting right there, only a little further up the ladder. Push a microwave pulse too hard or too fast and some of the qubit's population lands on that third rung.
Trapped ions and neutral atoms have the same issue in a different costume. An atom has many electronic states, and the two chosen to encode the qubit are surrounded by others that a stray laser photon or an imperfect pulse can populate. Spin qubits in silicon can leak into valley or orbital states. The details vary, but the moral is universal: the two-level system is a fiction imposed on a richer object, and the fiction occasionally fails.
Why leakage is worse than an ordinary error
A normal qubit error flips a 0 to a 1 or scrambles the phase. Those errors are annoying, but they stay inside the computational space, which is exactly what quantum error-correcting codes are designed to catch. The surface code and its relatives assume every qubit is always somewhere in the 0-1 world. When a qubit leaks to state 2, it drops off the map. The error-correction machinery keeps measuring it as if nothing happened, and the syndrome data it produces becomes garbage.
Worse, a leaked qubit does not sit quietly. During two-qubit gates it can interact with its neighbors and drag them into errors too, spreading the damage across a patch of the processor. A single leakage event can masquerade as a cluster of ordinary errors, confusing the classical decoder and inflating the effective error rate well beyond what the raw numbers suggest. Left unmanaged, leakage sets a hard ceiling on how well a large code can perform, no matter how good the gates look on paper.
Fighting the escape
The first line of defense is to stop leakage from happening. Pulse-shaping techniques such as DRAG, short for derivative removal by adiabatic gate, sculpt the control signal to suppress the frequency component that would excite the third level. Careful calibration keeps gates fast without slamming population up the ladder. Better anharmonicity in the circuit design widens the gap to the leaky states.
The second line accepts that some leakage will always slip through and works to reverse it. Researchers have built dedicated operations, sometimes called leakage reduction units, that pump a stray qubit back down to the computational space before it can poison the code. Google demonstrated a version of this in its surface-code experiments, resetting leaked qubits periodically so the error correction stayed stable over many rounds. Some schemes route the leaked energy into a lossy element that dumps it, effectively draining the top of the ladder.
A third approach is to teach the decoder about leakage directly. If the classical software knows a qubit has probably leaked, it can down-weight that qubit's measurements instead of trusting them, which limits the collateral damage.
Why it matters for the roadmaps
Every company promising a fault-tolerant machine is implicitly promising to hold leakage in check across thousands or millions of qubits, over billions of gate operations. It is not enough to have excellent gate fidelities in a demo; those fidelities have to survive the rare, disruptive events that scale-up makes statistically inevitable. Leakage is one of the reasons a headline error rate never tells the whole story. The qubit that quietly climbs off its two rungs is a reminder that the clean two-level picture is something engineers have to enforce, over and over, rather than something the hardware gives them for free.
