Microsoft reports a 1,000x reliability jump in Majorana qubits
Key takeaways
- Microsoft's new Majorana qubit design delivers 1,000x better switching reliability
- Multiple vendors now have nearly 100 logical qubits, the threshold for useful machines
- Error correction is now fast enough to fix mistakes mid-calculation
- The question has shifted from "if" quantum computing works to "when"
The dirty secret of quantum computing has always been that the machines are flaky. Qubits, the building blocks, fall apart if you so much as look at them wrong. That's why every "quantum breakthrough" headline of the last decade came with an asterisk.
The asterisk is shrinking fast.
What just happened
At its Build conference this month, Microsoft announced an updated material stack for its Majorana qubit design that it says delivers a 1,000x improvement in switching reliability. In plain English: a component that used to fail constantly now barely fails at all.
And it's not just Microsoft. Across the industry in 2026:
- Multiple vendors now report logical qubit counts approaching 100, the threshold where genuinely useful machines start to come into view.
- Error-correction decoding, the process that catches and fixes qubit mistakes, has dropped to under a microsecond, fast enough to fix errors while a calculation is still running.
- Quantinuum's trapped-ion systems are holding error rates below 1 in 10,000.
Those three items sound like jargon. The rest of this piece unpacks them, because together they explain why a quiet engineering story matters more than most loud quantum headlines.
First, what a qubit actually is
An ordinary computer stores information as bits. Each bit is a tiny switch that is either off (0) or on (1). Everything on your laptop, from this page to a video call, is built from billions of those switches flipping at speeds of around 4 GHz.
A qubit is the quantum version. Instead of sitting firmly at 0 or 1, it can hold a blend of both until you measure it. Link several qubits together and the number of combinations they can represent grows explosively. That is the source of the hope: for certain problems, such as simulating molecules, a quantum machine could explore possibilities that a normal computer would have to grind through one at a time.
The catch is that this blended state is delicate. It is not a switch you can leave alone. It is more like a spinning coin that must keep spinning perfectly while you work.
Why qubits fall apart
The technical word for the coin wobbling and falling over is decoherence. Heat, stray radiation, vibration, even tiny electrical noise from the control wiring can nudge a qubit and wreck the information in it. This is why many quantum machines sit inside refrigerators colder than deep space, and why people say qubits fail if you so much as look at them wrong.
Noise does not only cause total collapse. It also causes small slips in every single operation, known as gate errors. A gate is the quantum equivalent of a logic step, and each one has some chance of going wrong.
Error rates, and why small ones still hurt
Say a hypothetical machine gets each operation wrong 1% of the time. That sounds excellent until you chain steps together. After 100 operations, the chance that at least one has gone wrong is roughly 63%. Useful quantum algorithms are expected to need vastly more steps than that, potentially 1 million or more, so even a seemingly tiny error rate quickly buries the answer in noise.
This is why the Quantinuum figure matters. An error rate below 1 in 10,000 is the same as getting each operation right more than 99.99% of the time. Trapped-ion systems, which hold individual charged atoms in place and manipulate them with lasers, are among the most accurate qubit designs around. Better raw accuracy means every later step in the chain has less to clean up.
It is also what the Microsoft claim is about. A 1,000x gain in switching reliability attacks the same problem at the hardware level: make the physical component itself mistake-resistant, rather than relying entirely on software to patch things up afterwards. Microsoft reports this for its updated material stack, and as with any vendor result it is the company's claim until others reproduce it.
Error correction and the logical qubit
Nobody expects physical qubits to become perfect. So the field's answer is error correction, borrowed in spirit from the way a message sent over a noisy phone line can still be understood.
The trick is redundancy. Instead of trusting one fragile qubit with one piece of information, you spread that information across many physical qubits and keep checking them against each other. The group, working together, behaves like a single far more reliable qubit. That group is called a logical qubit.
You cannot simply copy a qubit the way you copy a file, so the checking is done indirectly, by measuring clues about whether something has gone wrong without reading the data itself. A conventional piece of software called a decoder then works out which qubit slipped and what correction to apply.
The cost has historically been steep. Estimates have often put it at hundreds to thousands of physical qubits for each logical one, depending on how noisy the hardware is. That is why headline qubit counts mislead. A chip with a large number of physical qubits might yield only a handful of logical ones. If you want the longer version of that argument, everyone quotes qubit counts, but almost nobody quotes the one that matters.
Why logical qubits near 100 matter
This is where the original claim lands. Multiple vendors now report logical qubit counts approaching 100, the threshold where genuinely useful machines start to come into view. Note the wording: approaching, and coming into view. Nobody is saying useful machines have arrived.
The speed claim is the other half. Decoding has dropped to under a microsecond, one millionth of a second. That is fast enough to fix errors while a calculation is still running. Slow decoding was a real bottleneck, because the errors keep arriving whether or not the decoder has caught up. Fast decoding turns error correction from something you do afterwards into something that happens live. For a deeper look at related progress, see how quantum error correction can now continuously recalibrate processors.
Physical versus logical, side by side
| Physical qubit | Logical qubit | |
|---|---|---|
| What it is | One actual hardware component | A group of physical qubits acting as one |
| Reliability | Fragile, loses its state quickly | Far more stable, errors are caught and fixed |
| Cost to build | Cheap per unit | Needs many physical qubits each |
| What vendors often quote | The big headline number | The smaller figure that decides usefulness |
| Where the recent progress shows | Better materials, such as Microsoft's Majorana update | Counts approaching 100, plus sub-microsecond decoding |
Why it matters
Error correction is the whole game. A quantum computer that can fix its own mistakes faster than it makes them stops being a physics experiment and starts being a computer. That line is being crossed now, quietly, in engineering labs rather than press conferences.
That is also why the story is easy to miss. A drop in error rates does not make a flashy demo. Nothing explodes on stage. But it is the progress that every flashier claim depends on. Recent quantum results, such as a quantum computer solving a problem fusion power has been stuck on, only become routine once the underlying machines stop breaking.
Governments have noticed too. The US has even ordered a machine built for science, which we looked at in detail.
What nobody can promise yet
Nobody can say exactly when these machines start breaking encryption or designing drugs. Those jobs likely need many more logical qubits than anyone has today, running for a long time without a hitch. A machine with roughly 100 logical qubits is a milestone, not the finish line.
But the question has changed from "if" to "when", and this year the "when" got noticeably closer. Worth keeping half an eye on, even while the AI news hogs every headline.
