Capability 1.3: Below-Threshold Operation & Scaling

This piece is part of an eight‑article series mapping the capabilities needed to reach a cryptanalytically relevant quantum computer (CRQC). For definitions, interdependencies, and the Q‑Day roadmap, begin with the overview: The Path to CRQC – A Capability‑Driven Method for Predicting Q‑Day.

(Updated in Sep 2025)

(Note: This is a living document. I update it as credible results, vendor roadmaps, or standards shift. Figures and timelines may lag new announcements; no warranties are given; always validate key assumptions against primary sources and your own risk posture.)

Introduction

“Below-threshold operation” refers to running a quantum processor at error rates below the critical threshold of a quantum error-correcting code. In simple terms, there is a tipping point in error rates: if each quantum gate and qubit has an error probability lower than this threshold, adding more qubits and more error-correction actually reduces the overall error rate of the computation.

If error rates are above the threshold, however, throwing more qubits at the problem only makes things worse – the additional complexity introduces more errors than the error-correcting code can remove. In the context of building a Cryptographically Relevant Quantum Computer (CRQC), achieving below-threshold operation at scale is often called the “do or die” criterion – without it, a large quantum computer simply cannot function reliably. It marks the divide between today’s noisy intermediate-scale quantum (NISQ) devices and tomorrow’s fault-tolerant quantum machines.

This capability centers on two linked challenges: (1) pushing physical qubit error rates well below the threshold, and (2) scaling up the number of qubits and operations while staying below that threshold. Both aspects are essential. A small device might have errors under 1%, near the threshold of a certain code, but if those error rates grow or even hold steady when you scale to thousands of qubits, the benefit of error correction could evaporate. Ultimately, below-threshold operation & scaling is about building bigger quantum processors without suffering an “error avalanche” as they grow. It requires extraordinary control over each qubit and gate, plus system-wide stability so that adding more qubits continues to increase overall reliability rather than degrade it.

Understanding Error Thresholds

At the heart of below-threshold operation is the quantum error correction (QEC) threshold theorem, one of the major theoretical breakthroughs of the 1990s. Early on, many researchers feared that quantum computers would be too error-prone to ever perform long calculations. However, by the mid-90s, theorists like Peter Shor, Andrew Steane, and others developed the first quantum error-correcting codes, and shortly thereafter came proofs that fault-tolerant quantum computation is possible in principle – but only if error rates per operation are below a certain limit. This critical error probability is known as the accuracy threshold. If physical error rates $$p$$ are below the threshold $$p_{\text{thr}}$$, then using error correction with more qubits can suppress the logical error rate (the error rate of the encoded, protected qubit) exponentially as the code size (or distance) increases. In other words, each extra layer of redundancy yields a dramatic improvement in reliability. If $$p$$ is above $$p_{\text{thr}}$$, error correction fails to keep up – adding qubits just adds more noise, and the logical error rate either stays the same or even worsens.

Every QEC code has its own threshold value. Early quantum codes had very low thresholds – on the order of $$10^{-5}$$ to $$10^{-4}$$ (0.001% or less error per operation). In fact, researchers initially estimated that error rates would need to be below about 0.01% (1 in 10,000 gate errors) just to get any net benefit from error correction with those codes. This seemed utterly daunting at a time when physical qubits were far noisier. Fortunately, improved codes were discovered. Notably, the surface code (a type of topological QEC code proposed by Alexei Kitaev and refined by others in the 2000s) has a much higher threshold on the order of ~1% per gate. In 2006, researchers showed an optimized surface code could tolerate around 1% error – roughly 100 times higher error rates than earlier codes could handle. This was a game-changer: an error rate of 1% (or fidelity of 99%) is still very challenging, but it’s within striking distance of what today’s best qubits can sometimes achieve.

To visualize the threshold effect, imagine a plot of logical error rate versus code size (distance). If the physical error $$p$$ is below threshold, the logical error plummets exponentially as you enlarge the code; if $$p$$ is above threshold, the logical error either flattens out or even rises. Mathematically, for a surface code logical qubit the relationship can be roughly expressed as:

$$$\varepsilon_d \propto \Big(\frac{p}{p_{\text{thr}}}\Big)^{(d+1)/2},$$$

