QuMod: Parallel Quantum Job Scheduling on Modular QPUs using Circuit Cutting Vinooth Kulkarni
Aaron Orenstein
Xinpeng Li
Dept. of Computer and Data Sciences Case Western Reserve University Cleveland, OH, USA [email protected]
Dept. of Computer and Data Sciences Case Western Reserve University Cleveland, OH, USA [email protected]
Dept. of Computer and Data Sciences Case Western Reserve University Cleveland, OH, USA [email protected]
Daniel Blankenberg
Vipin Chaudhary
arXiv:2604.11013v1 [quant-ph] 13 Apr 2026
Shuai Xu
Case Western Reserve University Department of Molecular Medicine Dept. of Computer and Data Sciences Case Western Reserve University Cleveland Clinic Lerner College of Medicine Dept. of Computer and Data Sciences Cleveland, OH, USA Case Western Reserve University Cleveland, OH, USA [email protected] Cleveland, OH, USA [email protected] [email protected]
Abstract—The quantum computing community is increasingly positioning quantum processors as accelerators within classical HPC workflows, analogous to GPUs and TPUs. However, many real-world applications require scaling to hundreds or thousands of physical qubits to realize logical qubits via error correction. To reach these scales, hardware vendors employing diverse technologies—such as trapped ions, photonics, neutral atoms, and superconducting circuits—are moving beyond single, monolithic QPUs toward modular architectures connected via interconnects. For example, IonQ has proposed photonic links for scaling, while IBM has demonstrated a modular QPU architecture by classically linking two 127-qubit devices. Using dynamic circuits, Bell-pairbased teleportation, and circuit cutting, they have shown how to execute a large quantum circuit that cannot fit on a single QPU. As interest in quantum computing grows, cloud providers must ensure fair and efficient resource allocation for multiple users sharing such modular systems. Classical interconnection of QPUs introduces new scheduling challenges, particularly when multiple jobs execute in parallel. In this work, we develop a multi-programmable scheduler for modular quantum systems that jointly considers qubit mapping, parallel circuit execution, measurement synchronization across subcircuits, and teleportation operations between QPUs using dynamic circuits.
I. I NTRODUCTION Quantum computing has rapidly become a central focus among emerging technologies, with industries racing to demonstrate progress across domains such as Secure longdistance communication, molecular simulations and protein folding in healthcare, combinatorial optimization, and Quantum machine learning and generative AI applications. The main driver is the growing set of problems that challenge existing classical techniques and the available computational resources. Quantum computers promise speedups for certain classes of classically hard problems by exploiting quantummechanical principles such as superposition and entanglement. This research was supported in part by NSF Awards 2216923 and 2117439.
Qubits, the basic units of quantum computation, are twolevel quantum systems whose states are vectors in a twodimensional Hilbert space acted on by unitary operations. An n-qubit register lives in a 2n -dimensional state space, so operating on superposition states allows algorithms to process structured information over an exponentially large space. Despite this potential, current quantum hardware remains in the noisy intermediate-scale quantum (NISQ) [1] regime. Qubits are realized in several physical platforms—including superconducting transmons, trapped ions, photonics, and neutral atoms—each with different trade-offs in fidelity, connectivity, and scalability. Because these technologies are still maturing, devices suffer from decoherence and gate errors arising from environmental noise, imperfect calibration, and control cross-talk. In practice, coherence times are limited to at most a few seconds, and many architectures (e.g., superconducting qubits) have sparse planar connectivity that makes long-range two-qubit operations more error-prone than in trapped-ion systems. Error correction further multiplies the physical qubit count, making it extremely challenging to scale monolithic devices with sufficiently low noise. To overcome these scalability limits, recent work explores modular quantum computing, where multiple quantum processing units (QPUs) are interconnected to act as a single larger machine. Two main forms of interconnect have been studied. First, quantum interconnects, such as photonic links between trapped-ion chains, aim to distribute entanglement directly across modules [2]. Second, classical interconnects, such as IBM’s real-time classical link between two 127-qubit Eagle QPUs [3], enable dynamic circuits in which operations on one QPU are conditioned on mid-circuit measurement outcomes from another, effectively realizing two-qubit interactions between qubits on different QPUs via teleportation-based circuit knitting [4]. Circuit cutting partitions a large circuit that would otherwise
require more qubits than available on a single device by cutting wires or gates, producing multiple smaller subcircuits [5]. The partitioned subcircuits contain only local operations, replacing the gates (multi-qubit) that were cut. The expectation value of the original circuit is recovered via quasi-probability reconstruction based on the measurement outcomes of these subcircuits [6]. However, the number of subcircuits grows exponentially with the non-local gates that need to be cut to partition a large circuit, which is termed as sampling overhead. There are mainly 2 ways of sampling the outcomes from the subcircuits. 1. Sampling based on local operations (LO), the cut qubits are treated purely classically: upstream subcircuits measure the cut qubits in an appropriate basis, downstream subcircuits are initialized in eigenstates, and classical postprocessing (e.g., via Kronecker products and quasi-probability weights) reconstructs observables of the original circuit. The way a circuit is partitioned (wire-cuts versus gate-cuts) determines the number of subcircuits and the sampling overhead: cutting k wires under LO typically requires on the order of 16k subcircuit sampling, and cutting a two-qubit gate (Example: controlled-NOT) can require up to nine subcircuits sampling. Various optimization techniques have been explored to reduce the sampling overhead in circuit cutting [7]–[10]. In all cases, the upstream subcircuits must be measured over appropriate Pauli bases, and the downstream subcircuits must be reinitialized accordingly to reconstruct the original bitstrings. Sampling overhead drops significantly when the architecture supports local operations and classical communication (LOCC) across QPUs: mid-circuit measurements on the upstream fragment are transmitted over a low-latency classical link to drive downstream conditional operations in real time using dynamic circuits (teleportation-style transfer of the cut qubit). Instead of treating the cut qubit as fully classical with offline post-processing, LOCC enables per-shot feedforward control between fragments. For k wire cuts, this reduces sampling overhead from 16k to 4k provided the feed-forward completes within coherence time, but it imposes architectural constraints requiring tightly synchronized midcircuit measurements, classical links, and conditional gates. Previous works in Quantum job scheduling are focused on running multiple circuits in parallel [11]–[13], accounting for measurement synchronicity and shot requirements, minimizing overhead associated with loading and unloading jobs, along with compilation and crosstalk errors due to parallel execution. Recent work on VQA scheduling [14], [15] partitions training into exploratory and fine-tuning phases, assigning high-fidelity devices only to noise-sensitive (later) iterations while using lower-fidelity hardware for early, more noise-resilient steps, thereby improving overall fidelity under hardware constraints. To scale beyond the limitations of qubits when circuits are large and the exponential sampling overhead of 16k subcircuits per wire cut, subcircuit scheduling with circuit-cutting techniques have been proposed [16]. However, recent advancements in interconnects offer large circuits execution where the qubit requirement is beyond a single device. IBM has shown utilization of modular QPU architecture where a 142-qubit
circuit is executed by cutting wires and teleporting the classical state after measurement. This approach reduces the sampling overhead exponentially from 16k to 4k for k wire cuts. In this work, we design a parallel quantum job scheduler on modular architectures with classical interconnects, taking into account the subcircuit sampling overhead and synchronicity required for subcircuit initialization based on dynamic circuits for measurement and feedback in two cases: (1) large circuits that cannot be run on a single device, where cutting is mandatory, and (2) dynamic decision making for circuit cutting in two modes (a) with Local operations (LO) (b) Local Operations with classical communication (LOCC) for maximum device utilization while taking into account device fidelity and the overall makespan of the job queue. II. BACKGROUND A. Circuit cutting with local operations (LO) Consider a circuit U acting on a register that we split into two disjoint subsets of qubits, L and R, assigned to different devices. In the LO setting, each partition can only implement local channels on the qubits it owns. Any gate that acts jointly on qubits in L and R must therefore be removed and replaced by an arrangement of (i) completely local operations on L and R and (ii) classical post-processing of measurement outcomes. This is achieved via a quasi-probability decomposition (QPD) of the non-local channel. Concretely, if G is a two-qubit gate that couples L and R, we write its action on a density operator ρ as G(ρ) = GρG† =
M X α=1
wα Lα ⊗Rα (ρ),
Λ≡
M X
|wα |,
α=1
(1) where each Lα and Rα is a channel implementable using only local unitaries, measurements, and classical control on the L and R qubits, respectively, and {wα } are real coefficients for explicit decompositions [6]. In an LO simulation, each occurrence of G is replaced by the following randomized procedure: 1) Draw an index α with probability pα = |wα |/Λ. 2) Apply the local channels Lα on L and Rα on R (which may include local measurements and classical control internal to each partition). 3) At the end of the circuit, measure the observable of interest and multiply the raw outcome o for that shot by the weight Λ sgn(wα ). Averaging these reweighted outcomes over many shots produces an unbiased estimator of the target expectation value. However, the variance is amplified by a factor Λ2 , so the number of circuit executions required to reach a given precision scales as O(Λ2 ). For typical two-qubit entangling gates (e.g., CNOT, CZ), optimal QPDs in the LO setting use a small number of local branches (M ≤ 9) with Λ2 ≈ 9, meaning that each cut gate effectively multiplies the required samples by a constant factor.
Wire cutting: Gate cutting targets specific two-qubit gates, whereas wire cutting breaks a qubit worldline at an intermediate time and treats the identity channel between two time slices as the object to be decomposed. Let q be a qubit that is cut between an “upstream” segment Uup and a “downstream” segment Udown . If we view the identity on q as a two-qubit operator, it can be expanded in a Pauli basis as X idq (ρ) = cP P ρP, (2) P ∈{I,X,Y,Z}
P with real coefficients cP satisfying P |cP | = Λwire . Operationally, this expansion is implemented by inserting, at the cut, a measurement-preparation scheme: 1) On the upstream subcircuit, qubit q is measured in a basis associated with a Pauli operator P ∈ {X, Y, Z} (and, if required by the chosen decomposition, in the computational basis). The pair consisting of the measurement setting P and the corresponding outcome m ∈ {+1, −1} uniquely specifies the upstream branch of the decomposition. 2) On the downstream subcircuit, the original qubit q is discarded and replaced by a freshly initialized qubit q ′ prepared in the eigenstate |ϕP,m ⟩ of P corresponding to the upstream measurement setting P and outcome m (e.g., |±⟩ for X, |±i⟩ for Y , and |0⟩ , |1⟩ for Z). The downstream unitary Udown is then applied to this reinitialized register. When this procedure is applied independently to k cut wires, the resulting estimator is a quasi-probability average over all combinations of upstream measurement settings and downstream state preparations. In the LO setting with Pauli bases, the optimal decomposition of a single wire has Λwire = 4, implying a variance overhead of Λ2wire = 16 per cut wire and a total sampling cost that scales as O(16k ). From the scheduler’s perspective, each cut wire induces a family of upstream subcircuits measured in different bases and a corresponding family of downstream subcircuits initialized in the associated eigenstates. All nonlocal correlations between partitions are reconstructed only offline by classically reweighting these measurement outcomes. B. Circuit cutting with local operations and classical communication (LOCC) In the LOCC setting, the circuit is again partitioned across disjoint sets of qubits, but real-time classical communication between QPUs is now permitted. Mid-circuit measurements on one partition may condition subsequent operations on another, while each device continues to implement only local gates. At the channel level, a non-local operation is realized by a composition of local unitaries and measurements, classical transmission of the outcomes, and classically controlled corrections. The resulting classical branches induce a quasi-probability decomposition analogous to the LO case, but the availability of feed-forward admits constructions with a smaller ℓ1 –norm and consequently reduced sampling overhead. For example, a remote entangling gate employing an entangled resource
state, Bell measurements, and conditional corrections achieves a constant overhead scaling as O(4n ) for n non-local gates, in contrast to the O(16n ) overhead of purely LO-based cutting. Wire cutting with LOCC: Consider again a single-qubit worldline that is cut between an upstream segment executed on device L and a downstream segment executed on device R. In contrast to the LO setting, where the identity channel on this wire is replaced by a mixture of measurement–repreparation gadgets, LOCC implements the same channel via a teleportation-style protocol. A typical construction proceeds in three stages: 1) Entangled resource preparation. Devices L and R are supplied with a shared Bell pair |Φ+ ⟩aL aR = √12 (|00⟩+ |11⟩) across ancillary qubits aL and aR , prepared prior to execution of the cut circuit. 2) Upstream execution and measurement: The data qubit q on L is evolved by the upstream subcircuit Uup up to the cut. At the cut position, device L performs a Bell-basis measurement on the pair (q, aL ), e.g., by applying a fixed two-qubit Clifford circuit followed by computational-basis measurements. This produces two classical bits (mZ , mX ) ∈ {0, 1}2 that encode which Bell state was observed. 3) Classical communication and downstream execution: The bits (mZ , mX ) are transmitted over the classical link to device R within the coherence window. Conditioned on these bits, R applies single-qubit Pauli corrections Z mZ X mX to the entangled partner aR and then continues the downstream subcircuit Udown on aR in place of the original qubit q. After completing Udown , R measures the observable of interest on its local qubits. In the ideal, noise-free case, this protocol exactly reproduces the action of the identity channel from the cut position on L to the start of Udown on R, so no additional quasi-probability reweighting is required beyond the averaging over the four possible Bell-measurement outcomes. In the quasi-probability formalism, the different outcomes (mZ , mX ) and the corresponding conditional corrections define four classical branches whose probabilities are given by the underlying quantum mechanics, which leads to an effective ℓ1 –norm squared of order 4 per wire instead of 16 as in LO. When k wires are cut and treated independently, the variance overhead of the estimator therefore scales as O(4k ), yielding an exponential improvement in sampling complexity over LO wire cutting. From the scheduler’s perspective, LOCC wire cutting turns each cut into a pair of causally ordered subcircuits: an upstream fragment that ends with mid-circuit measurements on device L, and a downstream fragment that begins on device R only after the corresponding classical outcomes have been received and the appropriate corrections have been applied. Upstream and downstream fragments can be parallelized across different jobs and devices, but for each logical cut the downstream fragment is constrained to start no earlier than the completion time of its upstream partner plus the classical-communication and control-latency budget.
All non-local correlations across the cut are now mediated on-line via the classical link and conditional gates, rather than reconstructed offline from independent measurement records as in the LO setting. C. Parallel circuit Scheduling challenges with LO vs LOCC Although LOCC-based circuit cutting can significantly reduce the sampling overhead (e.g., from 16n to approximately 4n for n cut wires), it introduces several practical drawbacks compared to purely local operations (LO). We summarize the main trade-offs in scheduling jobs in a quantum cloud with LO vs LOCC approach below. a) Loss of fully independent parallel execution.: Under LO, all fragments produced by circuit cutting are statistically independent and can be executed in any order on any available QPU, with no cross-fragment synchronization. In contrast, LOCC introduces explicit dependencies: downstream fragments must wait for measurement outcomes from upstream fragments. This converts a set of independent tasks into a multi-stage pipeline with precedence constraints, thus reducing scheduling flexibility. b) Additional latency on dependent operations across groups: When circuits are scheduled for parallel execution, circuits are grouped based on the circuit depths. As the slowest circuit in the group or the circuit with the largest depth decides the finish time of the entire group for each shot. LOCC requires mid-circuit measurements, transmission of measurement outcomes between QPUs, followed by classically controlled operations and post-processing. Even if the total number of required shots are reduced for LOCC, each effective shot incurs extra latency: ∆TLOCC ≈ ncuts · βcomm · τlink ,
(3)
where ncuts is the number of cut wires, βcomm is the average number of transmitted bits per cut per shot, and τlink is the inter-QPU classical link latency. For shallow or low-shot circuits, this additional per-shot delay can offset the advantages of reduced sampling overhead. c) More complex error and noise behavior.: LO-based circuit cutting adds variance through quasi-probability reconstruction but keeps a simple noise model: each fragment sees only local device noise. LOCC introduces extra noise from mid-circuit measurements, classical communication, and conditional operations driven by imperfect measurement outcomes. While the theoretical 4n scaling assumes ideal classical links and logic, these additional error sources degrade practical fidelity and complicate error analysis. We use the qiskit-addon-cutting [4] library to obtain a baseline LO decomposition: given an input circuit Cj and a device-size constraint, it returns a cut circuit C̃j annotated with cut two-qubit gates, the corresponding fragments {Fj,k }, the number of cut gates ncut j , and an LO samplingoverhead estimate κ2LO (j). For the two-qubit cuts produced by qiskit-addon-cutting, we observe nine fragments per cut on average, and we therefore model the sampling overhead
cut
as κ2LO (j) ≈ 9 nj . QuMod uses the same cut decomposition in both LO and LOCC modes: LO executes the fragments with quasi-probability reconstruction under this overhead, whereas LOCC reuses the cut locations but implements each non-local interaction via a teleportation-style primitive with reduced effective sampling cost. III. Q U M OD S CHEDULER We implement QuMod scheduling by extending the grouping and parallel scheduling strategy from [12], [13] to a modular, LO/LOCC-aware setting. We first group jobs using a dynamic programming algorithm adapted from [17], but we now form upstream and downstream groups that respect the direction of classical communication between QPUs. For each logical circuit that we cut, we index the cut by k and denote its upstream and downstream subcircuits by Uk and Dk , respectively. Every subcircuit job generated by this cut lies in either Uk or Dk . We restrict attention to groups g that are feasible: n o X F = g⊆J qj ≤ Qm , g ∩ Uk = ∅ ∨ g ∩ Dk = ∅, ∀k , j∈g
(4) i.e., the total qubit demand of g must not exceed the capacity Qm of machine m, and for every cut k a group may contain either upstream subcircuits (g ∩ Uk ) or downstream subcircuits (g ∩ Dk ), but never both. This prevents a single group from mixing causally dependent upstream and downstream subcircuits and preserves the LOCC execution order shown in Algorithm 3. In the grouping algorithm, we add the above constraints to the cost function, maxj∈g Tj − 1, minj∈g Tj
(5)
b(g) = λ max Cj − min Cj ,
(6)
a(g) =
j∈g
j∈g
where a(g) measures runtime imbalance within the group and b(g) penalizes its causal span. The overall cost is ( ∞, g∈ / F, dqumod (g) = (7) a(g) + b(g), g ∈ F , so that infeasible groups are discarded, and the remaining groups are encouraged to be both runtime-balanced and causally tight. Once groups are formed, each upstream and downstream group is mapped to machines based on the estimated makespan and fidelity of running that group in parallel. QuMod first generates an initial schedule Algorithm 1 and then iteratively improves device utilization through adaptive circuit cutting. For each job or group of jobs assigned to a machine, QuMod estimates the qubit requirements and sampling overhead after cutting Algorithm 2. Candidate cuts that would exceed a global sampling budget (e.g., due to 9k or 16k scaling in the number of subcircuits) are discarded, so cutting is adaptive
both to the available qubit slots and to the allowable sampling overhead. To identify where additional subcircuits can be Fig. 1: The figure shows the distributions of circuit characteristics of widths/depths for Random Heterogeneous Queue.
placed, QuMod scans the current multi-QPU schedule and computes the number of free “slots” across machines: P X Qm − j∈g qj m , (8) Nslots = Qmax sub m∈M
where gm is the set of jobs currently assigned to machine m and Qmax sub is the maximum subcircuit size (in qubits) produced by the chosen cutting pattern from Algorithm 1. A cut is accepted only if the number of new subcircuits J ′ can be placed in the available slots: |J ′ | ≤ Nslots .
(9)
In LO mode, QuMod treats all cuts as purely local: upstream and downstream subcircuits are scheduled on the same QPU with no inter-device communication. In LOCC mode, QuMod explicitly models classical communication and processing delays between upstream and downstream groups. For each cut that spans two QPUs, we insert a classical delay interval ∆class consisting of measurement, transmission, and stitching time. Large circuits that generate many subcircuits incur larger ∆class , since more classical post-processing is required. These delays are inserted between the upstream and downstream groups and are taken into account when computing Nslots , so that downstream subcircuits only start after the corresponding classical data is available. We end each iteration by reapplying the upstream/downstream grouping to close any scheduling gaps introduced by cutting and classical delays. If there are still jobs in the queue and free qubits across machines, QuMod repeats the cycle of grouping, adaptive cutting, and rescheduling. In this way, QuMod iteratively improves qubit utilization across modular QPUs while respecting both hardware constraints and sampling-overhead limits in LO and LOCC modes. IV. E VALUATION AND O BSERVATIONS For QuMod, we use a SimPy-based discrete-event simulator [18] with (i) a Poisson job queue, (ii) a set of modular QPUs configured from calibration data of eleven IBM Quantum devices, and (iii) the QuMod scheduler implementing LO/LOCC-aware policies. The number of shots per circuit scales with its volume (width × depth), starting from 1,000
Algorithm 1 QuMod Scheduling Algorithm (LO / LOCC Modes) Input: job queue J , modular QPUs M, cut mode ∈ {LO, LOCC} Output: final schedule Sfinal 1: Jcurrent ← J 2: repeat 3: improved ← false 4: Sinitial ← G ENERATE I NITIAL S CHEDULE(Jcurrent , M) 5: Tinitial ← M AKESPAN(Sinitial ) 6: for each job j in Sinitial do 7: if j is not eligible for cutting then 8: continue 9: end if 10: sub jobs ← T RY C UT(j, cut mode) 11: if sub jobs = ∅ then 12: continue 13: end if (sub) 14: Qmax ← maxj ′ ∈sub jobs qj ′ 15: Nslots ← 0 16: for all machine m ∈ M do 17: for all group P g scheduled on m in Sinitial do 18: Qused ← j ′ ∈g j ′ .qubits 19: Qavail ← Qjtotal (m) − k Qused Qavail 20: Nslots += Qmax sub 21: end for 22: end for 23: if |sub jobs| > Nslots then 24: continue 25: end if 26: Jcand ← Jcurrent \ {j} ∪ sub jobs 27: Scand ← G ENERATE I NITIAL S CHEDULE(Jcand , M) 28: Tcand ← M AKESPAN(Scand ) 29: if Tcand ≤ Tinitial then 30: Jcurrent ← Jcand 31: improved ← true 32: break 33: end if 34: end for 35: until not improved 36: Sfinal ← G ENERATE I NITIAL S CHEDULE(Jcurrent , M) 37: return Sfinal
and increasing with a factor of 1.5, so larger, more noisevulnerable circuits receive more shots. All experiments use a fixed scheduling window of 50 jobs. We use the following performance measures for our evaluations, shown in Table I. Average Queue Length: Time-averaged number of jobs in the queue. • Average Queue Time (Twait ): Average time a job spends waiting before execution. • Average Runtime (Trun ): Average time a job spends executing on a quantum device (including overhead). •
Algorithm 2 QuMod Circuit Cutting Modes (LO / LOCC) 1: function T RY C UT(job j, cut mode) 2: (C̃, metadata) ← F IND C UTS(j.circuit) 3: if cut mode = LO then
1: function PARTITION Q UMOD (J )
P ← {(PARTITION P ROBLEM(C̃), “flat”)} else (C↑ , C↓ ) ← PARTITION LOCC(C̃) P ← {(C↑ , “upstream”), (C↓ , “downstream”)} end if sub jobs ← ∅ 10: for all (C, s) ∈ P do 11: for all subcircuit C ′ ∈ C do 12: create sub-job j ′ with circuit C ′ 13: j ′ .parent id ← j.id 14: j ′ .stage ← s 15: j ′ .arrival time ← j.arrival time 16: j ′ .shots ← j.shots 17: sub jobs ← sub jobs ∪ {j ′ } 18: end for 19: end for 20: return sub jobs 21: end function 4: 5: 6: 7: 8: 9:
TABLE I: QuMod LO vs LOCC for small, large, and random > 127-qubit workloads. Mode QuMod LOCC QuMod LO
Length 9.87 9.22
Twait 6.47 6.24
Trun 4.11 4.11
Ttotal 10.58 10.34
LPST -3.67 -6.16
Small circuits (MQT-QUEKO). Workload changes: 32 (LOCC), 31 (LO). Mode QuMod LOCC QuMod LO
Length 2.73 3.15
Twait 0.90 1.96
Trun 2.88 3.64
Ttotal 3.78 5.60
LPST -2.24 -6.47
Large circuits (mandatory cut). Workload changes: 16 (LOCC), 19 (LO). Mode QuMod LOCC QuMod LO
Length 75.44 81.08
Twait 23.64 29.23
Trun 2.96 3.69
Ttotal 26.60 32.92
Algorithm 3 QuMod Grouping with LO / LOCC Constraints
LPST -2.30 -3.72
Input: runtime map T , qubit sizes q, device capacity Qdev , max group size Cmax , parent map parent, stage map stage 2: U ←J 3: G←∅ 4: while U ̸= ∅ do 5: g←∅ 6: Qused ← 0 7: U ′ ← S ORT B Y RUNTIME(U , T ) 8: for all j ∈ U ′ do 9: if |g| = Cmax then 10: continue 11: end if 12: if Qused + q(j) > Qdev then 13: continue 14: end if 15: conf lict ← false 16: for all k ∈ g do 17: pj ← parent(j) 18: pk ← parent(k) 19: sj ← stage(j) 20: sk ← stage(k) 21: if pj ̸= ⊥ ∧ pj = pk ∧ sj ̸= sk then 22: conf lict ← true 23: break 24: end if 25: end for 26: if conf lict then 27: continue 28: end if 29: g ← g ∪ {j} 30: Qused ← Qused + q(j) 31: end for 32: G ← G ∪ {g} 33: U ←U \g 34: end while 35: return G 36: end function
Random (158 heterogeneous circuits). Workload changes: 150 (LOCC), 198 (LO). Length: Avg. queue length; Twait : Avg. queue time; Trun : Avg. runtime; Ttotal : Avg. response time (Twait + Trun ); LPST: log probability of successful trial (closer to 0 is better). Workload changes: number of times the executing workload configuration changes.
Average Response Time (Ttotal ): Total time from submission to completion, Twait + Trun . • Log Probability of Successful Trial (LPST): Logarithmic estimate of a circuit’s success probability [11]. Values closer to 0 indicate a higher expected probability of correct, error-free execution, serving as a fidelity-like reliability proxy under the backend error model. •
A. MQT Benchmark circuits: Smaller Circuits In this setup, we run a queue of smaller MQT-QUEKO [19]circuits. We observe that the overall makespan is similar in both LO Figure 2a and Figure LOCC modes 2b. In LO mode, the subcircuits can be executed independently; because they have similar depths/runtimes, they are grouped and run in parallel with high device utilization, as shown in Fig. 2(a). In LOCC mode, the upstream subcircuits are grouped and executed on ibm_brisbane, while the downstream subcircuits are run on ibm_kyiv. The scheduler selects these devices based on the available backends at that point in time and chooses the configuration that yields the best estimated fidelity.
(a) QuMod LO mode
(b) QuMod LOCC mode
Fig. 2: MQT-QUEKO Benchmark circuits: Execution schedules using LO and LOCC modes on modular QPUs. Black horizontal lines separate execution on each quantum computer. The numbering and coloring of jobs is consistent across both subfigures. (a) Subcircuits that can be run independently using circuit cutting with only local operations (LO). (b) Upstream subcircuits are scheduled before downstream subcircuits on another QPU connected via a classical communication link (LOCC).
(a) QuMod LO mode
(b) QuMod LOCC mode
Fig. 3: MQT + Large circuits (Mandatory cut): Execution schedules using LO and LOCC modes on modular QPUs. Black horizontal lines separate execution on each quantum computer. The numbering and coloring of jobs is consistent across both subfigures. (a) Only job 4 with 142 qubits was cut, which does not fit on a QPU. Cutting more circuits in LO mode produces more subcircuits which the scheduler avoided (b) QuMod dynamically selects additional job (job id = 3) that could be cut and scheduled for better qubit utilization across the QPUs.
B. Large Circuits > 127 Qubits In this setup, we combine smaller circuits with large circuits requiring more than 127 qubits, and evaluate the average fidelity and makespan of all jobs in the queue. Figure 3 shows the corresponding execution schedule. When the scheduler encounters a job requiring 142 qubits, which cannot be executed on any single device, that job is selected for cutting in both LO and LOCC modes. In LO mode, the number of subcircuits scales as 9k when each two-qubit gate (e.g., CNOT, CZ) is cut. Because the resulting subcircuits are still large (approximately 71 qubits), they cannot be easily grouped with other jobs for parallel execution, nor even with each other: running two such subcircuits in parallel would again require 142 qubits. As a result, all subcircuits must be executed largely sequentially, leading to a longer overall makespan shown in Figure 3a. In LOCC mode, shown in Figure 3b, the scheduler additionally selects another circuit (job ID = 3) for cutting, based on device utilization. The resulting subcircuits are smaller and can be grouped into upstream and downstream sets that fit concurrently across the modular QPUs. This enables greater parallelism and improves overall qubit utilization. C. Random Heterogeneous Circuits We evaluate a mixed workload of large (> 127-qubit) and small circuits, with the distribution shown in Fig. 1. Since none of the large circuits fit on a single device, QuMod cuts them in both LO and LOCC modes and groups the resulting subcircuits with small circuits of similar depth for parallel execution. Across this workload, LOCC achieves higher fidelity and lower response time than LO, as summarized in Table I. V. C ONCLUSION In this work, we introduced QuMod, a quantum job scheduler for modular QPUs that runs circuits in parallel and selectively applies circuit cutting in two modes (LO and LOCC) to improve qubit utilization in a cloud setting. QuMod explicitly accounts for classical communication between QPUs, synchronizing upstream and downstream subcircuits and grouping them with other jobs by runtime to enable parallel execution. Because circuit cutting incurs exponential sampling overhead, naı̈ve LO-style cutting quickly becomes impractical for large circuits with high qubit counts (e.g., when accounting for error correction). Our results show that the LOCC mode achieves better makespan and higher effective utilization by adaptively cutting and distributing circuits across QPUs while respecting sampling budgets. We evaluate QuMod using a SimPy-based simulator parameterized with IBM’s modular QPU architecture and classical interconnects, demonstrating that LOCC-aware scheduling can significantly reduce runtime overhead compared to purely local cutting while maintaining or improving fidelity. R EFERENCES [1] J. Preskill, “Quantum computing in the nisq era and beyond,” Quantum, vol. 2, p. 79, 2018.
[2] D. Main, P. Drmota, D. P. Nadlinger, E. M. Ainley, A. Agrawal, B. C. Nichol, R. Srinivas, G. Araneda, and D. M. Lucas, “Distributed quantum computing across an optical network link,” Nature, vol. 638, no. 8050, p. 383–388, Feb. 2025. [Online]. Available: http://dx.doi.org/10.1038/s41586-024-08404-x [3] A. Carrera Vazquez, C. Tornow, D. Ristè, S. Woerner, M. Takita, and D. J. Egger, “Combining quantum processors with real-time classical communication,” Nature, vol. 636, no. 8041, p. 75–79, Nov. 2024. [Online]. Available: http://dx.doi.org/10.1038/s41586-024-08178-2 [4] A. M. Brańczyk, A. Carrera Vazquez, D. J. Egger, B. Fuller, J. Gacon, J. R. Garrison, J. R. Glick, C. Johnson, S. Joshi, E. Pednault, C. D. Pemmaraju, P. Rivero, I. Shehzad, and S. Woerner, “Qiskit addon: circuit cutting,” https://github.com/Qiskit/qiskit-addon-cutting, 2024. [5] W. Tang, T. Tomesh, M. Suchara, J. Larson, and M. Martonosi, “CutQC: using small quantum computers for large quantum circuit evaluations,” in Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. ACM, apr 2021. [Online]. Available: https://doi.org/10. 1145%2F3445814.3446758 [6] C. Piveteau and D. Sutter, “Circuit knitting with classical communication,” IEEE Transactions on Information Theory, vol. 70, no. 4, p. 2734–2745, Apr. 2024. [Online]. Available: http://dx.doi.org/10.1109/TIT.2023.3310797 [7] D. Chen, E. Hansen, X. Li, A. Orenstein, V. Kulkarni, V. Chaudhary, Q. Guan, J. Liu, Y. Zhang, and S. Xu, “Online detection of golden circuit cutting points,” in 2023 IEEE International Conference on Quantum Computing and Engineering (QCE). IEEE, 2023. [8] M. A. Perlin, Z. H. Saleem, M. Suchara, and J. C. Osborn, “Quantum circuit cutting with maximum-likelihood tomography,” npj Quantum Information, vol. 7, no. 1, p. 64, 2021. [Online]. Available: https://doi.org/10.1038/s41534-021-00390-6 [9] X. Li, V. Kulkarni, D. T. Chen, Q. Guan, W. Jiang, N. Xie, S. Xu, and V. Chaudhary, “Efficient circuit wire cutting based on commuting groups,” arXiv preprint arXiv:2410.20313, 2024. [10] D. T. Chen, E. H. Hansen, X. Li, V. Kulkarni, V. Chaudhary, B. Ren, Q. Guan, S. Kuppannagari, J. Liu, and S. Xu, “Efficient quantum circuit cutting by neglecting basis elements,” arXiv preprint arXiv:2304.04093, 2023. [11] L. Liu and X. Dou, “Qucloud+: A holistic qubit mapping scheme for single/multi-programming on 2d/3d nisq quantum computers,” ACM Trans. Archit. Code Optim., vol. 21, no. 1, Jan. 2024. [Online]. Available: https://doi.org/10.1145/3631525 [12] A. Orenstein and V. Chaudhary, “Qgroup: Parallel quantum job scheduling using dynamic programming,” in 2024 IEEE International Conference on Quantum Computing and Engineering (QCE), vol. 01, 2024, pp. 990–999. [13] V. Kulkarni, A. Orenstein, X. Li, S. Xu, D. Blankenberg, and V. Chaudhary, “Quflex: Parallel quantum job scheduling using adaptive circuit cutting,” in Proceedings of Supercomputing India (SCI), 2025, to appear. [14] M. Wang, P. Das, and P. J. Nair, “Qoncord: A multi-device job scheduling framework for variational quantum algorithms,” in 2024 57th IEEE/ACM International Symposium on Microarchitecture (MICRO), 2024, pp. 735–749. [15] J. Li, Y. Song, Y. Liu, J. Pan, L. Yang, T. Humble, and W. Jiang, “Qusplit: Achieving both high fidelity and throughput via job splitting on noisy quantum computers,” arXiv preprint arXiv:2501.12492, 2025. [16] S. Kan, Z. Du, M. Palma, S. A. Stein, C. Liu, W. Wei, J. Chen, A. Li, and Y. Mao, “Scalable circuit cutting and scheduling in a resource-constrained and distributed quantum system,” 2024. [Online]. Available: https://arxiv.org/abs/2405.04514 [17] V. Chaudhary and J. K. Aggarwal, “A generalized scheme for mapping parallel algorithms,” IEEE Trans. Parallel Distrib. Syst., vol. 4, no. 3, p. 328–346, Mar. 1993. [Online]. Available: https: //doi.org/10.1109/71.210815 [18] T. SimPy, “Simpy: A discrete-event simulation library,” PeerJ Computer Science, vol. 2, p. e103, 2016. [Online]. Available: https://doi.org/10.7717/peerj-cs.103 [19] N. Quetschlich, L. Burgholzer, and R. Wille, “MQT Bench: Benchmarking software and design automation tools for quantum computing,” Quantum, 2023, MQT Bench is available at https://www.cda.cit.tum.de/ mqtbench/.