RESCQ: Realtime Scheduling for Continuous Angle Quantum Error Correction Architectures

Error-corrected quantum computers need special "magic states" to run arbitrary rotations, and a cheaper alternative prepares rotation states directly — but that preparation randomly succeeds or fails, so you often have to retry; existing designs handle this with a fixed schedule made ahead of time, which wastes cycles, so this paper (UT Austin — Sayam Sethi and Jonathan Mark Baker) presents RESCQ, a realtime scheduler that reallocates preparation resources on the fly based on how likely each state is to succeed, halving the cycle count.

The argument in one glance

Problem

Arbitrary quantum rotations are expensive to make error-corrected

Fault-tolerant quantum computing runs on quantum error correction, and the leading code, the surface code, can only directly perform a limited set of operations called Clifford gates (like CNOT, X, Z, and H). That set is not universal — you cannot compute everything with it — so you also need a non-Clifford gate, and the standard one is the T gate, supplied by special "magic states" that are prepared separately and injected. The catch is that making magic states is enormously expensive: they are produced by distillation in bulky factories, and building an arbitrary rotation Rz(theta) out of the Clifford-plus-T gate set inflates the circuit depth by roughly two orders of magnitude and consumes huge numbers of these factories. Both the space and the time of a program end up dominated by magic-state production, which for near-term machines translates into many orders of magnitude of lost program fidelity. To escape this, researchers proposed continuous-angle architectures that prepare analog rotation states directly — a rotation state that, when injected, performs an arbitrary-angle rotation without distillation, using only ancilla qubits local to the injection site. This dramatically cuts the space cost of non-Clifford gates. But it introduces a new difficulty: preparing these rotation states is not deterministic.
What people did

Run a fixed schedule that retries preparation until it succeeds

The original continuous-angle architectures (such as the STAR design) lay out a grid of patches, each giving a data qubit a few local ancilla for preparing rotation states, and drive them with a repeat-until-success protocol on a statically-generated schedule. The schedule, fixed at compile time, always attempts to prepare the rotation state in a designated ancilla; if the preparation succeeds, it injects the gate; if it fails, it prepares a corrective "fixup" state and restarts the process from the beginning. The compiler decides all of this in advance, without runtime knowledge of what actually happened.
Why it fell short

A static schedule cannot cope with random success and failure

The problem is that preparation is probabilistic — each attempt succeeds only with some probability, and injection can fail too, in which case the required angle doubles and another fixup state is needed — yet a static schedule is committed before any of these outcomes are known. Because it cannot see which preparations succeeded or failed, it must be conservative: it plans for a fixed pattern of attempts and restarts that does not match what really occurs, so it wastes cycles. When a preparation fails, the rigid protocol restarts the whole process rather than adapting; when ancilla resources sit idle in one place while gates elsewhere are starved for them, the static plan cannot shift them. The result is a schedule that is unnecessarily expensive: it neither maximizes the chance of a successful preparation by trying in parallel, nor reallocates resources on the fly to where they are most likely to help. What was missing was a scheduler that watches the non-deterministic outcomes as the program runs and dynamically redistributes preparation resources to minimize the total time — while not spending so much classical computation deciding this that the overhead eats the gains.
This paper's idea

Schedule in realtime, reallocating resources by success odds

RESCQ (pronounced "rescue") is a realtime scheduler for programs compiled onto continuous-angle systems. Instead of a fixed plan, it actively minimizes the total cycle count by redistributing preparation resources on demand, based on the expected production rates of the rotation states — steering ancilla toward the preparations most likely to succeed and away from where they would sit idle. Rather than the baseline's single designated attempt, RESCQ attempts multiple preparations in parallel to maximize the probability that at least one succeeds, cutting restarts; and during injection it preemptively prepares the corrective fixup states so that an injection failure does not force restarting the entire process. Because it treats the ancilla as resources independent of any single data qubit, it can allocate them at runtime to wherever gates need them rather than starving neighboring operations. This dynamic recomputation, however, is not free: on some hardware, constantly recomputing the schedule in realtime imposes excessive classical control overhead, since a classical co-processor has limited bandwidth. RESCQ addresses this by dynamically selecting how often it recomputes — adapting the recomputation frequency to balance schedule quality against control cost. Across the workloads studied, RESCQ improves over the baseline static proposals by an average of 2 times in cycle count.

Why this problem is worth solving

The cost of non-Clifford gates dominates fault-tolerant quantum computing, so anything that makes them cheaper to realize is central to reaching useful scale.