where $$d$$ is the code distance (a measure of code size) and $$\varepsilon_d$$ is the logical error rate. The key point is that if $$p \ll p_{\text{thr}}$$, increasing the distance $$d$$ yields an exponential suppression of $$\varepsilon_d$$. For example, if physical gate errors are half the threshold, then going from distance $$d=3$$ to $$d=5$$ to $$d=7$$ might cut the logical error rate by roughly the factor $$p_{\text{thr}}/p$$ each time. Conversely, if $$p$$ is even slightly above $$p_{\text{thr}}$$, no amount of extra qubits will produce a reliable logical qubit – the errors will accumulate faster than the code can correct them. Julian Kelly, Director of Quantum Hardware at Google, put it bluntly: “There is no point in doing quantum error correction if you aren’t below threshold.”

In summary, operating below threshold means having a safety margin on error rates so that error correction actually works as advertised. In practice, for the popular surface code, the target has been to get physical two-qubit gate errors well below ~1% (ideally into the 0.1% range or better) so that we can scale up the code and watch the logical error rates fall off exponentially. Other codes have different thresholds (some higher, some lower), but the surface code’s ~1% is a useful benchmark because of its popularity and experimental friendliness (it only needs a 2D grid of nearest-neighbor qubits).

Why Below-Threshold Operation Is Critical

Achieving below-threshold error rates at scale is critical and blocking for building a useful large-scale quantum computer. This capability is what unlocks fault-tolerant scaling – the ability to keep improving reliability as you add more qubits. Without it, a quantum computer with a thousand qubits would actually perform worse than one with a hundred qubits, because the extra 900 qubits’ worth of noise would overwhelm any error-correcting benefit. In the context of CRQC (cryptographically relevant quantum computing), this is indeed the “make or break” criterion: if your hardware cannot stay below threshold as it grows, a CRQC (which may require millions of qubits and billions of gate operations) will simply never be achievable.

To appreciate the stakes, consider the requirements for breaking modern cryptography. A full-scale quantum attack (like factoring a 2048-bit RSA key) would require executing on the order of $$10^{9}$$ or more quantum gates in sequence, with each logical gate needing to fail with probability perhaps $$10^{-9}$$ or lower to have a high chance of overall success. That implies each logical qubit must be extraordinarily stable and reliable. Reaching such astronomically low error probabilities is only possible by layering many physical qubits in an error-correcting code and by stringing together many error-corrected operations – and this only works if the physical error rate is comfortably below the threshold so that each layer of encoding provides a net improvement. If adding more qubits didn’t keep reducing the logical error, you’d never reach $$10^{-9}$$ fidelity per operation – you might stall out at, say, 1% or 0.1%, which is far too high. As one example, a recent design for factoring RSA-2048 assumed physical gate error rates of ~0.1% to make the algorithm feasible; at ~0.1% error, with enough qubits (around one million) and fast error-correction cycles, the factoring could be done in under a week. If errors were even a few times higher (say 1% per gate), the required overhead in qubits or time would balloon dramatically, likely beyond practical limits.

Another way to look at it: a future CRQC might need to carry out trillions of operations. Even a single fault among those could be catastrophic if it’s not corrected. Therefore, the effective error per operation (after error correction) has to be extremely low – on the order of one in a trillion or less for a full computation. Achieving that means running the physical hardware with error rates well into the regime where error-correction is efficacious.

Below-threshold operation is what guarantees that when you double the size of your quantum computer (and thus maybe double the number of error-correction cycles), your overall error rate decreases instead of increases. It is the enabler for building quantum computers of arbitrary scale. This is why many experts see the crossing of the error threshold as a pivotal milestone in quantum technology – it’s the point at which the machine can, in principle, be made arbitrarily reliable by scaling up.

In short: if you’re not below threshold at scale, more qubits will make things worse, not better. For quantum computing to deliver on its promise (like cracking cryptography or simulating complex molecules reliably), we must enter the fault-tolerant regime where each layer of redundancy buys us an exponential payoff in error suppression. This is often viewed as the watershed moment separating the noisy era from the era of useful, large-scale quantum computers.

It’s no surprise, then, that below-threshold operation is considered a non-negotiable prerequisite for CRQC. Many other capabilities (high qubit counts, fast gates, etc.) matter too, but if this criterion isn’t met, those extra qubits or speed won’t help you run meaningful algorithms to completion.

