IBM Says Error Correction Puts Useful Quantum Systems on a 2029 Path

IBM’s highest-stakes claim, as Oliver Dial presents it, is that verifiable quantum advantage is close enough to be fought over in 2026, and that error-corrected client systems are plausible by 2029 because the error-correction overhead has changed. That is a narrower claim than “quantum computing has arrived,” but it is also more concrete than the field’s familiar habit of keeping practical machines perpetually several years away.

Dial draws a hard line between two milestones that are often blurred together: quantum utility and quantum advantage. IBM says it reached quantum utility in 2023. That meant its machines could run circuits complex enough that simulating the quantum computer on a classical computer became challenging or impossible. Utility, in Dial’s framing, is not the same as getting a practically better answer. It is the point at which the quantum system is no longer trivially replaceable by a classical simulation.

Quantum advantage is a stricter claim. Dial defines it as using a quantum computer to do something “better, faster, cheaper” than would have been possible on a classical computer. IBM is aiming for that milestone in 2026, though Dial is careful about the attribution: IBM is “hoping to demonstrate, or hoping for someone to demonstrate, ideally not us” quantum advantage this year. The point is not only to show that IBM’s hardware can run a hard quantum circuit, but to have outside users bring problems, classical researchers try to match or beat the result, and the field argue in the open about whether the quantum result held up.

That is why, for Dial, the key word is not only “advantage” but “verifiability.” A quantum computer producing an output that is hard to simulate is not enough if no one can say whether the output was right. He describes Google’s earlier random-circuit-sampling claims as probably true in spirit, but scientifically “a little bit dicey” because the claims involved verifying smaller circuits and extrapolating to larger ones. In his account, the debate is not whether the hardware did something impressive. It is whether the result can bear the stronger claim that a quantum computer produced the correct output beyond classical reach.

IBM’s response has been to help set up a Quantum Advantage Tracker, which Dial compares to “Hugging Face for quantum.” It is a leaderboard-like venue where researchers can post specific problems, quantum performance, and classical performance. IBM initially set it up, he says, but entries are added through GitHub issues rather than edited by IBM as a gatekeeper. The intended function is adversarial: a quantum result goes up; classical computer scientists try to reproduce or beat it; the claim survives, weakens, or disappears.

Dial also distinguishes between two kinds of advantage. One is the strict scientific version: can someone prove the quantum computer gave the right answer and prove it did so faster than any possible classical route? The other is what he calls “heuristic advantage”: a quantum computer produced a better answer than a classical method in practice, even if the proof is not airtight. He says people have already claimed this more pragmatic, nitty-gritty kind of advantage over the past year. IBM’s expectation for 2026 rests on the view that hardware, algorithms, and noise-correction tricks have advanced far enough that advantage-like results should become possible for a wider range of users on today’s systems.

The implication is narrow but significant. IBM is not saying fault-tolerant quantum computing has arrived. It is saying the field is approaching a public comparison regime in which quantum machines can be tested against classical machines on meaningful tasks, with enough scale and enough verification to make the debate materially different from earlier demonstrations.

Craig Smith presses Dial on why qubit counts matter, because the term is often used as a headline number without explaining what it buys. Dial’s answer starts with simulation. If a quantum system is small enough to fit into classical memory, or if the circuit is shallow enough, then classical algorithms can often simulate it efficiently enough that running the quantum device is not the sensible option.

A visual note shown during this explanation sharpened the point: if the number of qubits is restricted so that the system fits in a classical computer’s memory, “that opens up a set of fairly efficient classical algorithms that can simulate the system.” Dial adds a second constraint: circuit depth. Even with enough qubits, short circuits can sometimes be simulated with efficient classical techniques. Quantum utility required crossing both barriers: enough qubits and enough operations that the machine enters a regime where classical simulation becomes difficult.

Dial describes a quantum computer as an accelerator, not a replacement for a classical computer. A classical machine sends in a classical description of a problem, controls the quantum device, the device manipulates a quantum state, and then measurement converts the result back into classical data. Humans begin and end with classical information because, as Dial puts it, that is the only kind of data humans can access.