Every fault-tolerant quantum program is, at the physical level, mostly a struggle to produce the resources that error-corrected non-Clifford gates require. The surface code does Clifford gates natively but needs magic states for the rest, and those magic states are so expensive to distill that they come to dominate both the space (bulky factories) and the time (inflated circuit depth) of a computation — to the point that, for near-term machines with only modest error-rate headroom, the overhead can cost many orders of magnitude in fidelity. That makes the resource layer the make-or-break factor for whether fault-tolerant quantum computing is affordable. Continuous-angle rotation states are a promising escape because they cut the space cost dramatically, but they replace a deterministic-but-huge cost with a small-but-random one: preparation succeeds probabilistically, so time is now governed by how cleverly you manage retries and resource allocation. That shifts the bottleneck from physics to scheduling. A realtime scheduler that halves the cycle count is therefore not a minor tuning; it directly reduces the time cost of the very gates that dominate FTQC, and it does so in software, without new hardware. Because this resource-management problem grows more acute as machines scale, getting the scheduling right is critical to making these cheaper architectures actually deliver their promise.

The key realization is that when the workload is non-deterministic, the schedule has to be made at runtime from the actual outcomes, not fixed in advance.

A static compiler produces one plan and commits to it, which is fine when execution is predictable. But continuous-angle preparation is fundamentally a game of chance: each attempt might succeed or fail, injections might fail and force a larger corrective angle, and which resources will be free when depends on how those coin flips landed. A schedule fixed before any of this is known cannot be right — it has to assume a worst case or an average case, and either way it wastes cycles relative to what an informed decision would do. RESCQ’s insight is that the scheduler must live at runtime, watching the outcomes and reallocating on the fly: prepare several candidates in parallel so a failure is unlikely to stall progress, pre-stage the fixups so an injection failure does not restart everything, and move ancilla to wherever the odds say they will help most. This is exactly the kind of decision a static schedule cannot make. The subtlety, and the reason it is not trivial, is that the scheduler itself runs on a classical co-processor with finite bandwidth, so recomputing constantly can cost more than it saves. The final piece of the insight is therefore to make the scheduler adaptive about itself — recomputing more or less often depending on the hardware and situation, so the dynamic management pays off net of its own overhead. Turning a fixed compile-time plan into an adaptive, self-tuning runtime scheduler is what recovers the cycles a static plan leaves on the table.

What people did before, and where it broke

Build non-Clifford gates from distilled magic states. Use the Clifford-plus-T gate set with T states from distillation factories. Where it broke. Distillation dominates space and time and inflates circuit depth by orders of magnitude, crushing near-term fidelity.
Prepare continuous-angle rotation states directly. Inject analog rotation states to do arbitrary rotations without distillation, using local ancilla. Where it broke. Preparation is non-deterministic, so the time cost now depends on managing random successes and failures.
Drive them with a static, repeat-until-success schedule. Fix the attempt-and-restart plan at compile time. Where it broke. It is committed before any outcome is known, so it cannot adapt, wastes cycles on rigid restarts, and cannot shift idle resources.
Always attempt a single designated preparation. Try in one ancilla and restart on failure. Where it broke. It does not maximize success probability with parallel attempts, and an injection failure restarts the whole process.
The gap. No scheduler dynamically redistributed preparation resources at runtime, based on outcomes and expected success rates, while keeping the classical control overhead of doing so in check.

How RESCQ works

From a fixed retry plan to an adaptive realtime scheduler

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Manage error-correction resources in realtime rather than by a fixed plan. RESCQ moves scheduling from compile time into runtime, watching the non-deterministic outcomes of state preparation and reacting to them, which is what a static schedule fundamentally cannot do. Managing the resources of quantum error correction dynamically, in realtime, as the machine runs rather than through a fixed offline plan, is the same principle the work on extending the reach of real-time quantum error correction (Promatch) covered elsewhere on this site is built on, keeping the QEC control loop adaptive and fast enough to be usable. RESCQ applies realtime management to the scheduling of continuous-angle state production.

Redistribute scarce resources on demand toward where they pay off. The core of RESCQ is dynamic allocation: it steers ancilla and preparation effort toward the states most likely to succeed and away from idle capacity, adapting the allocation as the workload’s stochastic demands shift. Reallocating a pool of scarce resources on the fly to match a dynamic, unpredictable pattern of demand, rather than committing a static assignment, is the same strategy the work on a dynamic scheduler for dynamic, real-time, multi-model workloads (DREAM) covered elsewhere on this site uses, adapting the allocation as demand changes. RESCQ’s resources are the ancilla and preparation slots of a continuous-angle QEC architecture, allocated by expected production rate.

Use scarce qubit resources efficiently through smart compilation. RESCQ treats the ancilla as independent, reusable resources and schedules them to avoid starving operations, squeezing more useful work out of a fixed set of physical qubits. Getting more out of limited quantum resources by having the compiler and scheduler reuse and reassign qubits cleverly, rather than dedicating them statically, is the same lever the work on compiler-assisted qubit reuse through dynamic circuits (CAQR) covered elsewhere on this site pulls, reclaiming qubit resources that a naive layout would waste. RESCQ’s runtime redistribution of ancilla is its way of reusing the scarce qubits of the error-correction fabric.