Progress to Date: Approaching the Threshold

So, how close are today’s quantum hardware platforms to this below-threshold regime? The encouraging news is that evidence is emerging that we are at or near the error-correction threshold in small-scale devices. In the past few years, multiple experiments have demonstrated key pieces of below-threshold operation on prototype quantum processors.

On the hardware side, several qubit technologies have achieved two-qubit gate fidelities (a typical worst-offender metric) in the ballpark of 99%-99.9%, which is around the threshold range for the surface code. For instance, superconducting qubit systems (used by Google, IBM and others) now regularly report two-qubit gate error rates in the $$10^{-3}$$ to $$10^{-2}$$ range (0.1%-1%) under good conditions. Trapped-ion qubits have pushed even lower – in 2024, a team from Oxford Ionics (now part of IonQ) demonstrated a two-qubit gate error rate of $$3\times10^{-4}$$ (0.03%), essentially 99.97% fidelity. Similarly, researchers have shown that silicon spin qubits can surpass the 99% fidelity mark; one 2021 experiment achieved above 99.5% two-qubit fidelity in a silicon quantum dot device. These numbers are significant because they indicate that, at least in isolated operations or small systems, physical qubit performance is at or slightly better than the rough ~1% threshold of the surface code. In other words, we now have individual gate operations that are likely “good enough” in principle to support fault-tolerant quantum error correction.

Equally important, there have been experimental demonstrations that show quantum error correction actually working (to some extent) on real hardware – that is, encoded “logical” qubits that can outperform the best physical qubit in the device. Early milestones came from experiments with bosonic qubits (quantum harmonic oscillators in superconducting cavities). In 2016, for example, Yale researchers using a bosonic code extended a qubit’s lifetime beyond the break-even point, meaning the error-corrected logical qubit lived longer than an uncorrected physical qubit in the same setup. That was a crucial proof-of-concept that QEC can reduce error rates. However, bosonic codes involve a single “mode” (cavity) acting as a large qubit and don’t use many separate qubits in the way a surface code does.

In the domain of multi-qubit codes (like the surface code or related stabilizer codes), progress accelerated in the 2010s and early 2020s. By 2021, the team at Google Quantum AI reported they had created a small surface code logical qubit that showed some improvement over a physical qubit. Specifically, they implemented a distance-5 surface code and observed lower logical error rates compared to a distance-3 code and to bare qubits – an indication they were operating near or below the threshold in that regime. This was one of the first times a logical qubit in a multi-qubit code was shown to be beneficial (sometimes termed “QEC break-even” for multi-qubit codes). Around the same time, IBM demonstrated repeated QEC cycles on a 17-qubit superconducting device arranged in a heavy-hexagon lattice, encoding a distance-3 logical qubit and actively correcting errors over several rounds. IBM’s experiment showed they could identify and correct single errors in real time, though the logical error rate was still not better than the very best physical qubit. It was, nonetheless, a significant step toward scaling up QEC on their hardware.

Perhaps the most headline-grabbing achievement to date came from Google Quantum AI’s 2023-2024 experiments, which definitively demonstrated below-threshold error correction in a surface code. Using a new superconducting processor nicknamed “Willow” with 100+ qubits, Google researchers engineered a logical qubit in a surface code of distance 5 and then distance 7 – using 49 data qubits for the distance-7 code, plus dozens more ancilla qubits for syndrome measurements. Crucially, when they increased the code size from distance-5 to distance-7, the logical error rate decreased exponentially, as expected if the physical errors were below threshold. In fact, going from a 5×5 grid of qubits to a 7×7 grid reduced the logical qubit’s error rate by about a factor of 2.14. The larger (distance-7) logical qubit had an error rate of roughly $$1.4\times10^{-3}$$ (0.14%) per QEC cycle, compared to about $$3\times10^{-3}$$ (0.3%) per cycle for a single physical qubit over the same interval. This meant the encoded qubit was about twice as reliable as the device’s best bare qubit – a clear sign that error correction was yielding net improvement. In QEC lingo, they had crossed the threshold and achieved “logical qubit breakeven” using a multi-qubit code, for the first time in a planar superconducting array.