The number of qubits sets the size of the quantum state that can be manipulated. Dial reaches for linear algebra: the quantum computer operates in a vector space with $2^n$ dimensions for $n$ qubits. Gates can be represented as unitary transformations — matrix operations that preserve information and have inverses — applied inside that enormous state space. Four qubits, he says, can be simulated on a phone. Around 50 to 100 qubits, classical direct simulation becomes effectively impossible; around 100 is the range where the threshold becomes severe.

IBM’s current flagship devices in its fleet are 156-qubit machines. Dial compares that with Google’s earlier “supremacy” experiment at 53 qubits. IBM has also built larger experimental chips: Condor, a 1,000-qubit device, was built “just to prove that we could,” then taken apart almost immediately because its error rates were too high to productively use all 1,000 qubits. In Dial’s words, it was “an expensive technology demo,” not something IBM thought would be useful to clients.

That example exposes the limits of qubit counting. A larger chip is not necessarily a better computer if its errors prevent deep useful computation. IBM’s new device, Nighthawk, is coming online this year. It is smaller than the 156-qubit fleet devices at 120 qubits, but Dial says it has higher connectivity. Prior IBM devices had at most three connections per qubit. Nighthawk has four. That sounds incremental, but it reduces the need to move quantum data around the chip with repeated swaps when two distant qubits need to interact.

Nighthawk’s design reflects a broader claim Dial makes repeatedly: progress is not one variable. Better devices require more qubits, fewer errors, richer connectivity, better compilation, and better techniques for correcting or mitigating noise. A 120-qubit chip can be an advance over a larger chip if the hardware makes more useful operations possible.

The basic physical problem in IBM’s machine is not merely making a two-state device. It is making a two-state device that remains quantum long enough to compute. Oliver Dial says a quantum computer needs “a way of storing information that the universe can’t see.” If a qubit in a superposition of zero and one is observed by its environment, it collapses back into classical information.

Dial’s own path into quantum computing began with quantum dots: tiny boxes that can hold a single electron. One possible qubit design uses the electron’s spin — its tiny magnetic orientation — as zero or one. IBM uses a different approach: superconducting qubits. These are small superconducting resonators, effectively electromagnetic oscillators, built from metal superconductors. Dial describes them as LC circuits: a capacitor and a Josephson junction acting as an inductor. The qubit stores either zero or one microwave photon inside that resonator.

The resonator is designed around a frequency of about 5 gigahertz. At ordinary temperatures, microwave-frequency thermal radiation would interfere with the qubit. That is why the machines are cooled not merely below the superconducting transition temperature — Dial says below about one degree would be enough for the materials IBM uses to superconduct — but down near 0.02 degrees above absolute zero. The point is to keep the chip from “glowing” at the qubit frequency and injecting unwanted microwave photons.

The engineering difficulty compounds as machines scale. IBM’s qubits are not microscopic in the way a transistor is microscopic. Dial says IBM’s qubits are about three-quarters of a millimeter on a side; a person could see them with the naked eye on a chip, though “I’d have to freeze you to death before you got to see it happen.” A 120-qubit Nighthawk processor requires on the order of 480 control signals going into and out of the device. These are analog microwave signals, not digital wires. Each qubit needs a microwave control line. Each coupler needs a control line. Groups of qubits need measurement lines.

Those signals require signal generators, which Dial compares loosely to cell-phone transmitters, but much more precise and lower-noise. They also require wiring from room-temperature electronics into a cryogenic environment colder than deep space. If those wires are made incorrectly, they conduct heat into the system; Dial likens it to trying to air-condition a house with the windows open. Scaling a superconducting quantum computer is therefore not only a chip-design problem. It is a packaging, refrigeration, wiring, analog-electronics, crosstalk, and thermal-management problem.

The Josephson junction also solves a subtler requirement: isolating two useful energy states from higher ones. A simple oscillator could hold zero, one, two, three, or more photons. A qubit needs a clean zero-one manifold. Dial says the Josephson junction is “ridiculously non-linear,” which lets IBM design the oscillator so that if the first photon corresponds to a 5 gigahertz transition, the second might require 4.8 gigahertz. That separation lets the bottom two states be addressed without accidentally climbing into higher states.