Following a rotation gate through RESCQ

Executing one arbitrary-angle rotation

A trace, drawn from the paper, of how RESCQ schedules a continuous-angle rotation in realtime.

Step 1 of 5

A program needs an arbitrary rotation on a data qubit

The compiled program calls for an Rz(theta) rotation, which on a continuous-angle architecture is realized by preparing a rotation state and injecting it into the data qubit.

On a magic-state machine this would cost expensive distilled T states.

Why it works

Runtime information beats a compile-time guess. A static schedule is fixed before any outcome is known → but a realtime scheduler sees which preparations succeeded or failed → so it makes decisions that match reality instead of a conservative assumption.
Parallel attempts cut costly restarts. A single designated preparation often fails and restarts everything → but attempting several in parallel → so the probability that at least one succeeds rises and full restarts drop.
Pre-staged fixups absorb injection failures. An injection failure would otherwise restart the whole process → but preparing the corrective states preemptively → so a failure continues from the fixup rather than from scratch.
On-demand reallocation stops resource starvation. Idle ancilla in one place while others are starved wastes cycles → but treating ancilla as independent and reallocating by expected success rate → so effort goes where it helps most.
Adaptive recomputation keeps overhead from eating the gains. Constant rescheduling can swamp a limited classical co-processor → but dynamically choosing how often to recompute → so the dynamic management pays off net of its own control cost.

What it costs (trade-offs and scope)

Realtime scheduling consumes classical control bandwidth. The dynamic recomputation runs on a classical co-processor with finite bandwidth; RESCQ mitigates this by tuning recomputation frequency, but the overhead is real and hardware-dependent.
It targets continuous-angle architectures specifically. RESCQ schedules programs compiled onto continuous-angle rotation-state systems (like STAR); its benefit is tied to that non-deterministic-preparation setting, not magic-state distillation pipelines.
The gains depend on the production statistics. The improvement comes from exploiting the probabilistic success and failure of preparation and injection; workloads or hardware where those probabilities differ would see different benefits.
It optimizes scheduling, not the underlying physics. RESCQ reduces cycle count by better managing preparation and resources; it does not change the state-preparation success rates or the error-correction code itself.
Reported figures are averages over studied workloads. The 2-times average cycle-count improvement is over specific baseline static proposals on the paper’s workloads and hardware assumptions; results depend on the program, architecture variant, and control budget.

The comparison

Scheduling continuous-angle state preparation

Property	Magic-state distillation	Static continuous-angle schedule	RESCQ
Space cost of rotations
Adapts to random outcomes
Handles failed preparations
Resource allocation
Cycle count

A comparison of ways to realize arbitrary rotations under quantum error correction. Magic-state distillation is deterministic but dominates space and time; continuous-angle states cut the space cost but need probabilistic preparation, which a static schedule cannot manage well. RESCQ schedules the preparation in realtime, attempting candidates in parallel, pre-staging fixups, and redistributing ancilla by expected success rate while bounding its own classical overhead, averaging a 2 times reduction in cycle count over the static baseline. Exact figures should be read from the paper.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

This explainer is based on the paper’s full text (the authors’ arXiv copy, 2408.14708, of the ASPLOS 2025 paper). The described system is the paper’s: RESCQ (pronounced “rescue”) is a realtime scheduler for programs compiled onto continuous-angle quantum-error-correction architectures, which prepare analog rotation states (written in the paper as the state Rz(theta) applied to the plus state) to perform arbitrary Rz(theta) rotations without magic-state distillation. The paper explains that preparing these states is non-deterministic (a preparation attempt succeeds with some probability and may need repetition; injection can also fail, doubling the required angle and needing a fixup state), and that the original architectures (such as the STAR design, with a grid of patches giving each data qubit a few local ancilla) use a static, repeat-until-success schedule that cannot adapt. RESCQ actively minimizes total cycle count by on-demand redistribution of resources based on expected production rates, attempts multiple preparations in parallel to reduce restarts, preemptively prepares fixup states during injection, and treats ancilla as independent resources; it dynamically selects the recomputation frequency to bound the classical control overhead. The paper reports an average 2 times improvement in cycle count over baseline static proposals. The background above on the surface code, Clifford versus non-Clifford gates, the T gate and magic states, distillation, and continuous-angle rotation states is standard quantum-computing context provided to make the approach intuitive. The step-by-step walkthrough is an illustration of the described mechanism. Exact protocols, the STAR-block variants, the scheduling algorithm, and the full evaluation should be read from the paper.

Background

Why fault-tolerant quantum computing is increasingly a resource-management problem