Not only did the distance-7 logical qubit outlast the physical ones, it also showed the expected exponential error suppression trend: every time they increased the code distance by 2, the logical error roughly halved. This matches the theoretical prediction for being safely below threshold, and it indicates the hardware had physical gate and memory errors sufficiently low (and sufficiently uncorrelated) for the surface code to do its job. As the Google team summarized, “We are finally below the threshold” for quantum error correction. In addition, their distance-7 code with 100+ qubits was run with a real-time decoder in the loop (a classical system processing syndrome measurements on the fly), and still maintained below-threshold performance with manageable latency. This is important because a practical quantum computer must not only have good qubits, but also a fast error decoding system to correct errors in real time.

It’s worth noting that other platforms are also making strides. Trapped ion systems (e.g. Quantinuum, IonQ, academic groups) have demonstrated small QEC codes and beneficial error mitigation, though typically with fewer qubits so far. For example, Quantinuum reported operating a [[4,1,2]] error-detecting code and a Bacon-Shor code on their ion trap, achieving logical error rates significantly (100×) lower than physical in some cases by tailoring to biased noise. These experiments, while not yet at the scale of the Google surface code, show that multiple qubit technologies are closing in on the threshold from different directions – some by brute-force fidelity improvements (ion traps with 99.9%+ gates), others by clever coding and bias exploitation, and superconducting platforms by a combination of improved fidelity and fast scaling of qubit counts.

To sum up the status: we have empirical proof-of-concept that below-threshold operation is possible on small quantum processors. In specific experiments, logical qubits have been realized that outperform the best physical qubits, thanks to error correction, indicating we can indeed go below threshold in practice. Physical error rates on the order of $$10^{-3}$$ (0.1%) have been achieved in leading platforms, which is at or near the threshold for the surface code. However, these successes have so far been on systems with on the order of $$10^2$$ qubits or fewer, and maintaining such performance as we scale to $$10^3$$ or $$10^6$$ qubits remains an open challenge. That’s what we’ll discuss next.

Demonstrating Exponential Error Suppression

One hallmark of being truly below threshold is the exponential suppression of logical errors with increasing code size. The Google experiment described above is a prime example: they observed that moving from a 3×3 code to 5×5 to 7×7 resulted in an exponential decrease in error rates, roughly consistent with theory. In quantitative terms, their distance-5 code and distance-7 code realized a logical error suppression factor $$\Lambda \approx 2.14$$ when increasing the distance by 2. This factor $$\Lambda$$ is essentially the ratio $$\varepsilon_{d+2}/\varepsilon_{d}$$, and theory predicts $$\Lambda \approx p_{\text{thr}}/p$$ for $$p$$ well below threshold. The fact that $$\Lambda\approx 2.14$$ in their experiment suggests the physical error rate $$p$$ was about half the threshold (since $$p_{\text{thr}}/p \approx 2.14$$). Indeed, their measured logical error per cycle at distance 7 was $$0.143%$$, versus an extrapolated single-qubit error per cycle of ~$$0.3%$$, implying $$p \approx 0.3%$$ and $$p_{\text{thr}}\sim0.6%$$ for their specific implementation – numbers in line with being just below the threshold.

Why is this exponential suppression so important? Because it means we have a fighting chance to scale up to extremely low error rates by increasing the code distance. For a CRQC, as noted, we might need logical error rates in the $$10^{-9}$$ to $$10^{-12}$$ range per operation. No physical qubit is anywhere near that level of accuracy. But if each time we enlarge the code by a certain increment we get, say, a 2× or 3× reduction in logical error, then a sufficiently large code (distance $$\sim25$$ or so) could in principle push errors down to that $$10^{-9}$$ ballpark, even if physical errors are at $$10^{-3}$$ level. Exponential improvement is the secret sauce that makes the concept of fault-tolerant quantum computing feasible at all – it means we don’t need physical qubits with one-in-a-billion accuracy (which would be unattainable); we “just” need to be below threshold and then we can trade qubit quantity for quality via error correction.