IBM uses nanofabrication tools, clean rooms, packaging techniques, and semiconductor-like processes that fit the company’s existing hardware strengths. But the resulting object is not a classical chip. It is an analog microwave system, fabricated like advanced electronics, then operated in a regime where heat radiation, wiring, and microscopic materials defects become computational issues.

When Smith asks how quantum computing relates to AI, Oliver Dial does not claim that frontier AI models are about to move onto quantum hardware. He divides applications into near-horizon and long-horizon categories. Near-term quantum computers need problems that map efficiently onto the device. Today, that mostly means chemistry and materials science: using a quantum system to solve problems in quantum mechanics.

Dial says some chemistry demonstrations are now approaching the accuracy of state-of-the-art classical chemistry techniques. He does not claim broad superiority. The point is that these are the places where the mapping from problem to quantum machine is natural enough that near-term systems might compete.

AI, by contrast, remains mostly in the toy-problem category. Many AI methods involve linear algebra, and quantum computing can be described in linear-algebraic terms. But that does not imply that current quantum computers can run useful AI workloads. Dial says today’s machines are not large enough to represent those models or deep enough to run the necessary circuits. There have been proof-of-concept demonstrations around kernel estimation — finding a basis in which information can be represented sparsely — and examples deliberately designed around features quantum computers can detect efficiently, such as periodicity. Those are small demonstrations, not useful AI systems.

His broader caution is about heuristics. Dial defines a heuristic algorithm as one that may make practical sense and work well, even though one cannot prove it will always return the right answer. He contrasts that with algorithms whose correctness can be written on a chalkboard, such as matrix multiplication, the fast Fourier transform, or Shor’s algorithm for factoring. Much of AI belongs to the heuristic category: beam search, genetic algorithms, gradient descent on neural networks. Optimization methods also tend to be heuristic, and Dial says quantum optimization experiments look encouraging, though still not proven in the stronger sense.

For long-horizon AI and linear algebra, Dial acknowledges that quantum computers may offer speedups for parts of the problem, assuming input states can be prepared efficiently. But he emphasizes the pre-factor problem: quantum computers are slow and costly enough that even an algorithmic speedup would only pay off for “absolutely enormously large problems.” That makes such applications distant.

He gives Grover search as an example of an algorithm that is easy to talk about and easy to overrate. Grover’s algorithm searches an unsorted list in time proportional to the square root of the list size. For a list of a billion possibilities, that is far fewer than checking roughly half the list. But because the practical overhead is so large, Dial says one would be better off building a massively parallel classical computer for relevant cases. Grover search may be an elegant teaching example, but he says it is unlikely to matter technologically in either his lifetime or Smith’s.

Shor’s algorithm sits differently. It is one of the canonical “blackboard” quantum algorithms because its correctness can be mathematically proved, and it addresses factoring, a problem believed to be hard classically. Dial repeats Scott Aaronson’s framing: either factoring is easy classically and someone gets a Fields Medal; or quantum computers cannot be built and someone gets a Nobel Prize for discovering why; or quantum computers can really do things classical computers cannot. But Shor’s algorithm requires a much larger, error-corrected quantum computer than anyone can build today.

The result is a sober application map. Chemistry and materials are closest. Optimization may show near-term heuristic gains. AI on quantum hardware is exploratory and small. Large linear-algebra speedups and Shor-style demonstrations belong to the error-corrected future.

The central obstacle to deeper quantum computation is error correction. Oliver Dial explains it by starting with classical communications. If a sender wants to transmit a one through a noisy channel, the simplest redundancy scheme is to send three ones. If the receiver gets 1, 1, 0, the receiver infers the intended value was probably one. More sophisticated systems use parity checks: send data plus information about whether the number of ones is even or odd. Add more checks, and the system can detect or correct more mistakes at the cost of extra data.

Quantum systems can use error-correcting codes too, but they cannot simply inspect the qubits. Looking at the qubits destroys the quantum state. The workaround is to measure parity information without learning the underlying qubit values. Dial calls this “blind error correction”: circuits reveal whether certain parity constraints have been violated, while leaving the encoded quantum information intact.

