Why a physical qubit was never going to be enough
Let us start with the two words that do all the work in this guide. A physical qubit is a single thing: one superconducting transmon, one trapped ion, one atom in a laser tweezer. The best of them make an error somewhere around one time in a thousand when two of them interact. That sounds fine until you notice that a useful chemistry or factoring algorithm needs billions of those interactions in a row without a single one going wrong. A logical qubit is the fix: information spread over many physical qubits in such a way that errors can be spotted and undone before they spread.
The idea is old. Peter Shor published the first quantum code in 1995, using nine physical qubits to protect one. Andrew Steane's seven-qubit code followed, and Alexei Kitaev's surface code from the late 1990s became the favourite because it only asks each qubit to talk to its nearest neighbours, which is what real chips can do. The theory then hands you a promise called the threshold theorem. If your physical error rate is below a certain threshold, making the code bigger (in the jargon, increasing its distance) drives the logical error down exponentially. Above the threshold, bigger codes make things worse, because you are adding more places for errors to happen faster than you can catch them. "Below threshold" is therefore the sentence the whole field was waiting to hear.
Willow: below threshold on a superconducting chip
In December 2024 Google Quantum AI published a paper in Nature under the title "Quantum error correction below the surface code threshold". The chip, called Willow, has 105 superconducting qubits. The team ran surface codes at distance three, five and seven, and the logical error rate fell each time the distance went up, roughly halving at each step. That is the exponential suppression the theorem promised, seen on hardware for the first time in a clear way. The distance-seven logical qubit also held its information for longer than the best single physical qubit on the chip, which is the other milestone people had wanted: the whole was finally better than its best part. The decoder, the classical software that works out which error happened, kept pace with the machine in real time.
The caveats we keep in mind. This was a memory experiment: the logical qubit was stored and read out, not used to compute anything. It was one logical qubit, using roughly a hundred physical qubits to make it. Useful machines will want hundreds or thousands of logical qubits, and the physical-to-logical ratio has to come down or the qubit counts have to go up by a lot.
Neutral atoms: many logical qubits at once
A year earlier, in December 2023, a collaboration between Harvard, MIT and the company QuEra published a Nature paper (Bluvstein and colleagues) that came at the problem from the other side. Rather than making one very good logical qubit, they made lots of modest ones: up to 48 logical qubits from 280 rubidium atoms held in optical tweezers. Because the atoms can be picked up and moved mid-circuit, the team could run colour codes and three-dimensional codes that would be awkward on a fixed chip, and could entangle logical qubits with one another rather than just storing them.
The honest trade-off is that much of the improvement came from post-selection: runs where an error was detected were simply thrown away. That is fine for showing a code works and useless for a long calculation, where you cannot restart every time something flickers. Neutral-atom measurements are also slow compared with superconducting ones. Still, this is the experiment that showed people what dozens of logical qubits look like, and it changed a lot of roadmaps.
Trapped ions: small codes, very clean
Quantinuum's trapped-ion machines have a different personality again. Their two-qubit gates are among the cleanest anyone has measured, and any ion in a trap can be brought next to any other, so codes that need long-range connections are natural. In 2024 Quantinuum and Microsoft reported logical qubits whose error rates came out lower than the physical qubits they were built from, using small codes and active error detection, and went on to demonstrate entangled logical qubits and logical operations rather than pure storage. The price is speed: ion gates run in microseconds to milliseconds where superconducting gates run in nanoseconds, and the qubit counts are small. We think of it as the platform proving what fault tolerance looks like at small scale, while others race on size.
Better codes: qLDPC and cat qubits
Not every breakthrough was on hardware. In 2024 an IBM team (Bravyi and colleagues) published in Nature a family of quantum low-density parity-check codes, the so-called bivariate bicycle codes, with a headline member nicknamed the "gross" code. It stores 12 logical qubits in 144 data qubits (plus a matching set of check qubits) at a distance comparable to a surface code that would need something like ten times as many physical qubits. The catch is that it needs a few connections that reach further than nearest neighbours, which today's superconducting chips do not have. It is a strong argument for designing hardware around the code rather than the other way round.
The other idea is to build a qubit that is lopsided on purpose. A cat qubit lives in a superconducting resonator and is arranged so that bit-flip errors are suppressed exponentially, leaving only phase flips to correct, and those can be handled with a simple repetition code. The groups around Michel Devoret and others at Yale pioneered the bosonic approach; the French company Alice & Bob was founded on it; and in February 2025 AWS announced its Ocelot chip using cat qubits. The trade-off is that cat qubits need continuous stabilising drives, and some gates are harder to make in the biased setting. Whether the reduced overhead wins out is one of the open bets of the next few years.
What still is not shown
We would love to tell you the problem is solved, so let us be plain about what is missing. Nobody has yet run a full fault-tolerant algorithm end to end. The hardest operations, the so-called non-Clifford gates that make a quantum computer more than a fancy classical one, need "magic states" produced by distillation, and doing that at scale is still ahead of us. Decoders have to keep up with millions of measurements per second on big machines. And every route still points to hundreds of thousands or millions of physical qubits for the applications that matter, which is why our platforms guide spends so long on scaling stories.
How we read the next announcement. Logical or physical? Memory or computation? Was post-selection used? Did the logical error beat the physical one? Those four questions, from our home page checklist, settle most of what a headline means.