Demonstrating exponential error suppression experimentally is also a stringent test of the whole stack: qubit fidelity, stability of the device, quality of the error decoder, and absence of excessive correlated noise. The Google team, for instance, had to run their surface code for up to a million cycles to gather statistics, and even showed that their decoder could keep up in real time with a modest 63 microsecond latency. They also ran a simpler repetition code out to distance 29 (using up to 29 qubits in a line) to test deeper suppression. Interestingly, at that extreme, they found the logical error no longer dropped off as nicely – it was limited by rare correlated error events (like cosmic rays hitting the chip) that occurred roughly once every hour. This illustrates a key point: to really get an exponential curve over many orders of magnitude, every aspect of the system’s noise must be tamed, including those one-in-a-billion events. A single high-energy cosmic ray can momentarily blast many qubits at once, creating a burst of errors that no local code can fully correct. Thus, showing exponential suppression from, say, $$10^{-3}$$ down to $$10^{-9}$$ will require not only increasing code distance but also mitigating such correlated error sources (through shielding, error detection schemes, or software that can recognize and exclude “ephemeral” events). We’ll talk more about these challenges next.

Nonetheless, the experiments to date have given a strong validation that below-threshold error correction is not just a theory – it works in practice on real quantum chips, at least up to moderate distances (5 to 7). Each increment in code size gave a predictable improvement, exactly the trend we need to maintain to reach fault tolerance. The focus now is on extending this trend to larger scales and ensuring that it continues in the face of new noise mechanisms that arise as machines grow.

Challenges in Scaling Up

While the recent results are exciting, significant challenges remain in proving below-threshold operation at the scales required for CRQC. In current experiments, we have seen exponential error suppression up to distance $$d\approx7$$ and on processors with on the order of $$10^2$$ qubits. However, a cryptographically relevant quantum computer may require code distances on the order of $$d\approx20$$-$$30$$ (to get those $$10^{-9}$$ logical error rates) and qubit counts in the $$10^5$$-$$10^6$$ range. Bridging that gap is a formidable endeavor. Here are some of the key challenges and interdependencies involved:

Maintaining Physical Error Rates at Scale

It’s one thing to have 0.1% error gates on a system with 50 qubits, and quite another on a system with 5,000 qubits. As systems scale up, new error sources tend to creep in. Control wires, microwave crosstalk, vibrations, heating, inhomogeneities across a larger chip – all these can degrade fidelity. For example, in a larger superconducting chip, qubits at the edges might behave slightly differently than those in the center due to wiring or magnetic field variations. Trapped-ion systems might face mode crowding and difficulty cooling all ions as the chain length grows. The net result could be that the average error rate $$p$$ starts to rise with system size if mitigations aren’t in place. Staying below threshold requires that engineers improve the baseline qubit quality fast enough to overcome any size-related noise increases. This is why materials science, fabrication improvements, and better hardware design (3D integration, shielding, etc.) are all interdependent with the below-threshold scaling goal. Each qubit added should ideally not introduce proportionally more error.

Stability Over Long Times

A full-scale quantum computation might run for many hours or days. The hardware needs to maintain below-threshold performance not just at the start, but consistently over the entire run. This is challenging because calibrations can drift, and small error rate fluctuations could push you above threshold temporarily. The Google experiment ran for many cycles (up to a million) and had to ensure the error rates didn’t deteriorate over time. Continuously running error correction for hours will require extremely robust calibration, perhaps automated tuning, and handling of environmental changes (temperature fluctuations, component aging, etc.). We essentially need an “industrial-grade” stability in the quantum processor – something not yet demonstrated, as most current experiments run on the order of minutes at most in one continuous shot.

Correlated Errors and Crosstalk

As mentioned, rare but high-impact events (cosmic rays, radiation bursts, magnetic glitches) can cause simultaneous errors in many qubits. Also, in a densely packed qubit array, there may be crosstalk – e.g. when you drive a microwave pulse on one qubit, it slightly perturbs a neighbor. These correlations violate the usual assumption of independent errors that most QEC codes rely on. A few correlated errors can mimic a higher effective error rate and spoil the exponential suppression. To scale below-threshold performance, engineers will need to reduce such correlations (through shielding, encoding data in ways that can detect spatially correlated hits, or designing operations to minimize crosstalk). Some approaches involve using alternative codes or tailored decoding algorithms that account for known correlations. For instance, if certain error patterns are more likely, a smart decoder can be trained to recognize them. We might also need “refresh” procedures to periodically remove accumulated error byproducts (like qubit leakage states or spectator mode excitations) that otherwise build up in large systems.