It helps to see RESCQ within a broad realization about fault-tolerant quantum computing: below the elegant theory of error-correcting codes lies a messy, resource-constrained systems problem, and how well that problem is managed largely determines whether a code is affordable to run. Error correction consumes scarce resources continuously — classical bandwidth for decoding, ancilla qubits for communication and gate decompositions, and above all the special resource states needed for non-Clifford gates — and these must be produced, moved, and consumed under tight limits and, increasingly, in the presence of randomness. The field keeps finding that the naive, static, worst-case way of handling these resources is far too expensive, and that adapting to what actually happens at runtime recovers large savings. That is a systems mindset applied to quantum: schedule dynamically, allocate on demand, and keep the management layer’s own overhead in check. RESCQ is a clean instance for the specific case of continuous-angle rotation-state production, where the resource cost is dominated not by fixed factories but by the luck of probabilistic preparation, making a realtime, adaptive scheduler exactly the right tool. This effort to squeeze the real-world cost out of quantum error correction by treating it as a resource-management and scheduling problem, rather than assuming worst-case behavior, is the same terrain the work on better-than-worst-case decoding for quantum error correction (better-than-worst-case decoding) covered elsewhere on this site occupies, exploiting the actual behavior of the system instead of a pessimistic bound. RESCQ’s particular contribution is to show that realtime scheduling of continuous-angle state preparation, with adaptive recomputation, halves the cycle count a static plan would incur.

If you remember only three things

1. Fault-tolerant quantum computing on the surface code can only do Clifford gates directly; arbitrary rotations need non-Clifford gates, traditionally supplied by magic states (like T states) that are distilled in bulky factories. Distillation dominates both the space and the time of a program and inflates circuit depth by orders of magnitude, which for near-term machines costs enormous fidelity. Continuous-angle architectures escape this by preparing analog rotation states directly — injecting them performs an arbitrary rotation without distillation, using only local ancilla, cutting the space cost dramatically. But their preparation is non-deterministic: each attempt succeeds only with some probability and may need retries, and injection can fail (doubling the required angle and needing a corrective fixup state). The original designs manage this with a static schedule fixed at compile time, which cannot adapt to which preparations actually succeed and therefore wastes cycles.
2. RESCQ (pronounced "rescue") is a realtime scheduler for continuous-angle systems that actively minimizes total cycle count by redistributing preparation resources on demand, based on the expected production rates of the rotation states. Rather than the baseline's single designated attempt with restart-on-failure, RESCQ prepares multiple candidates in parallel to maximize the chance one succeeds and cut restarts, preemptively prepares the corrective fixup states during injection so an injection failure does not restart the whole process, and treats ancilla as independent resources it can reallocate at runtime toward wherever they help most. Because recomputing the schedule in realtime burdens a limited-bandwidth classical co-processor, RESCQ also dynamically selects how often to recompute, balancing schedule quality against classical control overhead.
3. Across the studied workloads, RESCQ improves over the baseline static proposals by an average of 2 times in cycle count, reducing the time cost of exactly the non-Clifford operations that dominate fault-tolerant quantum computing, entirely in software. The trade-offs and scope: realtime scheduling consumes classical control bandwidth (mitigated but not eliminated by tuning recomputation frequency), it targets continuous-angle architectures with non-deterministic preparation specifically, its gains depend on the production and injection success statistics, and it optimizes scheduling rather than the underlying physics or code. This explainer is based on the paper's full text.

Check yourself

Check your understanding

1. Why are arbitrary rotation gates expensive under quantum error correction, and what do continuous-angle states offer?
2. Why does a static schedule handle continuous-angle preparation poorly?
3. What does RESCQ do differently, and how does it avoid drowning in overhead?
4. What does RESCQ achieve, and what are the limits of the approach?

Sources

The paper is “RESCQ: Realtime Scheduling for Continuous Angle Quantum Error Correction Architectures” by Sayam Sethi and Jonathan Mark Baker (The University of Texas at Austin), published at ASPLOS 2025, DOI 10.1145/3676641.3716018. It is available on arXiv as 2408.14708.

This explainer is written from the paper’s full text (the authors’ arXiv copy). RESCQ is a realtime scheduler for continuous-angle quantum-error-correction architectures, which prepare analog rotation states to perform arbitrary rotations without magic-state distillation but whose preparation is non-deterministic. RESCQ minimizes total cycle count by on-demand redistribution of resources based on expected production rates, prepares multiple candidates in parallel to reduce restarts, preemptively prepares fixup states, and dynamically selects its recomputation frequency to bound classical control overhead. The paper reports an average 2 times improvement in cycle count over baseline static proposals. Background on the surface code, Clifford and non-Clifford gates, magic states and distillation, and continuous-angle rotation states is standard context. The numbers are the paper’s own; exact mechanisms and full results should be confirmed in the paper.