Quantum error correction is harder than classical error correction for several reasons. Quantum computers must correct both bit-flip errors, where one becomes zero or zero becomes one, and phase errors, which Dial describes as superpositions coming out at the wrong angle — roughly a timing error. Correcting a single logical qubit requires two kinds of error-correcting structure. The operations used to prepare and measure the parity checks are themselves noisy. If the starting error rates are too high, the error-correction code damages the information instead of protecting it.

Dial says IBM’s best processors are still short of the error rates needed for far-future algorithms, but not by orders of magnitude: roughly three to ten times better would be needed. The larger historical problem was overhead. With the best-understood codes until recently, it was typical to talk about using 100 physical qubits to make one error-corrected logical qubit. At that ratio, IBM’s best current processor could produce roughly one useful logical qubit, after including the surrounding error-correction apparatus. Dial says that pushed system size and cost beyond what IBM considered reachable engineering.

IBM’s account of the shift centers on a new error-correcting code it calls the gross code. Dial says low-density parity-check codes had long been known from communications theory and promised lower overhead in principle. What was missing, in his description, was a practical implementation that mapped onto hardware, including a way to extract the syndrome — the parity-check information — and infer the errors. IBM’s work, he says, filled in those details for a code that is an order of magnitude more efficient than what IBM says was previously known to be possible in a practical implementation.

That improvement did not come for free. The surface code, the earlier dominant approach in Dial’s explanation, only required nearest-neighbor connections between qubits laid out like a checkerboard. The higher-rate gross code requires non-local connections. Dial says the chip needs something like a “highway overpass”: a way for wiring to pop out of the plane so qubits can connect beyond immediate neighbors. This is where hardware-software co-design becomes central. IBM’s hardware team told its error-correction team what might be physically buildable — perhaps six connections per qubit, with wires reaching about 10 qubits away — and the error-correction team designed a code around those constraints.

IBM is now testing an experimental chip intended to demonstrate the features needed for that code. Dial says it is not a client-facing machine because it implements only two logical qubits, which is not computationally useful. Its importance, in IBM’s roadmap, is as a prototype for the 2029–2031 systems the company wants to build to run the large “chalkboard” algorithms that require fault-tolerant logical qubits.

Dial ties IBM’s four-year timeline to this change in error-correction overhead. He says he used to wonder whether he would see an error-corrected quantum computer in his lifetime. Now, because of the more efficient codes, he says IBM believes it can build one large enough to be computationally useful in the next four years. The confidence is not that all physics problems are solved. It is that IBM believes the overhead reduction has moved the goal from beyond engineering reach into a difficult systems program that can fit its roadmap.

IBM maintains two roadmaps, according to Oliver Dial. The development roadmap covers devices that IBM expects to be computationally interesting and client-accessible. The innovation roadmap covers research demonstrations that are not yet useful to clients but prove out the pieces required for fault-tolerant systems.

For 2026, 2027, and 2028, the development roadmap is built around improved versions of Nighthawk. Dial describes Nighthawk as IBM’s state-of-the-art processor design in that roadmap context, while also saying earlier that the device is coming online this year rather than describing it as the already deployed flagship fleet. “Improved” means two things: better gate fidelities, driven by materials and physics work to reduce errors; and larger versions, driven by engineering and systems scaling. In parallel, IBM is working on software techniques that let users get more from noisy machines: error mitigation and smaller forms of error correction that do not provide full large-scale fault tolerance but can fix specific errors or make circuits more useful.

IBM tries to compress this practical capability into a single metric: the number of gates, or operations, a device can run. Dial presents that as a better measure of progress than raw qubit count because depth matters as much as size.

The innovation roadmap moves toward logical qubits and modularity. In 2026, IBM expects to demonstrate logical qubits. In 2027, it expects to connect two modules of logical qubits, because the target system cannot be built as one enormous monolithic chip. In 2028, it expects to demonstrate universal computation on those logical systems. In 2029, IBM hopes to bring error-corrected devices to clients, at which point the development and innovation roadmaps would merge again.

1. 2023
   IBM says it reached quantum utility: circuits complex enough to be challenging or impossible to simulate classically.
2. 2026
   IBM hopes for a verifiable quantum-advantage demonstration and plans to demonstrate logical qubits on the innovation roadmap.