Syndrome Measurement Quality

In QEC, measuring error syndromes (parity checks) is how the code learns about errors without observing the data qubits directly. Those measurements themselves can be noisy or faulty. If the measurement error is too high, it can effectively lower the threshold. Thus, scaling up will require that readout errors are also below threshold. Many current systems have higher error rates for measurements than for gates – e.g. a superconducting qubit readout might be 2% error even if gates are 0.5%. Some experiments mitigate this by doing repeated measurements or using flag qubits to catch measurement mistakes, but it’s an area needing improvement. Operation below threshold at scale will likely demand faster, more accurate readout of qubits, possibly via new techniques (like multiplexed readout or better quantum nondemolition measurements).

Decoder Performance and Latency

A often under-appreciated aspect is the classical computing side – the decoder algorithm that takes in the syndrome data and outputs corrections. As the code distance and number of qubits grow, decoding becomes more computationally intensive. If the decoder is too slow, syndromes will back up and you won’t be correcting errors in real time, which can let errors spread. Google’s experiment integrated a hardware decoder that could keep up with their 1.1 microsecond cycle time (with ~63 μs latency). But for larger codes (distance 11, 13, etc.), more complex decoders might be needed, potentially requiring powerful classical co-processors or FPGA solutions. Ensuring the decoder itself doesn’t become the bottleneck is a challenge. Moreover, the decoder must be accurate – a suboptimal decoder might misidentify the error pattern even if the physical hardware is below threshold, thereby negating some of the advantage. Research is ongoing into high-speed, high-accuracy decoders (including machine-learning-based decoders) to support larger codes.

Magic States and Other Overhead

A full fault-tolerant quantum computer not only needs to preserve memory (logical qubits) but also perform logical gates, especially non-Clifford gates via magic state distillation. Magic state distillation has its own effective threshold – the input “raw” magic states must have error below a certain value or the distillation fails to improve them. If our base physical qubits are below the surface code threshold, it increases the likelihood that they can also produce magic states above the distillation threshold (which might be around, say, 3% error per state for typical protocols). However, if not, we’d have to use additional rounds of distillation, compounding the resource overhead. This means that achieving below-threshold operation helps not just in storing qubits, but in generating the other resources needed for universal computation. It’s an interdependent piece: better physical qubits (lower error) reduces the overhead in magic state factories, and conversely, efficient magic state techniques (like the recently proposed “magic state cultivation”) reduce the burden on having ultra-extreme physical fidelity. Both must work hand-in-hand to make a full CRQC feasible.

In summary, proving out below-threshold scaling to thousands or millions of qubits will involve nearly every part of the quantum stack. It’s not just about qubit quality, but also about integration, environment control, error decoding, and system architecture. The “gap to CRQC” for this capability can be described as going from a ~100-qubit, distance-7 demonstration to a >1000-qubit, distance-20+ demonstration while keeping physical error rates at or below the few-in-a-thousand level. Each increase in scale will test whether new errors emerge. This is why companies like IBM and Google are incrementally increasing qubit counts and concurrently working to keep errors in check. IBM’s roadmap, for instance, is to scale to 433 qubits (Osprey) and 1121 qubits (Condor) in the next couple of years, with the clear understanding that error rates must come down or at least stay constant as they do so. If those larger chips can be made to run a surface code with, say, distance 9 or 11 and still see exponential suppression of errors, it will be a huge leap forward in confidence.

Outlook: Towards Fault-Tolerant Scaling

The next few years will be crucial for below-threshold operation and scaling. Having achieved a toehold in the fault-tolerant regime (with distance-7 codes and ~100 qubit systems), researchers are now aiming to extend that beachhead. We can expect to see attempts at larger distance codes – perhaps distance 9, 11, or even beyond – as hardware improves. Google, for example, will likely continue scaling up their superconducting processors, possibly needing a few hundred physical qubits to test a distance-9 surface code. IBM with its 433-qubit and 1121-qubit processors might explore different codes (surface code or heavy-hexagon codes of moderate distance) to see if logical error rates keep dropping. Ion trap systems might not yet have the qubit counts to do large distance codes, but their approach could involve networking smaller modules or using error-correcting codes tailored to their low-error but slower gates.

