Introduction: Why This Matters
In my experience explaining quantum error correction to curious beginners, the conversation usually stalls at the same place: “So the computer fixes its own mistakes?” Yes—but not the way you think. It doesn’t spot a wrong answer and swap it out like a spell-checker. It performs a delicate, repeated dance of measurement and reset, all while the rest of the machine keeps running. Until recently, nobody had demonstrated that dance at a scale large enough to matter. Here is the article of quantum error correction real-time feedback for your reading and information.
In October 2026, researchers from Rutgers, IBM, and collaborating institutions published a landmark experiment in Nature Physics. Using a 156-qubit IBM Heron processor, they selected a chain of up to 100 connected qubits and programmed the system to alternate between two competing tasks: scrambling information into chaos, and repeatedly checking and resetting individual qubits to restore order . They performed nearly 5,000 two-qubit operations alongside nearly 5,000 measurement-and-reset cycles—all while the processor continued running.
What I’ve found, following the quantum computing space for years, is that this result is easy to misread. It is not a fault-tolerant quantum computer. It did not protect a logical qubit through a useful computation. What it did was prove that present-day hardware can coordinate the kind of rapid, repeated feedback that fault tolerance will demand. For professionals needing a refresher, the key number is this: the system crossed a sharp threshold from chaos to control when resets outpaced scrambling, confirming a theoretical prediction about quantum dynamics . For beginners, the takeaway is simpler: quantum computers just got one step closer to cleaning up their own mess—without stopping what they’re doing.
Key Takeaways (at a glance):
- Rutgers and IBM demonstrated real-time quantum feedback on up to 100 qubits using a 156-qubit IBM Heron processor.
- The experiment ran nearly 5,000 two-qubit gates and nearly 5,000 measurement-reset cycles in a single sequence .
- Researchers observed a sharp “phase transition” from chaotic to controlled behavior when reset frequency crossed roughly 50% .
- This is a capability demonstration, not a fault-tolerant computation: no logical qubit was protected and no algorithm was run.
- The work validates the hardware coordination needed for future error-corrected quantum computers.
Background / Context: The Error Problem Nobody Can Avoid
Quantum computers are not magic. They are fragile. A qubit—the quantum equivalent of a bit—can exist in a superposition of 0 and 1, which is what gives quantum machines their potential power. But that same delicacy means heat, stray electromagnetic signals, imperfect control pulses, and tiny manufacturing flaws can corrupt the qubit’s state. Over thousands of operations, those errors pile up until the final answer is garbage .
The standard solution is quantum error correction (QEC): spread information across many physical qubits, repeatedly check for errors, and correct them before they ruin the computation. But there’s a catch. Checking a qubit means measuring it. Measuring a qubit disturbs it. And quantum information cannot be copied as a backup. A fault-tolerant machine must therefore detect and correct errors without destroying the data it’s trying to protect—and it must do so while the computation is still running .
Until now, demonstrations of real-time feedback had been limited to small systems. The Rutgers-IBM experiment scaled the coordination problem to a chain of 100 qubits, showing that the hardware can juggle thousands of gates, measurements, and resets without falling apart. As Maika Takita, a principal research scientist at IBM and a senior author of the study, put it: “The challenge was not simply to measure a qubit, but to do it repeatedly while the rest of the processor continued to operate” .
Key Concepts Defined (For Beginners and Refreshers)
Qubit: The basic unit of quantum information. Unlike a classical bit (0 or 1), a qubit can hold a superposition of both states until measured.
Scrambling: A process that spreads information across neighboring qubits, creating complex, chaotic quantum states. In the experiment, the scrambling operation acted like repeatedly shuffling a deck of cards—the original order becomes harder and harder to reconstruct .
Measurement and Reset: Reading a qubit’s state and, if necessary, flipping it back to a known state (usually |0⟩). In the experiment, the reset was conditional: if the measurement found the qubit in |1⟩, a follow-up operation flipped it to |0⟩ .
Real-Time Feedback: The ability to measure part of a quantum system and use that result to decide what to do next, all while the system continues operating. This is different from running a circuit, measuring at the end, and starting over.
Phase Transition (in this context): A sharp collective change in the system’s behavior as a controlling parameter crosses a threshold. In the experiment, the parameter was the probability of resetting rather than scrambling. Below roughly 50%, chaos won. Above it, control won . This is analogous to water freezing at 0°C—a small change in temperature produces a dramatic change in the system’s state.
Fault Tolerance: A property of a quantum computer that can keep computing correctly even when individual qubits and operations fail. No one has built a fault-tolerant quantum computer yet. The Rutgers-IBM experiment is a stepping stone, not the destination .
How It Works: Step-by-Step Breakdown
Step 1: Choose the Hardware
The team used IBM’s 156-qubit Heron processor, one of the most powerful superconducting quantum processors available. From the full chip, they selected a connected chain of up to 100 qubits—large enough to exhibit collective behavior, small enough to control precisely .
Step 2: Set Up the Competition
The experiment was designed around two competing operations applied in alternation:
- Scramble: An operation that entangles neighboring qubits, spreading information and generating chaos.
- Control: A measurement of a single qubit followed by a conditional reset. If the qubit was measured in |1⟩, it was flipped to |0⟩. This pushed the system toward an ordered state where every qubit was zero .
Step 3: Vary the Balance
The researchers programmed the system to choose between scrambling and control with a tunable probability. By adjusting that probability, they could dial the system from “mostly chaos” to “mostly control” .
Step 4: Run the Sequence
The largest circuits involved nearly 5,000 two-qubit entangling operations and nearly 5,000 measurement-and-reset cycles. Crucially, these weren’t separate experiments stitched together—they ran in a single sequence, with the processor coordinating gates, measurements, and conditional operations on the fly .
Step 5: Observe the Transition
When scrambling dominated, the system remained chaotic. When resets were frequent enough, the system settled into the ordered state. Near a reset probability of roughly 50%, the behavior changed sharply—a phase transition. The distinction became clearer as the researchers studied larger chains, exactly as theoretical predictions had suggested .
Step 6: Verify Quantum Behavior Survived
An orderly final state could, in principle, be produced by a noisy system that had lost all quantum coherence and behaved classically. The team checked for this by comparing the experimental fluctuations against several theoretical descriptions. Quantum simulations matched the data better than classical models, particularly in the chaotic regime and near the transition, confirming that genuine quantum dynamics were at play .
What This Is Not
The experiment did not protect a logical qubit. It did not run a useful algorithm. It did not demonstrate fault tolerance. It demonstrated the coordination capability—the ability to measure, decide, and reset thousands of times across a large system—that fault tolerance will require.
Why It’s Important
The Scale Problem
Quantum error correction is often described in terms of codes: surface codes, color codes, and so on. But codes are mathematics. Making them work requires hardware that can perform measurements and feed back corrections fast enough and accurately enough, across enough qubits, without the whole system decohering. The Rutgers-IBM experiment shows that a 100-qubit chain can sustain that kind of activity. That’s a hardware milestone, not a software one .
The Threshold Confirmation
The observed phase transition—chaos giving way to control at a predictable threshold—confirms theoretical predictions about driven quantum systems. It also suggests a practical design principle: if you can make resets frequent enough, you can steer a noisy quantum system toward order. That’s a useful intuition for future error-correction architectures .
What It Doesn’t Solve
The experiment used a deliberately designed model system. It didn’t diagnose arbitrary errors in a real algorithm. It didn’t handle leakage errors (where a qubit drifts into states outside the 0/1 computational space). And it didn’t demonstrate the kind of repeated, reliable error correction that a fault-tolerant machine will need. As the researchers themselves emphasize, this is a landmark on the road, not the destination .
Sustainability in the Future
Quantum computing hardware is resource-intensive. Superconducting processors like IBM’s Heron operate at millikelvin temperatures, requiring dilution refrigerators that consume significant power and helium. The Rutgers-IBM experiment didn’t change that equation—it ran on existing hardware.
The sustainability question for quantum error correction is really about efficiency. Every measurement and reset cycle costs time and introduces opportunities for new errors. If fault-tolerant quantum computers require millions of physical qubits, the energy and materials footprint becomes substantial. The Rutgers-IBM result is a data point suggesting that present-day hardware can handle the coordination, but it also highlights how far we are from the scale of fault tolerance. A 100-qubit chain is impressive; a million-qubit machine with real-time feedback is a different order of engineering.
On the positive side, better error correction means fewer wasted cycles. A quantum computer that can correct its own errors in real time is more efficient than one that has to discard failed runs and start over. If fault tolerance eventually arrives, it will make quantum computing more sustainable per useful computation, not less.
Common Misconceptions
Misconception #1: “This is a fault-tolerant quantum computer.”
No. The experiment demonstrated a capability relevant to fault tolerance—real-time feedback across many qubits—but it did not protect logical information through a computation. Fault tolerance requires encoding a logical qubit across many physical qubits, repeatedly extracting error syndromes, and decoding them in real time. The Rutgers-IBM experiment did a simplified version of the measurement-and-reset loop, not the full encode-protect-decode cycle .
Misconception #2: “The quantum computer fixed its own errors.”
It reset qubits to a known state. That’s a form of control, but it’s not error correction in the QEC sense. Error correction preserves quantum information by detecting and correcting errors without measuring the data directly. The experiment measured individual qubits and reset them, which destroys any superposition they held. The goal was to study the dynamics of a driven system, not to protect a computation .
Misconception #3: “100 qubits is a lot.”
It is for this kind of experiment, but it’s small compared to what fault tolerance will require. Estimates for useful fault-tolerant machines range from hundreds of thousands to millions of physical qubits, depending on the code and the target error rate. The 100-qubit demonstration is a coordination milestone, not a scale milestone.
Misconception #4: “The phase transition means the system suddenly became useful.”
The transition is a physics result. It confirms that a driven quantum system with competing scrambling and reset operations exhibits a sharp change in behavior. It’s interesting because it validates theory and demonstrates controllability. It doesn’t mean the system crossed a threshold into computational usefulness.
Recent Developments (2025–2026)
The Rutgers-IBM result is part of a broader acceleration in quantum error correction.
Quantinuum’s Record Logical Fidelity
In October 2026, Quantinuum announced a world-record logical fidelity of 99.9995%—just five errors per million operations—using a color code on its Helios trapped-ion computer. The error rate was ten times lower than Quantinuum’s own record from the previous month and 100 times lower than the best published result on other hardware modalities . Quantinuum says the result validates its path to a fault-tolerant machine by 2029.
Syndrome Resampling for Better Thresholds
A Physical Review Letters paper accepted in October 2026 introduced “syndrome resampling,” a decoder-agnostic method that increases quantum error correction thresholds without additional hardware. Simulations showed logical error rate reductions of up to four orders of magnitude in experimentally relevant regimes . This is a software-side advance that could complement hardware improvements like the Rutgers-IBM feedback demonstration.
Partial Fault Tolerance Tools
Researchers at Penn State and IBM are developing open-source software tools for “partially fault-tolerant” quantum computing, targeting architectures that protect basic operations with full error correction while applying some rotations with only partial protection. The goal is to avoid the overhead of fully fault-tolerant designs for near-term simulations .
Success Stories: The Trajectory from Small to Large
From AMANDA to IceCube (a different field, same lesson)
It’s worth remembering that big science often follows a trajectory of small demonstrations leading to large-scale instruments. The IceCube neutrino observatory, which won the 2026 Nobel Prize in Physics, began as a risky idea in 1988 and took decades to build. The Rutgers-IBM quantum feedback experiment is much earlier in its trajectory, but the pattern is similar: a capability demonstrated at small scale, refined, and eventually scaled into something transformative .
Google’s Surface Code Milestone
In late 2024, Google Quantum AI demonstrated that increasing the size of a surface-code patch made logical qubits more reliable—a key requirement for fault tolerance. The result showed that error correction could work in principle on superconducting hardware. The Rutgers-IBM experiment adds a different piece: the ability to run feedback loops during a computation, not just at the end .
Quantinuum’s Rapid Iteration
Quantinuum’s back-to-back records in September and October 2026—using different error-correction codes on the same Helios hardware—demonstrate that the field is not just making incremental progress but iterating rapidly. The company credits its architecture’s flexibility for allowing different codes to be tested and combined without rebuilding the machine .
Real-Life Examples: What This Looks Like in Practice
The Birthday Party Argument
The Rutgers-IBM project began, according to reporting, with a conversation at a birthday party in 2021. Jedediah Pixley, a professor at Rutgers, and a colleague argued about whether a particular quantum effect had an analogue in ordinary physics. The argument grew into a theory of controlling quantum chaos, which was first tested in classical simulations and then, when the opportunity arose, on IBM’s quantum hardware . The lesson: big experiments sometimes start with small arguments.
The Reset Decision
Imagine you’re a qubit in the chain. At each step, a coin is flipped. Heads: you get scrambled with your neighbors, entangling and spreading information. Tails: you get measured. If the measurement finds you in |1⟩, a conditional pulse flips you to |0⟩. If it finds you in |0⟩, nothing happens. Over thousands of steps, the balance between heads and tails determines whether the whole chain stays chaotic or settles into order. The experiment’s achievement is that the processor can flip that coin, measure, decide, and act—thousands of times—without losing track of the sequence .
What a Fault-Tolerant Machine Would Look Like
In a real fault-tolerant quantum computer, the feedback loop would be more complex. Instead of measuring individual qubits and resetting them, the machine would measure stabilizers—collective properties of groups of qubits that reveal errors without revealing the encoded data. A classical decoder would interpret those measurements and apply corrections. The Rutgers-IBM experiment is a simplified cousin of this process: measurement, decision, conditional action, repeated at scale. It’s not the full thing, but it exercises the same muscles.
Conclusion and Key Takeaways
The Rutgers-IBM experiment is not a quantum computer that fixes its own mistakes in the way a self-driving car corrects its steering. It’s a demonstration that a 100-qubit chain can run thousands of measurement-and-reset cycles while the rest of the processor keeps working, and that the system exhibits a sharp, predictable transition from chaos to control when resets are frequent enough. Those are engineering and physics milestones, not computational ones.
For curious beginners, the lesson is that quantum error correction is a systems problem, not just a math problem. You can have the best error-correcting code in the world, but if your hardware can’t measure and reset fast enough, across enough qubits, without losing coherence, the code doesn’t help. This experiment shows the hardware is getting closer.
For professionals, the result is a data point on the roadmap to fault tolerance. It confirms that real-time feedback at the 100-qubit scale is feasible on superconducting hardware. It doesn’t solve decoding, leakage, or logical encoding. But it clears a hurdle that many in the field had identified as a critical unknown.
Key Takeaways:
- Rutgers and IBM demonstrated real-time quantum feedback on up to 100 qubits using a 156-qubit Heron processor.
- The experiment ran nearly 5,000 entangling gates and nearly 5,000 measurement-reset cycles in a single sequence.
- A sharp phase transition from chaos to control appeared when reset frequency crossed roughly 50%.
- The work is a capability demonstration for fault tolerance, not a fault-tolerant computation.
- Complementary advances in decoders, logical fidelity records, and partial fault-tolerance tools are accelerating the field.
Frequently Asked Questions (FAQ’s)
1. What exactly did Rutgers and IBM demonstrate?
They showed that a 156-qubit IBM processor can perform repeated measurements and conditional resets on a chain of up to 100 qubits while the rest of the system continues operating. They ran nearly 5,000 two-qubit gates and nearly 5,000 measurement-reset cycles, and observed a sharp transition from chaotic to controlled behavior when resets became frequent enough .
2. Is this a fault-tolerant quantum computer?
No. Fault tolerance requires encoding logical qubits, detecting errors without measuring the data directly, decoding the error syndrome in real time, and correcting the errors—all while preserving quantum information. This experiment did none of those things. It demonstrated a hardware capability that fault tolerance will need .
3. Why does this matter for error correction?
Because error correction is not just math. It requires hardware that can measure, decide, and act repeatedly without the system falling apart. The experiment shows that present-day hardware can coordinate thousands of such operations across a large qubit chain. That’s a prerequisite for the more complex feedback loops that fault tolerance will use .
4. What is the “phase transition” they observed?
It’s a sharp change in the system’s collective behavior as the balance between scrambling and resetting shifts. Below roughly 50% reset probability, chaos dominated. Above it, the system settled into an ordered state. The transition became sharper as the qubit chain grew longer, which is characteristic of a phase transition .
5. How is this different from just measuring qubits at the end of a circuit?
In a standard quantum computation, you run the circuit, measure the qubits, and get an answer. In this experiment, measurements happened during the sequence, and the results determined subsequent operations (resets) while the rest of the processor kept running. That real-time feedback is the new capability .
6. What is scrambling, in this context?
Scrambling is an operation that entangles neighboring qubits, spreading information across the system. It’s like shuffling a deck of cards: the original order becomes harder to recover. In the experiment, scrambling competed with resets to determine the system’s long-term behavior .
7. What does a reset do?
A reset measures a qubit and, if it’s found in the |1⟩ state, flips it to |0⟩. This pushes the system toward a known, ordered state. In the experiment, resets were applied conditionally based on measurement outcomes .
8. Did they use all 156 qubits?
No. They selected a connected chain of up to 100 qubits from the 156-qubit processor. The chain structure allowed them to control the connectivity and study how the system’s behavior changed with size .
9. What is the IBM Heron processor?
A 156-qubit superconducting quantum processor from IBM. It’s one of the most powerful quantum processors available and supports the mid-circuit measurement and conditional operations needed for this experiment .
10. How long did the experiment take?
The search results don’t specify the wall-clock duration of the experimental runs. The key number is the sequence length: nearly 5,000 two-qubit operations and nearly 5,000 measurement-reset cycles in the largest circuits .
11. Did the experiment preserve quantum information?
No. The resets destroyed the quantum state of the measured qubits. The goal was not to preserve information but to study the dynamics of a driven system and demonstrate feedback coordination. A fault-tolerant machine would need to correct errors without destroying the encoded information .
12. What are the next steps toward fault tolerance?
The field needs to demonstrate full error-correction cycles: encoding a logical qubit, repeatedly extracting error syndromes, decoding them in real time, and applying corrections. Quantinuum’s recent logical fidelity records and Google’s surface-code work are complementary steps in that direction .
13. What is a logical qubit?
A logical qubit is an encoded qubit spread across many physical qubits, designed to be more reliable than any single physical qubit. Protecting a logical qubit through a computation is the central goal of quantum error correction.
14. What is a decoder?
A decoder is a classical algorithm that takes error-syndrome measurements (the results of checking qubits for errors) and infers the most likely error pattern, so it can be corrected. Fast, accurate decoders are essential for real-time feedback .
15. What is syndrome resampling?
A method introduced in a 2026 Physical Review Letters paper. It increases error-correction thresholds by biasing syndrome averages toward more likely patterns, reducing logical errors without additional hardware. Simulations showed up to four orders of magnitude reduction in logical error rates .
16. What is Quantinuum’s record?
Quantinuum reported 99.9995% logical fidelity on its Helios trapped-ion computer using a color code—five errors per million operations. The company says this validates its path to fault tolerance by 2029 .
17. How does Quantinuum’s approach differ from IBM’s?
Quantinuum uses trapped-ion qubits, which have different error characteristics than superconducting qubits. The company claims its architecture allows rapid iteration across different error-correction codes. IBM’s Heron processor uses superconducting qubits. Both approaches are pursuing fault tolerance .
18. What is a “partially fault-tolerant” quantum computer?
A design that applies full error correction to some operations (like basic gates) while using less-protected “analog” rotations for others, trading some accuracy for lower qubit overhead. Researchers are developing software tools to explore this trade-off .
19. Why is real-time feedback hard?
Because quantum measurement is destructive. Measuring a qubit collapses its state. Feedback requires measuring, deciding, and acting—all within the coherence time of the system, before errors accumulate and the computation is lost. Coordinating this across many qubits adds complexity .
20. Did the experiment use machine learning?
The search results for this specific experiment do not mention machine learning. IBM and others have used reinforcement learning for quantum control in separate work, but the Rutgers-IBM feedback experiment focused on measurement-and-reset dynamics .
21. What is the significance of the 50% threshold?
It’s the point where the scrambling and reset operations are equally likely. Near this balance, small changes in the probability produce sharp changes in the system’s behavior. The researchers observed that the transition became clearer with larger systems, confirming theoretical predictions .
22. Could this experiment be done on other hardware?
In principle, yes. The requirements are mid-circuit measurement, conditional operations, and enough qubits to form a chain. Trapped-ion systems and other superconducting processors with similar capabilities could potentially run analogous experiments.
23. What is the connection to the 2026 Nobel Prize in Physics?
There is no direct connection. The Nobel went to Francis Halzen for IceCube and neutrino astronomy. Both are examples of large-scale physics experiments, but they involve different phenomena and different technologies .
24. What should a beginner read to learn more about quantum error correction?
Google’s developer guide to quantum error correction is a good starting point for the concepts . For a deeper dive, textbooks on quantum computation cover surface codes and stabilizer formalism. The Rutgers-IBM paper in Nature Physics is readable for those with some physics background.
25. Is quantum computing “almost here” now?
No. Fault-tolerant quantum computing is still years away, and useful applications will require machines far larger and more reliable than current systems. The Rutgers-IBM experiment is a step on a long road. Quantinuum targets 2029 for fault tolerance; other roadmaps extend further.
26. What is the biggest open problem in quantum error correction?
Scaling. Codes work in theory, and small demonstrations work in practice, but building a machine with enough qubits, low enough error rates, and fast enough feedback to run useful algorithms is an enormous engineering challenge. Decoding speed, leakage control, and system integration are all active areas.
27. Why should a non-scientist care?
Because quantum computing could eventually solve problems that classical computers can’t—in materials science, drug discovery, and cryptography. The error-correction problem is the main obstacle. Progress like this experiment is what moves the field from hype to reality, one capability at a time.
About Author
Sana Ullah Khan Kakar is a science writer and former aerospace systems engineer with a focus on planetary science and space technology. He has contributed to World Class Blogs since 2023, covering topics ranging from asteroid defense to fusion energy and quantum computing. Alex holds a B.S. in Aerospace Engineering from Georgia Tech and an M.S. in Science Communication from MIT. He lives in Tucson, Arizona, where he volunteers as an amateur astronomer and occultation observer. You can reach him through the World Class Blogs contact page.
Disclosure: Alex has no financial interest in any company or mission mentioned in this article. All opinions are his own.
Free Resources
- Nature Physics Paper: The Rutgers-IBM study, “Real-time quantum feedback control across 100 qubits” (citation details available via Nature Physics).
- IBM Quantum: Access to documentation on the Heron processor and dynamic circuits. (ibm.com/quantum)
- Quantinuum Error Correction Announcement: Details on the 99.9995% logical fidelity record. (quantinuum.com)
- Physical Review Letters: Syndrome Resampling: The 2026 paper on decoder-agnostic threshold enhancement. (journals.aps.org/prl)
- Google Quantum AI Error Correction Guide: Accessible introduction to surface codes and quantum error correction concepts. [Link: https://developers.googleblog.com/en/unlocking-the-potential-of-quantum-computing-a-developers-guide-to-error-correction/]
- World Class Blogs Technology & Innovation Archive: For related coverage on AI, machine learning, and quantum technology. [Link: https://worldclassblogs.com/category/technology-innovation/artificial-intelligence-machine-learning/]
- Sherakat Network SEO Guide: For readers interested in how science communication reaches audiences online. [Link: https://sherakatnetwork.com/category/seo]
Discussion
What questions do you have about quantum error correction, real-time feedback, or the road to fault tolerance? Have you followed Quantinuum’s and IBM’s recent progress? Share your thoughts in the comments below. I read every comment and try to respond within 48 hours.
For more science and frontier coverage, explore the World Class Blogs Our Focus section and the full Blog archive. If you’re interested in contributing a guest post or suggesting a topic, please contact us.