3. 2027
   IBM plans to demonstrate connections between two modules of logical qubits.
4. 2028
   IBM plans to demonstrate universal computation on logical-qubit systems.
5. 2029
   IBM hopes to bring error-corrected quantum devices to clients, merging the development and innovation roadmaps.

Dial is explicit that schedule pressure is real. IBM’s roadmap has credibility, in his view, because the company publishes it, updates it annually, and has generally stuck to it. That public commitment also creates risk. Four years is short enough, he says, that he can count the remaining cycles of learning: build a device, learn from it, build the next one. Science on a schedule is hard because things will go wrong.

IBM’s hardware organization is structured around rapid iteration. Dial says about one third of the team is focused on hardware and two thirds on software. Until a few years ago, every quantum processor IBM built was fabricated in the building where Dial works, using a small research fabrication facility. More fabrication has since moved to the Albany NanoTech Center, a 300-millimeter research and pilot-production facility co-run by IBM and NY CREATES, because IBM’s devices are becoming more complex and require more advanced, automated tooling. Final packaging is still done locally; control electronics are designed by teams that also work on IBM’s System Z, though built by subcontractors; assembly and test happen at IBM sites including Poughkeepsie.

The fleet is also built for turnover. IBM operates cloud-accessible quantum computers in its own data centers, where users can get a small amount of free monthly access. Those systems are typically upgraded after about two years. It also has customer-site installations under managed service agreements: Dial says there are 13 around the world, with four more being installed toward the end of the year. IBM still owns and manages those systems, keeps them calibrated, and usually provides a mid-term upgrade after about two years. The expectation is that a two-year-old quantum system will be materially behind the latest hardware.

That cadence is part of how IBM is trying to make the roadmap real. It is cycling through bird-named processors — Heron, Condor, Nighthawk — and multiple variants of the same generation, keeping whichever versions perform best. Dial says IBM is working on three versions of Nighthawk at once. In a field where gains depend on noise, connectivity, fabrication, controls, and software, IBM’s account is one of repeated learning cycles rather than a single leap to a finished machine.

Craig Smith asks whether enterprises should already be training cohorts of people who understand quantum algorithms and the timeline. Dial’s answer is no, it is not too early.

His first reason is application mapping. Every organization has its own problems. Figuring out whether those problems can be expressed in a form suitable for a quantum computer — whether as a near-term heuristic algorithm or as a future fault-tolerant algorithm — takes people who understand both the domain problem and quantum computing. That overlap is rare, and developing it takes time.

His second reason is strategic timing. Dial compares it to being told four years in advance that IBM System/360 was coming. If a company could have been “ready and raring to go” on the first day the machine was available, that would have been a major advantage. For large enterprises already planning on four- and five-year horizons, he says, this is the right time to start thinking seriously.

The caveat is that quantum preparation should not be premised only on a 2029 error-corrected machine. Dial says near-term heuristic work in optimization and chemistry is “getting really close,” with additional thresholds possible in the next couple of years. He does not promise those thresholds will be crossed, precisely because the algorithms are heuristic. But he calls the signs encouraging.

In Dial’s view, the useful preparation is not generic enthusiasm for quantum computing. It is building teams that can identify candidate problems, understand the difference between physical and logical qubits, distinguish proof-based algorithms from heuristics, assess whether a quantum result is verifiable, and track whether classical methods have caught up. His account implies that enterprises that wait until error-corrected hardware is available will face a translation problem at exactly the moment they want to use the technology.

The reason he finds the 2029 timeline “terrifying” is not that quantum computing’s social impact is inherently negative. Dial says he expects the impacts to be overwhelmingly positive, especially for materials science. “We name the ages of man after materials,” he says; a computer that helps materials science is, in his view, a powerful positive prospect.

The terror is operational. IBM has set a public schedule. The remaining learning cycles are countable. The code breakthrough may have made the machine feasible in IBM’s planning, but feasibility still leaves fabrication, packaging, control, error rates, modularity, and software integration to execute. Too many things going wrong could slip the schedule by a year. The fear is not the power of the machine. It is whether the machine can be delivered on time.