One optimistic sign is that hardware fidelities continue to improve year by year. The record for two-qubit gate fidelity keeps getting broken – as noted, 99.9% (one in a thousand error) is no longer a distant dream but a state-of-the-art reality, and even 99.99% (one in ten-thousand error) has been achieved on ion traps. If superconducting qubits can also push into the 0.01% error range (through better materials, 3D qubits, etc.), the threshold margin widens, making it easier to suppress errors at scale. Alternative approaches like error mitigation and bosonic qubits might also play supporting roles – for example, combing a bosonic encoding with a small stabilizer code (a technique demonstrated in 2022) yielded an 8.8× improved logical lifetime in a recent experiment. Such hybrid schemes could reduce the physical qubit count needed for a given logical performance.

Looking ahead 5-10 years, many experts anticipate that we will see the first fully demonstrated logical qubits with error rates at the $$10^{-6}$$ or $$10^{-9}$$ level, which would be true fault-tolerant qubits. These might involve thousands of physical qubits each. Industry roadmaps are aligned with this: for example, some companies and government programs talk about achieving a million-qubit quantum processor by the end of the decade (2030 or so). If those qubits are of sufficient quality (i.e. well below threshold individually), then such a machine in principle could run error-corrected algorithms that break cryptography or tackle chemistry problems beyond classical reach. That said, there are many engineering breakthroughs needed to go from a 100-qubit experiment to a million-qubit facility (cryogenics, interconnects, power, etc.). It’s not a given that a million-qubit device in 2030 will indeed have all qubits performing at 0.1% error rates – but that is the target.

We might also see new error-correcting codes or frameworks that improve effective thresholds or reduce overhead. For instance, quantum LDPC codes (low-density parity-check codes) are an active research area; some LDPC codes promise higher thresholds or more efficient encoding than surface code. If one of those can be implemented, it might relax the hardware requirements a bit (for example, a code with a 2% threshold would be more forgiving). However, these codes often require long-range connections or complex circuitry, which is why surface code remains the favorite for now.

Another frontier is software and adaptive techniques: smarter decoders can squeeze more performance out of the same hardware. In 2024, Google reported using a machine-learning (transformer-based) decoder that improved decoding accuracy for their codes. There’s also interest in adaptive error correction – where the code or decoder parameters are adjusted on the fly based on observed error patterns. All of these could help maintain below-threshold operation as systems scale, by effectively raising the threshold or coping with error bursts.

In terms of timeline for CRQC, the achievement of stable below-threshold operation on large arrays of qubits is one of the biggest uncertainty factors. Optimistically, if things go well, one could envision by the late 2020s a quantum computer with perhaps ~1,000 good physical qubits operating below threshold, yielding a handful of logical qubits that can perform very low-error operations. That might be enough to run some short cryptographic algorithms (like a small instance of Shor’s algorithm) to demonstrate the concept. Reaching thousands of logical qubits (millions of physical) for full cryptographic breaking might take longer, perhaps into the early 2030s, but it all hinges on solving the engineering problems outlined. The moment when engineers can say “we added more qubits and the logical error went down another 10×” on a large scale will be the true dawn of fault-tolerant quantum computing.

Tracking Progress in Below-Threshold Performance

If you’re interested in tracking how the field is advancing toward below-threshold operation and scaling, here are a few tips:

Watch for QEC Milestone Experiments

Keep an eye on news from major quantum hardware groups (Google Quantum AI, IBM Quantum, IonQ, Quantinuum, academic labs like Delft, MIT, etc.). When they publish results demonstrating higher distance error-correcting codes or record-low error rates, that’s a direct indicator of progress. For example, Google’s distance-7 surface code experiment was reported in Nature in late 2024 and widely covered in science news. Future announcements of, say, a distance-9 code, or a logical qubit that lasts 100× longer than physical, will likely be publicized.

Monitor Hardware Metrics

Improvements in raw physical qubit metrics translate to threshold progress. Look for reports of two-qubit gate fidelities creeping upwards (from 99% to 99.9% to 99.99% and so on), as well as coherence times extending. Many companies release these numbers in press releases or hardware papers. For instance, IonQ’s blog announced when they hit the 99.99% two-qubit fidelity milestone. IBM regularly updates the performance of their devices on the IBM Quantum Experience website (including average error rates). Reaching and surpassing that ~99% fidelity mark on larger and larger systems is a sign that threshold-capable hardware is maturing.

Follow the “Logical Qubit” metrics

Ultimately, logical error rate is what matters. So pay attention to any data on logical error per circuit cycle or logical qubit memory time. The ratio of logical error to physical error tells you if they’re below threshold. In Google’s case, a logical error of 0.14% vs physical 0.3% was the key comparison. If you see future reports where, say, a logical qubit of distance 11 has an error of 0.01% while physical qubits are at 0.5%, that would be a dramatic below-threshold validation. Some resources like the Quantum Error Correction Zoo keep track of realized quantum codes and their performance in experiments, which can be a handy reference to see the state of the art.

Check Technology Roadmaps

Companies often lay out targets in their roadmaps (e.g., IBM’s roadmap aiming for an error-corrected logical qubit by a certain year). These can give a sense of anticipated timelines. If a milestone is achieved or delayed, it’s informative. For example, IBM has mentioned goals like demonstrating a useful logical qubit around 2025-2026 on their 1000+ qubit hardware. Tracking whether those goals are met can indicate how the below-threshold scaling is proceeding.

Conferences and Preprints

Many quantum computing results first appear as arXiv preprints or are announced at conferences (APS March Meeting, IEEE Quantum Week, etc.). If you are technically inclined, scanning the arXiv quant-ph archive for “quantum error correction” papers can show you the latest. Look for keywords like “fault-tolerant”, “below threshold”, “logical qubit”, “distance code” in titles or abstracts. Research news sites (like Phys.org, Quanta Magazine, or the Quantum Computing Report) also summarize big developments in more digestible form for the broader public.

Interdependency Signals

Since below-threshold operation ties into other factors (like decoder performance and magic state distillation), progress in those areas is also relevant. For instance, if you hear that a new high-speed decoder was implemented or that magic state generation got more efficient, indirectly that supports below-threshold scaling (because it reduces overhead or prevents bottlenecks).

By keeping tabs on these indicators, you can form a picture of how quickly quantum computing is overcoming the “do or die” threshold challenge. As of now, the field has crossed the first threshold milestone on a small scale (showing improvement with a distance-7 code). The race is on to extend that success to the scales required for full-blown cryptography-breaking machines.

Conclusion

Below-threshold operation and scaling is arguably the linchpin capability for realizing practical quantum computers. It’s the principle that if you can get each part of your quantum computer just quiet enough – below a certain error rate – then building a bigger machine helps rather than hurts. Thanks to decades of theory we know this principle is sound, and thanks to recent experimental breakthroughs we now know it can be achieved in the lab, at least in miniature. A logical qubit that outperforms its constituents is no longer hypothetical; it has been demonstrated. This gives the community a tangible confidence boost: fault-tolerant quantum computing is not a pipe dream, but a matter of engineering and scaling.

That said, the journey from a 100-qubit, error-corrected demo to a million-qubit cryptanalysis engine is a profound challenge. The gap will be closed by continued improvements in physical qubit fidelity, by clever system design to avoid new noise as we scale up, and by advances in error correction techniques themselves (codes, decoders, etc.). It’s a holistic effort – breakthroughs in materials science, cryogenics, classical control electronics, and quantum architecture all have a role to play in keeping the error rates suppressed as the qubit count grows.

For cyber professionals and quantum enthusiasts, the message is this: keep an eye on that error curve. When you see news that a larger quantum chip has achieved an even lower logical error rate than previous smaller chips, that’s the sign of true progress toward CRQC. Below-threshold operation is the tipping point that turns quantum computers from fragile devices into scalable, reliable engines of computation. It’s the transition from NISQ to the fault-tolerant era. With continued effort, and if current trends continue, we can be cautiously optimistic that the exponential suppression of errors will hold and extend, enabling quantum computers to tackle ever more complex and lengthy tasks. In the end, crossing this threshold – and staying below it as we climb in scale – is what will unlock the full potential of quantum computing. The recent achievements are the first critical steps on that path, showing that the “die” can indeed be cast in favor of do rather than die, as quantum machines grow larger and more powerful.