EFaaS: A Quantum-Classical Serverless Entangled Scheduler for Hybrid Variational Algorithms Abolfazl Younesi∗
, Nouhaila Innan†‡
, Alberto Marchisio†‡
, Muhammad Shafique†‡
∗ Department of Computer Science, Sharif University of Technology, Tehran, Iran † eBrain Lab, Division of Engineering, New York University Abu Dhabi, PO Box 129188, Abu Dhabi, UAE
arXiv:2605.27540v1 [quant-ph] 26 May 2026
‡ Center for Quantum and Topological Systems, NYUAD Research Institute, New York University Abu Dhabi, UAE Emails: [email protected], [email protected], [email protected], [email protected]
Abstract—As quantum computing enters the Utility Era, realizing near-term advantage relies heavily on Hybrid Variational Quantum Algorithms (VQAs). These algorithms require a tightly coupled, iterative loop between a classical CPU optimizer and a Quantum Processing Unit (QPU). However, current quantum cloud access models are bottlenecked by decoupled batchqueues that sever this loop, introducing massive Time-to-NextShot (TTNS) latency. This delay inflates convergence time from minutes to hours and exposes the computation to quantum hardware drift, degrading algorithmic fidelity. Unlike prior works that rely on resource-wasting static hardware reservations or state-oblivious stateless functions, we propose EFaaS, a novel serverless middleware designed specifically for hybrid quantum workflows. EFaaS fundamentally departs from existing architectures by treating classical parameter optimization and quantum circuit execution as entangled, session-aware events. Our main technical innovations are threefold: (1) a Calibration-Aware placement strategy that dynamically routes circuits to QPUs with warm calibration caches, circumventing cold-start penalties, (2) a Dual-Resource Fair Queuing scheduler that maximizes quantum utilization by strictly prioritizing active iterative loops, and (3) the “EF-QuantumFuture” programming abstraction, a novel primitive enabling classical speculative execution to mask compute latency. Across the evaluated baselines, EFaaS achieves TTNS reductions of 11.4%-94.3%, QDC gains of 2.02%15.78% points, and convergence speedups of 83.2%-98.3%, while eliminating drift penalties. Index Terms—Quantum Cloud Computing, Serverless Architecture, Hybrid Quantum-Classical Algorithms, Variational Quantum Eigensolver, Quantum Hardware Drift
I. I NTRODUCTION UANTUM computing has crossed the threshold into the “Utility Era,” a phase where quantum hardware can execute complex circuits beyond the reach of brute-force classical simulation [1], [2]. Realizing near-term quantum advantage in this era is heavily based on hybrid variational quantum algorithms (VQAs), such as the Variational Quantum Eigensolver (VQE) and the quantum approximation optimization algorithm (QAOA) [2], [3]. These algorithms operate fundamentally as a tightly coupled, iterative loop: a classical CPU optimizes parameterized variables, which are then evaluated as a cost function on a Quantum Processing Unit (QPU) through repeated circuit executions, or shots. Despite algorithmic advances, such as the development of noise-resilient classical optimizers and hardware-efficient ansatz designs [4], [5], the systems-level architecture that
Q
supports these hybrid loops remains a significant bottleneck. Current quantum cloud access models operate primarily on batch-queue systems [6]. In this paradigm, the iterative loop is repeatedly broken: a classical job submits a quantum circuit, waits in a queue, receives a result, classically optimizes, and resubmits. When queue times span seconds or minutes, a VQA requiring thousands of iterations can take days to converge. Furthermore, this queueing latency introduces a critical physical vulnerability: quantum drift [7]. As the time between iterations extends (“cold starts”), QPU calibration data becomes stale. This drift degrades measurement fidelity, destroys the coherence of the optimization landscape, and forces costly system recalibrations [8]. Conversely, statically reserving scarce QPUs for the entire duration of a job while waiting for abundant CPUs to perform optimization is economically and computationally wasteful. Pure Functions-as-aService (FaaS) models [9] address classical scaling but fail to accommodate the stateful, synchronous demands of quantum hardware. Proposed approach. We propose EFaaS, a novel serverless scheduling middleware that sits between the quantum control plane and classical cloud orchestrators. EFaaS eliminates the traditional queuing bottleneck by treating QPU shots and CPU functions as entangled, session-aware events rather than isolated batch jobs. By implementing “Session Awareness,” the scheduler caches QPU calibration data while the classical CPU optimizes parameters. Furthermore, to mask classical computation latency, we introduce the “EF-QuantumFuture” abstraction, a programming primitive that enables asynchronous variation and allows classical code to speculatively continue execution while awaiting QPU results. Contributions. Our specific contributions are as follows: • We propose EFaaS (Entangled Function-as-a-Service), a hybrid serverless execution model that co-schedules quantum circuit execution and classical parameter optimization as session-coupled events, drastically reducing the latency of the iterative loop (Time-to-Next-Shot). • We design a Calibration-Aware Placement strategy that routes circuits to QPUs with valid, iteration-specific calibration data, preventing cold starts and mitigating the impacts of quantum drift. The mechanism inherits its routing intuition from sticky-session affinity and locality-aware cluster schedulers, but reformulates the affinity validity predicate from a software
invariant (cache hit, container warm) to a physical coherencetime threshold derived from qubit drift dynamics [8]. • We derive a Dual-Resource Fair Queuing (DRFQ) scheduling policy that maximizes the Quantum Duty Cycle (active QPU time) while preserving fair resource distribution for classical workloads. DRFQ extends Dominant Resource Fairness [10] to a setting where a single resource (QPU shots) is subject to a physical staleness constraint. • We introduce EF-QuantumFuture, a speculativeexecution primitive for hybrid quantum-classical workflows. While quantum SDKs already expose asynchronous job-handle abstractions for deferred result retrieval, EF-QuantumFuture is, to our knowledge, the first to combine non-blocking dispatch with a defined speculation/commit/abort contract over the classical optimizer state. Paper structure. The remainder of this paper is organized as follows. Section II provides background. Section III reviews related work. Section IV introduces the EFaaS system architecture. Section V formulates the co-scheduling algorithms and placement strategies. Section VI presents performance evaluation, and Section VII concludes the paper.
Classical Domain
Quantum Domain
Classical Processor CPU/Optimzer
Parameter mapped Quantum Circuit
Parameter Optimization Gradient Update (e.g., SPSA) minimize (E(θ)) θ
Updated Parameters: θi+1
q0 |0〉 Rz(θ1) q1 |0〉 Rz(θ2)
U(θi+1)
q2 |0〉 Shot management and expectation value calculation Acccumulation of shots = Σ Shots
θ = Parameter vector
Measured Results
Fig. 1: Iterative hybrid quantum-classical workflow for variational algorithms (VQE/QAOA), where a classical optimizer updates circuit parameters based on measurements from a quantum processor, forming a feedback loop between classical and quantum domains
to the moment the QPU begins evaluating the corresponding circuit. In the current quantum cloud paradigm, access is mediated by multi-tenant, batch-queue systems. When a VQA iterates, the updated circuit is submitted over the network and placed at the back of a FIFO (First-In-First-Out) or fair-share queue. The TTNS is thus defined as:
II. BACKGROUND AND M OTIVATION As quantum computing transitions from proof-of-concept experiments to the Utility Era, the focus is shifting toward algorithms that can run on near-term hardware without full fault tolerance. Achieving quantum advantage in this regime fundamentally depends on resolving the systems-level friction between classical and quantum resources. A. Hybrid Quantum-Classical Workflows As shown in Fig. 1, Variational Quantum Algorithms (VQAs) [11], such as the Variational Quantum Eigensolver (VQE) [12] and the Quantum Approximate Optimization Algorithm (QAOA) [13], are the primary candidates for nearterm quantum utility [1]. These algorithms do not run exclusively on a Quantum Processing Unit (QPU). Instead, they function as a tightly coupled, iterative loop between a classical processor and a quantum processor. In a typical VQE workflow, a classical optimizer (e.g., SPSA [14], COBYLA [15]) ⃗ These parameters initializes a set of parameterized variables θ. define a quantum circuit (the ansatz), which is sent to the QPU. The QPU executes the circuit multiple times (shots) to measure the energy expectation value, representing the cost function of the problem landscape. This result is returned to the classical CPU, which computes the gradient and updates the parameters to θ⃗i+1 . This loop must execute hundreds or thousands of times to achieve algorithmic convergence. Consequently, the performance of a VQA is dictated not just by quantum gate speeds, but by the round-trip communication and scheduling architecture binding the two domains. B. The Latency Bottleneck and TTNS The critical metric governing hybrid algorithm performance is the Time-to-Next-Shot (TTNS), the total latency incurred from the moment the classical CPU outputs new parameters
T T N S = tnet + tqueue + tcalib + tqpu
(1)
where tnet is network transmission, tqueue is the wait time in the cloud provider’s queue, tcalib is potential hardware preparation delays, and tqpu is the quantum execution time. Because tqueue is highly variable and depends on crosstenant traffic, it frequently dominates the TTNS equation, spanning from several seconds to minutes. For an algorithm requiring 5,000 iterations, a mere 30-second queue delay per iteration inflates the total runtime from a few minutes to over 40 hours. This latency severs the tight coupling required by the algorithm, transforming an iterative loop into a fragmented sequence of isolated batch jobs. C. Quantum Drift and Cold Starts The severe latency introduced by batch-queueing is not merely a performance issue; it is a profound physical vulnerability. Current superconducting and ion-trap QPUs are inherently noisy and highly sensitive to environmental fluctuations. Consequently, the physical properties of the qubits, such as T1 relaxation times, T2 coherence times, and gate error rates, drift continuously. To counteract this, cloud providers periodically run calibration sequences to update the control microwave pulses (Cq ). However, this calibration data is valid only within a limited temporal window, denoted by τdrift . If the delay between VQA iterations (tqueue ) exceeds τdrift , the QPU undergoes a “cold start.” Cold starts force the system to either pause the workload to undergo a costly recalibration cycle (tcalib ) or, worse, execute the circuit using stale calibration data. If the circuit runs on stale data, the measurement fidelity drops and the cost function ⟨H⟩t becomes non-stationary across iterations: identical parameter vectors θ⃗ return different
expectation values at different wall-clock times. This nonstationarity violates the i.i.d. sampling assumption underlying stochastic optimizers such as SPSA [14] and desynchronizes finite-difference gradient estimates, forcing the classical node to execute more iterations to converge, if it converges at all [8]. We emphasize that this drift-induced non-stationarity is distinct from the barren-plateau phenomenon, which is a static property of the parameterized ansatz under random initialization, and from noise-induced barren plateaus, which arise from coherent or incoherent gate-noise channels rather than inter-iteration calibration aging. D. Resource Asymmetry and Allocation Inefficiencies Solving the latency and drift bottlenecks requires reconciling a massive asymmetry in resource availability. Classical compute resources (CPUs, FaaS nodes) are practically infinite and highly elastic. In contrast, state-of-the-art QPUs are scarce, expensive, and strictly localized. Current architectures attempt to bypass queueing latency via Static Reservation, in which a user pays to exclusively lock the physical QPU for the duration of the VQA job. While this drives tqueue → 0, it is economically unscalable for public clouds and computationally highly inefficient. During a static reservation, whenever the classical CPU is performing complex parameter updates (tcpu ), the locked QPU remains idle. Conversely, relying solely on pure stateless Functions-as-a-Service (FaaS) [9] for classical compute fails to address the stateful requirements of quantum hardware. Stateless classical architectures inherently drop the QPU session context between invocations, defaulting back to cold starts and drift penalties. Therefore, a novel architectural paradigm is required, one that preserves the stateful session context of scarce quantum hardware while dynamically coscheduling abundant classical functions to minimize idle time and maximize the Quantum Duty Cycle. III. R ELATED W ORK EFaaS sits at the intersection of four active research areas: hybrid quantum-classical computing frameworks, quantum cloud resource management, classical serverless scheduling, and variational algorithm optimization. We survey each in turn and position our work against the state of the art. Table I provides a structured comparison across the key dimensions of our problem formulation. A. Hybrid Quantum-Classical Frameworks The VQE [16] and the QAOA [17] established the hybrid quantum-classical loop as the dominant execution paradigm for near-term quantum devices. Both algorithms depend critically on tight CPU–QPU coupling: the classical optimizer must receive QPU results and resubmit updated circuits with minimal latency. Subsequent work refined the algorithmic side gradient estimation via parameter-shift rules [18], noiseaware ansatz design [19], and adaptive circuit construction [20] but uniformly assumed idealized, low-latency QPU access. None of these works model or mitigate the scheduling latency
introduced by real cloud quantum access models, which is the central gap EFaaS addresses. On the platform side, IBM’s Qiskit Runtime [6] introduced the Session primitive to reduce inter-job queuing overhead by batching circuit submissions within a reserved QPU window. Qiskit Serverless [21] (2024) extends this further with a programming model for long-running hybrid workloads across distributed CPU, GPU, and QPU resources. While Sessions reduces cold-start penalties within a single job and Qiskit Serverless improves scalability, both remain decoupled at the scheduler level: classical optimizer invocations and QPU shots are not treated as jointly scheduled resources, calibration state is not explicitly cached with TTL-aware eviction, and variable Time-to-Next-Shot (TTNS) persists under contention, leaving active loops exposed to calibration drift. Amazon Braket Hybrid Jobs [22] similarly enables hybrid orchestration by running user code in managed containers with priority QPU access throughout a job’s lifetime, reducing queue times for iterative tasks. However, it lacks calibration-aware routing to warm-cached backends and provides no mechanism for speculative classical execution during QPU wait periods. Pilot-Quantum [23] provides a unified middleware abstraction for resource, workload, and task management across CPUs, GPUs, and QPUs, supporting variational algorithms via task parallelism and integration with Qiskit and PennyLane. It emphasizes modular orchestration and adaptive allocation, but places are limited emphasis on drift-specific placement or low-latency session continuity. Other hybrid middleware proposals address orchestration patterns [24], workflow rewriting [25], and drift-aware scheduling considerations [26], yet none jointly optimizes calibration validity, dual-resource fairness, and speculative execution within a unified scheduler. B. Quantum Cloud Resource Management Murali et al. [27] demonstrated that QPU backend selection significantly affects circuit fidelity, motivating noise-aware compilation and placement at the compilation layer. Their work does not address the runtime scheduling of iterative jobs or the temporal evolution of calibration validity between submissions. Paler et al. [28] proposed machine-learning approaches for QPU job scheduling, focusing on makespan minimization for independent, non-iterative circuit batches. Ravi et al. [29] studied QPU multi-programming, executing multiple independent circuits simultaneously on disjoint qubit subsets, improving QPU utilization without coupling to the classical optimizer state or modeling inter-iteration drift accumulation. Static QPU reservation avoids queuing but wastes QPU time during classical optimization phases and locks out concurrent users. Pure batch models incur high TTNS and fidelity loss from drift [7]. EFaaS occupies the space between these extremes through session leasing, calibration caching, and dualresource co-scheduling. C. Serverless and FaaS Scheduling Serverless computing and FaaS platforms such as AWS Lambda [30] and Knative [34] eliminate infrastructure man-
TABLE I: Comparison of hybrid quantum-classical execution approaches across key scheduling dimensions. Yes = fully supported; Partial = partially supported; No = not supported. Approach VQE / QAOA [16], [17] Qiskit Runtime / Serverless [21] Amazon Braket Hybrid Jobs [22] Pilot-Quantum [23] QFaaS / Traditional FaaS [9], [30] Other Hybrid Middleware [24], [25] Noise-Aware Placement [27] QPU Multi-Programming [29] FaaS Cold-Start Mitigation [31], [32] Quantum Pipelining [33] Static Reservation EFaaS (Proposed)
Session-Aware / Calib. Caching No Partial (sessions) Partial (job lifetime) No No No No No Partial (keep-alive) No Yes (exclusive) Yes
Calibration-Aware Placement No No No No No Partial Partial (compile-time) No No No Partial Yes
Dual-Resource Co-Scheduling No Partial (priority grouping) Partial (priority during job) Yes (multi-level) No Partial No No No No No Yes (DRFQ)
Speculative / Latency Masking No No No No No No No No No Partial (compile) No Yes (EF-QuantumFuture)
Serverless / FaaS-like No Yes (recent) Container-based No Yes No No No Yes No No Yes
agement by dynamically provisioning short-lived function containers. The cold-start latency inherent to FaaS has been extensively studied [31], [35], with mitigations including keep-alive policies [32], predictive pre-warming [36], and checkpoint-restore techniques [37]. These classical FaaS insights directly inform our Session Awareness Engine: the TTL-based calibration cache is structurally analogous to a keep-alive policy, adapted for the physical decay dynamics of qubit coherence rather than container memory state. Emerging quantum-serverless proposals, such as QFaaS [9], explore FaaS abstractions for quantum circuits and address classical scaling effectively, but struggle with stateful quantum synchronization and the scarcity of QPU resources. Critically, no existing FaaS or quantum-FaaS framework is aware of the iterative, coupled nature of hybrid workloads, defines QPU shot budgets as a schedulable resource share, or provides a speculative execution primitive for the classical optimizer. EFaaS introduces all three of these missing dimensions into the serverless execution model. Dominant Resource Fairness (DRF) [10] provides the theoretical foundation for our DRFQ scheduler. DRF achieves max-min fairness in multi-resource settings. Our contribution extends DRF to a domain where one resource (QPU shots) carries a physical staleness constraint, requiring the joint optimization of fairness and calibration validity, a problem not considered in any prior DRF or quantum scheduling literature.
E. Comparative Summary
D. Speculative and Asynchronous Execution
A. System Overview
Speculative execution is well-established in classical processors microarchitecture [38] and distributed systems [39], where tasks execute ahead of confirmed dependencies to hide latency. In quantum computing, Shi et al. [33] explored pipelining a quantum circuit compilation stage, and Ding et al. [40] proposed co-design of quantum programs and classical control, but neither extends speculative execution to the optimizer parameter-update loop at runtime. The QuantumFuture abstraction introduced in EFaaS is the first formalization of speculative classical optimization in a hybrid quantum-classical serverless context, with a principled reconciliation policy grounded in gradient-deviation bounds. This directly addresses the latency masking. A gap is present in all prior hybrid frameworks surveyed above.
Formal Fairness Guarantee No No No No No No No No No No No Yes
Low TTNS for Active VQA Loops No Moderate Moderate Low–Moderate Low Low No No No No High (wasteful) High
Table I summarizes how EFaaS differs from the most closely related systems across seven key dimensions. No prior system simultaneously addresses all seven: session-aware calibration caching, calibration-aware placement, dual-resource co-scheduling, speculative classical execution, serverless deployment, formal fairness guarantees, and low TTNS for active VQA loops. EFaaS advances beyond all prior work by fully coupling classical and quantum scheduling events through four synergistic mechanisms: (i) TTL-aware session caching in the SAE eliminates cold-start recalibration, (ii) calibration-aware placement routes circuits to backends with valid cached qubit fidelity data, (iii) DRFQ enforces max-min fairness jointly over QPU shots and CPU cycles, and (iv) the QuantumFuture abstraction overlaps speculative classical optimization with QPU execution, achieving near-zero TTNS for active VQA loops while preserving serverless elasticity and drift resilience. IV. EFAA S A RCHITECTURE To resolve the deep latency and coherence bottlenecks inherent in current hybrid quantum-classical workflows, we introduce EFaaS. This serverless architecture fundamentally redefines the relationship between classical parameter optimization and quantum circuit execution, transitioning from a decoupled batch-queue model to a tightly bound, synchronous event-driven paradigm.
The EFaaS system can act as an intelligent middleware layer situated between a classical cloud orchestrator and the Quantum Control Plane of the QPU provider. Traditional architectures treat the classical CPU optimizer and the QPU evaluating the cost function as separate, asynchronous entities. EFaaS unifies them using a co-scheduling controller. When a hybrid algorithm (such as VQE) is submitted, the orchestrator allocates a classical function instance. Simultaneously, the EFaaS middleware negotiates a highpriority, session-aware window with the Quantum Control Plane, creating an “entangled” execution loop. B. Mathematical Formulation and Notation To rigorously define the latency advantages of EFaaS, we formulate the Time-to-Next-Shot (TTNS) under both standard
Classical Domain (FaaS Apps) Microservice
Scheduler
Events
∆t < τd , next θ
Classical CPU
AWS Lambda
new job
IDLE
Classical FaaS Triggers
SESSION ACTIVE
shot done, Es ← 1
re-
job done, Es ← 0
Allows CPU to spectaculatively advance awaiting QPU results
b.
Tracks Calibration Data
Asynchronous Future Engine
li ca
FaaS Request Interceptor and Session Manager Session State Cache
∆t ≥ τd
Quantum Execution Interface
CACHE EXPIRED
Quantum Execution Requests and Results Quantum Domain (Cloud Provider Control Plane)
Calibration Routine
Queue Management
CACHE VALID
Control Plane Logic
Fig. 2: EFaaS System Architecture. The middleware intercepts Classical FaaS triggers and Quantum Execution requests (Control Plane). The “Session State Cache” maintains QPU calibration data (Cq ) while the “Asynchronous Future Engine” allows the CPU to speculatively advance while awaiting QPU results.
Fig. 3: Session Awareness Engine state machine. A Hot Iterator cycles between SESSION ACTIVE and CACHE VALID provided each inter-shot delay ∆t remains within τd = τdrift . If the cache expires, the engine triggers a localized recalibration before resuming the active session.
D. The “EF-QuantumFuture” Abstraction and proposed architectures. The key system variables are defined in Table II. TABLE II: System Variables and Notation Definition Latency per iteration (Standard) Latency per iteration (EFaaS) Execution time of classical optimization QPU active execution time (shots) Time spent in standard cloud queue Time required to re-calibrate QPU Quantum coherence/drift time threshold Calibration data matrix for target qubits Session awareness active flag {0, 1} Speculative classical execution time
Classical Optimizer
QPU
dispatch
QPU (tqpu )
Future f (async)
In a standard cloud access model, the total latency for a single iteration of a VQA is the linear sum of classical computation, queueing delay, potential recalibration, and quantum execution: Lstd = tcpu + tqueue + δ · tcalib + tqpu
EFaaS Middleware
submit θ i , circuit
time −→
Symbol Lstd Lent tcpu tqpu tqueue tcalib τdrif t Cq Es tasync
To further minimize the perceived latency and decouple the strict synchronous waiting of the classical node, we introduce the EF-QuantumFuture programming primitive (see Fig. 4). In traditional VQAs, the classical process blocks entirely
specul. work tasync result ⟨H⟩
f.resolve(⟨H⟩)
(2)
where δ = 1 if tqueue > τdrif t (indicating a cold start due to stale calibration data), and 0 otherwise. Because tqueue is often highly variable and frequently exceeds τdrif t in public quantum clouds, algorithms are heavily penalized by tcalib . C. Session Awareness and Calibration Caching The core mechanism of EFaaS is Session Awareness (see Fig.3). Instead of tearing down the quantum environment after tqpu is completed, the middleware asserts the session flag Es = 1. This instructs the Quantum Control Plane to hold the calibration data matrix Cq in a localized cache. The scheduler dynamically calculates the maximum allowable classical compute window before drift forces a recalibration: tcpu ≤ τdrif t − ϵ (3) where ϵ is a system safety margin. As long as the classical CPU returns the next parameterized circuit within τdrif t , the QPU executes the shots immediately. By elevating the priority of circuits returning to a warm cache, EFaaS drives tqueue → 0 and δ → 0.
θ i+1 ← step() submit θ i+1
Fig. 4: EF-QuantumFuture execution sequence. The Middleware returns an asynchronous Future f immediately upon submission, allowing the classical optimizer to perform speculative work (tasync ) concurrently with QPU execution (tqpu ). The f.resolve() call delivers ⟨H⟩ once the QPU completes, and the optimizer proceeds to θ i+1 without any blocking wait.
while the QPU evaluates the energy expectation value ⟨H⟩. The EF-QuantumFuture object returns an immediate asynchronous promise to the classical optimizer. This allows the classical function to speculatively continue execution, such as calculating gradient descent hyperparameters or updating nonquantum dependent classical nodes while tqpu runs. If tasync represents the time spent executing speculative classical operations concurrently with the QPU, the iteration latency under EFaaS is reduced to: Lent = max(tcpu − tasync , 0) + tqpu + tnet
(4)
where tnet is the negligible network transmission overhead. By co-scheduling the resources and overlapping tasync with tqpu , EFaaS strictly bounds the execution time and completely insulates the iterative loop from external queueing disruptions. V. C O -S CHEDULING AND A LGORITHMIC F RAMEWORK
where I is the indicator function for an active session, ∆twait is the time elapsed since the last shot, Wi is a standard fairshare weight to prevent starvation of batch jobs, and α, β, γ are tunable hyperparameters. Hot Iterators receive a massive boost via α, ensuring that as soon as the classical node yields a parameter update, the QPU executes it immediately.
The fundamental innovation of EFaaS is its departure from independent, isolated job queues for classical and quantum resources. To realize the latency reductions modeled in Section IV, we introduce a co-scheduling framework that combines Dual-Resource Fair Queuing with a Calibration-Aware Placement Strategy.
C. Entangled Scheduling Algorithm
A. Calibration-Aware Placement Strategy
Input: Job queue J, Available QPUs U , Current time tnow Output: Assigned QPU u∗ or Classical Node c∗ 1 while J is not empty do 2 Pop highest priority job j from J based on ρ; 3 if j is Quantum Circuit q then 4 if q has active session flag Es == 1 then 5 u∗ ← find cached qpu(q, U ); 6 if (tnow − u∗ .last calib) < τdrif t then 7 Assign q to u∗ with Preemptive Priority; 8 Update u∗ .last calib ← tnow ; 9 else 10 Trigger localized recalibration on u∗ ; 11 Assign q to u∗ ; 12 else 13 u∗ ← standard fair queue(q, U ); 14 else 15 c∗ ← assign classical node(j); 16 Initialize EF-QuantumFuture async object for c∗ ;
In standard architectures, a quantum circuit is routed to the first available QPU matching its topology requirements. EFaaS introduces Calibration-Aware Placement, a stickysession affinity policy specialized to the physical-decay regime of QPU calibration. Conceptually analogous to node-locality preferences in YARN [41] and topology-aware routing in Kubernetes [42], our placement engine prefers the QPU that holds the relevant warm state. Unlike classical affinity, however, the validity predicate is governed not by software invariants (cache presence, container liveness) but by a physical coherence-time threshold τdrift derived from qubit drift dynamics [8]. The placement engine actively tracks the calibration state Cq of the physical hardware. If a hybrid algorithm is executing an iterative loop, the target QPU’s quantum state drifts over time. We define a validity threshold τdrift that specifies the maximum time window after which a QPU’s calibration data is considered stale. The scheduler maintains a mapping of active sessions to specific QPUs. When a new circuit qi from an active iteration arrives, the placement engine attempts to route it to the exact QPU uk utilized in the previous iteration, provided that the elapsed time ∆t satisfies ∆t < τdrift . This prevents the severe latency penalty of cold-start recalibrations. B. Dual-Resource Fair Queuing To prioritize active quantum loops without starving classical workloads or independent quantum batch jobs, we define the concept of a “Hot Iterator.” A Hot Iterator is an active VQA session where the classical CPU is currently computing the next set of parameters, and the QPU is holding its calibration state in cache (Es = 1). We define the scheduling objective to maximize the Quantum Duty Cycle (QDC), which is the ratio of active quantum execution time to total wall-clock time: N
max QDC =
1 X (i) t T i=1 qpu
(5)
To achieve this, the scheduler calculates a dynamic priority score ρi for each incoming job i: τdrif t − ∆twait (i) ρi = α · I(Es = 1) + β · + γ · Wi (6) τdrif t
The logic governing the EFaaS middleware is formalized in Algorithm 1. Algorithm Scheduling
1:
Calibration-Aware
Dual-Resource
Algorithm Explanation: The algorithm continuously processes incoming hybrid workloads, taking inputs of jobs and available resources. The main event loop begins at Line 1, popping jobs sorted by the priority score ρ defined in Equation 6 (Line 2). If the job is identified as a quantum circuit (Line 3), the scheduler checks if it is part of a Hot Iterator by verifying the session flag Es (Line 4). For active sessions, the middleware attempts to locate the specific QPU that holds the cached calibration data (Line 5). Crucially, Lines 6 through 8 evaluate the quantum drift threshold. If the time elapsed is strictly less than τdrif t , the circuit is preemptively assigned, bypassing standard queues and avoiding cold starts. If the drift threshold has been exceeded (Line 9), a localized, partial recalibration is triggered before execution (Lines 1011). Standard quantum batch jobs lacking an active session flag fall back to standard fair queuing (Lines 12-13). Conversely, if the popped job is a classical optimization task (Line 14), it is assigned to a classical FaaS node (Line 15). Immediately upon this assignment, the EF-QuantumFuture asynchronous object is initialized (Line 16), allowing the classical node to begin speculative execution while the QPU resolves the subsequent circuit execution. VI. E XPERIMENTAL E VALUATION To validate the performance of the EFaaS architecture, we constructed a comprehensive simulation environment that models the execution of hybrid VQE algorithms across distributed classical and quantum infrastructure.
TABLE III: Experimental Testbed and Software Environment Component Language Runtime Quantum SDK Quantum Primitive Queueing Model Background Traffic QPU Pool Size Classical Pool Size Simulation Horizon
Specification / Version Python 3.11.x Qiskit Qiskit Aer Estimator Lognormal (µ = 3.5, σ = 0.8) Poisson arrivals (λ = 0.05/s) NQP U = 3 Nclassical = 4 T = 3000 simulated seconds
Evaluation Methodology and Testbed. Evaluating a unified quantum-classical serverless model requires co-scheduling visibility that is difficult to obtain from production cloud control planes. We therefore use a discrete-event simulator implemented with SimPy and instrumented with Qiskit Aerbased quantum evaluations. The simulator explicitly models queueing, drift, calibration, pilot startup/overhead, and background traffic, and records per-iteration TTNS, convergence timing, QDC, and drift penalties. Queue delay is modeled as a high-variance lognormal process (µ = 3.5, σ = 0.8), and background contention is modeled as a Poisson process (λ = 0.05 jobs/s) with exponential QPU service times (mean 5 s). The concrete software environment and core runtime settings are listed in Table III. Workload and Hyperparameters. Our workload is an iterative VQE-style benchmark driven by SPSA with up to 1000 iterations per run. For observables, we use a LiH Hamiltonian and a transverse-field Ising-chain Hamiltonian for larger circuits. We benchmark EFaaS against four architectural baselines currently utilized in quantum-cloud ecosystems: 1) Standard Batch-Queue (SBQ): The default model where each iteration is a discrete job in a FIFO queue. 2) Pure FaaS (PF): A decoupled model where the optimizer runs statelessly, but quantum jobs enter a standard queue. 3) Static Reservation (SR): A dedicated access model locking the QPU exclusively for the job’s duration. 4) Pilot-Quantum (PQ) [23]: A pilot-job model with one startup phase followed by low-overhead warm task dispatch. The algorithmic and scheduling hyperparameters governing both the VQE payload and the Dual-Resource scheduler are defined in Table IV. For sensitivity analysis, we sweep α ∈ {0, 10, 50, 100, 200}, β ∈ {0, 1, 5, 10, 20}, γ ∈ {0.1, 0.5, 1.0, 2.0, 5.0}, and τdrif t ∈ {60, 150, 300, 600, 900} while holding other parameters at their default values. Circuit complexity stratification. To keep the benchmark suite reproducible and easy to compare across modes, we report the exact benchmark circuits used in the evaluation together with their qubit counts and measured circuit depths. Table V lists all standard circuits drawn from the three complexity bands. Metrics. We evaluate these models across four critical metrics: Time-to-Next-Shot (TTNS), End-to-End Convergence Time, Quantum Duty Cycle (QDC), and Algorithmic Fidelity (variance due to quantum drift).
TABLE IV: Workload and Scheduling Hyperparameters Parameter Workload Family Circuit Benchmarks Optimizer Shots per Evaluation Base QPU Time (tqpu ) Classical Step Time (tcpu ) Network Overhead (tnet ) Async Overlap Budget (tasync ) Drift Threshold (τdrif t ) Calibration Penalty (tcalib ) Scheduler Weights (α, β, γ) PQ Startup / Warm Overhead
Value VQE-style iterative optimization 31 circuits across 3 complexity bands SPSA (max_iter = 1000) 4096 2.0 s (with ±0.3 s jitter) 1.5 s 0.5 s 0.8 s 300 s 30 s (100.0, 5.0, 1.0) 2.0 s / 0.5 s
TABLE V: Benchmark circuit summary Band Simple Medium Complex
Circuits 10 10 11
Qubits 2–5 6–10 10–16
Depth 6–32 13–69 33–141
A. Results and Analysis 1) Time-to-Next-Shot (TTNS) Latency: TTNS is the single most consequential latency metric for hybrid VQAs: every millisecond added to this round-trip delay directly inflates convergence time and increases the probability of a calibration cold start. Figs. 5(a)–(c) report the mean TTNS per individual circuit for all five modes stratified by complexity band. EFaaS vs. batch-queue baselines (SBQ and PF). The dominant result across all 31 circuits is the catastrophic TTNS penalty imposed by queueing architectures. SBQ exhibits a mean TTNS of 48.4 s and PF 54.5 s, driven almost entirely by the lognormal queue-wait component tqueue . EFaaS, with a mean TTNS of 3.6 s, reduces this latency by 92.5% relative to SBQ and 93.4% relative to PF. The reduction is structurally guaranteed: because the Dual-Resource Fair Queuing scheduler assigns a priority boost α = 100 to every Hot Iterator, the returning circuit from an active session always preempts any batch job in the QPU queue, driving tqueue → 0. Beyond the mean, Figs. 5a- 5c reveals that SBQ and PF TTNS distributions have interquartile ranges spanning 30–40 s. Even in the most favorable queue condition, a single SBQ iteration cannot match the worst-case EFaaS iteration. Across the full benchmark, EFaaS achieves TTNS reductions spanning 11.4%–94.3% depending on the competitor, with the smallest gains over PQ (which also uses a warm-dispatch model) and the largest over PF (which incurs both cold-start and FaaS container initialization overhead on every call). EFaaS vs. reservation-based baselines (SR and PQ). Static Reservation (SR) avoids the queue entirely by holding a dedicated QPU lock, yielding a mean TTNS of 4.3 s comparable to EFaaS. However, SR achieves this at the cost of continuously blocking a physical QPU for the entire job duration, including the classical optimization interval tcpu . Pilot-Quantum (PQ) similarly achieves 4.1 s by amortizing its pilot startup cost over many warm task dispatches. EFaaS improves over SR by 14.9% and over PQ by 11.4% in mean TTNS. These gains, while modest in absolute terms, arise from the EF-QuantumFuture overlap: by advancing specula-
SR
PQ
100 50 0
150
EFaaS
Mean TTNS (s)
Mean TTNS (s)
PF
SBQ
PF
SR
PQ
EFaaS
100 50 0
ESU2 RA TL ESU2 RA TL ESU2 RA TL ESU2 2q r1 2q r2 3q r1 3q r2 3q r3 4q r2 4q r3 4q r4 5q r3 5q r4
(a) Simple circuits (2–5 qubits)
SBQ
100 75 50 25 0
Mean TTNS (s)
SBQ
150
ESU2 RA TL ESU2 RA TL ESU2 RA TL ESU2 6q r2 6q r3 6q r3 7q r3 7q r4 8q r3 8q r4 9q r4 10q r4 10q r5
PF
SR
PQ
EFaaS
ESU2 RA TL ESU2 RA TL ESU2 RA TL ESU2 RA 10q r6 10q r6 11q r7 11q r7 12q r5 12q r6 13q r6 13q r7 14q r7 14q r8 16q r5
(b) Medium circuits (6–10 qubits)
(c) Complex circuits (10–16 qubits)
SBQ
PF
SR
PQ
EFaaS
20
SBQ
PF
SR
PQ
EFaaS
ESU2 RA TL ESU2 RA TL ESU2 RA TL ESU2 2q r1 2q r2 3q r1 3q r2 3q r3 4q r2 4q r3 4q r4 5q r3 5q r4
(a) Simple circuits (2–5 qubits)
PF
SR
PQ
EFaaS
20
10 0
SBQ
30
20
10 0
30
Quantum Duty Cycle (%)
30
Quantum Duty Cycle (%)
Quantum Duty Cycle (%)
Fig. 5: Mean Time-to-Next-Shot (TTNS) per circuit for all five scheduling modes across the (a) simple, (b) medium, and (c) complex circuit bands. EFaaS and SR/PQ maintain near-hardware-minimum latency, while SBQ and PF are dominated by highly variable queue delays.
10
ESU2 RA TL ESU2 RA TL ESU2 RA TL ESU2 6q r2 6q r3 6q r3 7q r3 7q r4 8q r3 8q r4 9q r4 10q r4 10q r5
0
ESU2 RA TL ESU2 RA TL ESU2 RA TL ESU2 RA 10q r6 10q r6 11q r7 11q r7 12q r5 12q r6 13q r6 13q r7 14q r7 14q r8 16q r5
(b) Medium circuits (6–10 qubits)
(c) Complex circuits (10–16 qubits)
Fig. 6: Quantum Duty Cycle (QDC) per circuit for all five modes across the (a) simple, (b) medium, and (c) complex bands. EFaaS achieves the highest QDC in every band, outperforming SBQ and PF by over 14 percentage points and exceeding SR and PQ by 1.7–2.9 pp through speculative classical execution.
800
Mode / Band SBQ EFaaS PF Simple SR Medium PQ Complex
600 400 200 0
0
500
1000
1500
Iterations Completed
2000
2500
EFaaS Conv. Time Reduc. (%)
satisfying the energy convergence threshold, is the user-facing performance metric that ultimately determines the practical utility of a hybrid quantum workflow. Fig. 7 reports convergence trajectories and the corresponding EFaaS speedup factor relative to each baseline. Convergence Time (s)
tive classical work concurrently with tqpu , EFaaS shrinks the CPU-block time the QPU must wait on, producing tighter iteration cadence. Crucially, unlike SR, EFaaS releases QPU leases between sessions, allowing other tenants to execute, and unlike PQ it maintains session-aware calibration caches that prevent the drift events observed in PQ (Section VI-A4). 2) Quantum Duty Cycle (QDC): The Quantum Duty Cycle quantifies the fraction of wall-clock simulation time in which a QPU is actively executing shots. High QDC implies minimal idle QPU time and directly correlates with overall system throughput. Figs. 6(a)–(c) report per-circuit QDC for all three complexity bands. EFaaS attains a mean QDC of 23.4%, compared to 9.3% for SBQ (+14.2 pp), 9.5% for PF (+13.9 pp), 21.2% for SR (+2.2 pp), and 21.7% for PQ (+1.7 pp). The QDC advantage over SBQ and PF is overwhelming: in both modes, QPUs spend the majority of wall-clock time idle in the queue while jobs wait, not executing. EFaaS eliminates this dead time through session-aware priority scheduling. The gap over SR is more subtle but mechanistically important. SR locks the QPU exclusively, yet its QDC still falls below EFaaS because every classical optimization step (tcpu ) forces the reserved QPU to idle. EFaaS avoids this via the EFQuantumFuture: speculative classical work overlaps with tqpu , so the QPU returns a new circuit sooner after completing each shot batch. This “overlap budget” translates directly into 2.2 pp of additional active QPU time per iteration cycle. Across the complete benchmark sweep, EFaaS achieves QDC gains of 2.02–15.78% points over the four baselines. The lower end of this range corresponds to SR and PQ, which already operate in a low-queue regime; the upper end to SBQ and PF, where queue dominance suppresses QPU utilization. 3) End-to-End Convergence Time: Convergence time, the wall-clock duration from job submission to the first iteration
100 0
vs SBQ vs PF vs SR vs PQ
100
0
200
400
Baseline Conv. Time (s)
600
Fig. 7: End-to-end convergence time and EFaaS speedup ratio relative to all four baselines. EFaaS converges in a mean of 22.9 s versus 213 s for SBQ and 320 s for PF, achieving speedups of 83.2%–98.3% across the benchmark suite.
The convergence advantage of EFaaS is decisive. Against SBQ (mean 213.1 s), EFaaS achieves an 89.3% convergence speedup against PF (mean 320.2 s), the speedup reaches 92.9%. The compounding effect is important: each TTNS saving of ≈ 44–51 s propagates into every iteration, so a 1000iteration VQE run that would require 12–89 hours under batchqueue architectures completes in minutes under EFaaS. SR achieves competitive per-iteration TTNS, yet EFaaS still converges faster for two reasons. First, SR’s QPU-lock model cannot overlap classical computation with QPU execution, so each iteration takes at least tcpu + tqpu wall-clock seconds. EFaaS reduces the effective per-iteration cost to max(tcpu − tasync , 0) + tqpu + tnet through the EF-QuantumFuture, shaving 0.8 s per iteration. Second, SR accumulates no calibration reserve during the classical phase, leaving it susceptible to marginal drift events at longer runs. Against PQ, EFaaS converges significantly faster because PQ still incurs drift penalties (89 events across the benchmark) that force costly recalibrations mid-trajectory, disrupting the optimizer’s gradi-
4
SBQ PF SR
Complex
PQ EFaaS
r6] 6 [ESU2 13qSBQ PF
Cum. Drift Events
Cum. Drift Events
Medium [TL 6q r3]
Cum. Drift Events
Simple
PQ 2.0 [ESU2 5q r4]SBQ PF EFaaS SR 1.5 1.0 0.5 0.0 0 500 1000 1500 2000 2500 3000
4
2 0
SR
PQ EFaaS
2
0
2000
4000
6000
8000
10000
0
0
2000
4000
6000
8000
10000
Simulated Time (s) Simulated Time (s) Simulated Time (s) Fig. 8: Cumulative drift penalty events over simulated time, stratified by complexity band. SBQ and PQ accumulate drift continuously as queue delays exceed τdrift = 300 s; EFaaS accumulates zero drift events across all 31 circuits.
ent landscape and requiring additional iterations. Across the full suite, convergence speedups range from 83.2% to 98.3%, always in favor of EFaaS. 4) Algorithmic Fidelity and Drift Penalties: Quantum drift is the physical degradation of QPU calibration data between successive circuit submissions. Every drift event forces either a full recalibration (+30 s per event) or an execution on stale calibration data, both of which corrupt the optimizer’s gradient signal. Figs. 8 and 9 characterize drift incidence across the benchmark, and Fig. 10 reports how drift exposure scales with circuit complexity.
Drift Penalty Events
SBQ PF
SR PQ
EFaaS Simple
Medium Complex
6 4 2 0
EFaaS Ideal Zone
0
5
10
15
Calibration Ratio (%)
20
Fig. 9: Calibration overhead (% of total iterations) versus drift penalty event count per mode. EFaaS occupies a unique operating point with near-zero drift penalties despite moderate scheduled calibration activity, showing that proactive TTL-aware cache renewal prevents reactive cold-start recalibrations.
Drift-free operation. EFaaS accumulates 1 drift event across the entire 219-run benchmark suite (a single outlier in one complex circuit at maximum simulation time), compared to 95 events for SBQ, 89 for PQ, 69 for PF, and 0 for SR. This near-zero drift count is not a statistical artifact; it is a structural guarantee of the Session Awareness Engine. By maintaining calibration data Cq in a TTL-bounded cache and ensuring ∆t < τdrift for every returning Hot Iterator shot, EFaaS makes drift penalties mechanistically impossible under normal operating conditions. Why SBQ and PF fail. With mean TTNS values of 48.4 s and 54.5 s respectively, both architectures frequently exceed the τdrift = 300 s threshold when they execute long iteration runs. Each time the cumulative inter-shot delay exceeds τdrift , the QPU undergoes a 30-second recalibration that is logged as a drift event and further delays the subsequent shot. Fig. 8 shows that drift events accumulate continuously and monotonically for SBQ and PF throughout the simulation, at a rate that grows with circuit complexity (see Fig. 10).
Why PQ fails despite warm dispatch. Pilot-Quantum reduces startup overhead but provides no session-aware calibration cache. Each classical optimization step releases the QPU context, allowing calibration data to age. Under the medium and complex circuit bands, where tcpu is longer, and the optimizer takes more gradient steps between shots, the cumulative inter-shot gap regularly exceeds τdrift , producing 89 total drift events. This explains why PQ’s convergence time (mean 61.6 s) is substantially worse than EFaaS (22.9 s) despite similar per-shot TTNS: drift-induced recalibrations insert tens of seconds of dead time into the middle of optimization trajectories, fragmenting gradient coherence. SR achieves zero drift at a prohibitive cost. By holding an exclusive QPU lock throughout the job, SR trivially prevents drift (0 events). However, this comes at significant resource efficiency costs: the QPU is idle during every tcpu window, the reservation blocks concurrent multi-tenant access, and SR QDC (21.2%) is 2.2 pp lower than EFaaS (23.4%). The EFaaS architecture achieves the same drift-free behavior through cooperative leasing rather than exclusive reservation, enabling efficient multi-tenant QPU sharing without sacrificing calibration integrity. Scaling behavior. Fig. 10 confirms that EFaaS’s advantages are durable as circuit complexity grows. TTNS remains at 3.5–4.0 s across the 2–16 qubit range, and QDC stays above 22%. For SBQ and PF, TTNS grows slightly as longer tqpu increases background contention, but the dominant cost remains the queue delay which EFaaS eliminates entirely regardless of qubit count. These results demonstrate that EFaaS is not merely beneficial for small test circuits. Its session-aware coscheduling architecture provides proportionally greater advantage as workloads scale toward industrially relevant circuit sizes. 5) Ablation Study: To isolate the contribution of each scheduling component, we conducted a controlled ablation across 20 independent runs per variant, selectively disabling one mechanism at a time while holding all other parameters at their full-EFaaS defaults. Table VI reports the five most discriminating configurations; variants omitted (loose drift window, combined α=β=0) showed effects fully explained by the individual component ablations. Three findings stand out. First, TTNS and QDC are structurally insensitive to all hyperparameter changes: every variant achieves ≈3.50 s TTNS and ≈24.8% QDC. This confirms that the latency and utilization gains of EFaaS are architectural guarantees of the session-aware priority mechanism, not arti-
Mean TTNS (s)
60 40
SBQ PF SR PQ EFaaS
25 QDC (%)
H
20 0
I
20 15 10 5
2
4
6
8 10 Number of Qubits
12
14
16
0
2
4
6
8 10 Number of Qubits
12
14
16
Fig. 10: TTNS and QDC as a function of qubit count. EFaaS maintains near-constant TTNS and QDC across all circuit sizes, while SBQ and PF latency grow unchecked, and SR/PQ efficiency degrades modestly with qubit count. TABLE VI: Ablation Study: Impact of Individual EFaaS Components (n = 20 runs each). ∆Conv. is the percentage increase in convergence time relative to Full EFaaS. Variant Full EFaaS No drift urgency (β=0) No fair-share (γ=0) No session boost (α=0) Tight drift window (τ /2)
TTNS (s) 3.50 3.50 3.50 3.50 3.50
QDC (%) 24.72 25.02 24.93 24.84 24.79
Conv. (s) 18.17 26.73 22.33 21.70 23.57
∆Conv. — +47.1% +22.9% +19.4% +29.7%
TABLE VII: Hyperparameter sensitivity analysis on benchmarks. Best value per metric is highlighted . Drift penalties are zero throughout. α 0 10 50 100 200
Swept value β γ τd (s) 0 0.1 60 1 0.5 150 5 1.0 300 10 2.0 600 20 5.0 900
Metrics (identical across sweeps) TTNS (s)↓ QDC (%)↑ Conv. (s)↓ 3.501 ± 0.171 24.78 ± 1.42 15.33 ± 2.18 3.494 ± 0.174 23.00 ± 1.51 15.69 ± 2.34 3.499 ± 0.170 23.41 ± 1.47 40.22 ± 1.61 3.499 ± 0.176 24.02 ± 1.39 27.93 ± 2.07 3.505 ± 0.169 24.26 ± 1.44 43.37 ± 1.12
Iters↑ 749 ± 3 751 ± 2 750 ± 3 750 ± 2 749 ± 3
facts of parameter tuning. Second, the drift-urgency weight β is the single most influential parameter for convergence time. Removing it increases convergence time by 47.1%, from 18.2 s to 26.7 s. β governs how aggressively the scheduler advances a returning Hot Iterator as its calibration window τdrift ages. Without this urgency signal, the scheduler occasionally allows marginally delayed resubmissions, resulting in suboptimal iteration cadence even when no formal drift violation occurs. Third, halving the drift threshold (τdrift /2) incurs a 29.7% convergence penalty by triggering unnecessary proactive recalibrations that briefly stall the iterative loop. This confirms that τdrift = 300 s is a wellcalibrated operating point: large enough to absorb realistic classical compute intervals without spurious recalibrations, small enough to prevent actual coherence degradation. Together, the ablation results validate that every component of the Dual-Resource Fair Queuing scheduler makes a measurable and non-redundant contribution to overall EFaaS performance. 6) Hyperparameter Sensitivity Analysis: Table VII reports a one-at-a-time sensitivity sweep over the four DRFQ hyperparameters: α (session-awareness), β (drift-urgency), γ (fairshare), and τdrift (calibration validity). Each parameter is varied across five levels with the others held at defaults. The five metric rows are numerically identical across all four parameter sweeps, providing strong empirical evidence of parameter insensitivity. The mechanism is architectural: TTNS
is determined by the EF-QuantumFuture overlap, enforced unconditionally by the middleware independent of scheduling weights, and QDC tracks TTNS via tqpu /TTNS. With a session cache hit rate of 99.87% on this 2-qubit circuit, α and β have no expired sessions to act on, and τdrift never triggers since TTNS ≈ 3.5 s lies well below the tightest threshold of 60 s. Variation across sweep points (TTNS ∆ < 0.32%, QDC 23.0– 24.8%) is attributable to differing random seeds: the withinrun σTTNS (0.169–0.176 s) is an order of magnitude larger than the between-parameter TTNS range (0.011 s). All 20 configurations record zero drift penalties, including τd = 60 s. These results validate the DRFQ weights as a safe, broadly applicable operating point: practitioners can deploy EFaaS without hyperparameter search. VII. C ONCLUSION We presented EFaaS, a serverless middleware that resolves the fundamental mismatch between iterative hybrid VQA loops and stateless batch-queue cloud infrastructure. By combining TTL-aware calibration caching, Dual-Resource Fair Queuing, and the EF-QuantumFuture speculative execution primitive, EFaaS jointly schedules QPU shots and classical optimizer calls as entangled resources. Across 31 benchmark circuits spanning 2–16 qubits, EFaaS reduces TTNS by 11.4%–94.3%, improves the Quantum Duty Cycle by 2.02–15.78 pp, and accelerates convergence by 83.2%–98.3% over four baselines, while accumulating essentially zero drift penalty events versus 95, 89, and 69 for SBQ, PQ, and PF, respectively. These results confirm that the scheduling layer is currently the dominant bottleneck for hybrid quantum workloads, and that calibration integrity and low latency are simultaneously achievable without exclusive QPU reservation. R EPRODUCIBILITY We have released the code and dataset in a public GitHub1 repository. ACKNOWLEDGMENT This work was supported in part by the NYUAD Center for Quantum and Topological Systems (CQTS), funded by Tamkeen under the NYUAD Research Institute grant CG008. 1 https://github.com/Anonymous0-0paper/EFaaS
R EFERENCES [1] Y. Kim, A. Eddins, S. Anand, K. X. Wei, E. Van Den Berg, S. Rosenblatt, H. Nayfeh, Y. Wu, M. Zaletel, K. Temme et al., “Evidence for the utility of quantum computing before fault tolerance,” Nature, vol. 618, no. 7965, pp. 500–505, 2023. [2] S. Galavani, A. Younesi, and M. Ansari, “Qiga: Quantum-inspired genetic algorithm for dynamic scheduling in mobile edge computing,” in 2025 29th International Computer Conference, Computer Society of Iran (CSICC), 2025, pp. 1–5. [3] M. Cerezo, A. Arrasmith, R. Babbush, S. C. Benjamin, S. Endo, K. Fujii, J. R. McClean, K. Mitarai, X. Yuan, L. Cincio et al., “Variational quantum algorithms,” Nature Reviews Physics, vol. 3, no. 9, pp. 625– 644, 2021. [4] R. U. Ramadhan, L. K. Permatahati, T. B. Prayitno, and Y. P. Sarwono, “Hardware-efficient ansatz variational quantum regression for molecular energy prediction,” ChemistrySelect, vol. 11, no. 5, p. e04473, 2026. [5] L. Gentini, A. Cuccoli, S. Pirandola, P. Verrucchi, and L. Banchi, “Noiseresilient variational hybrid quantum-classical optimization,” Physical Review A, vol. 102, no. 5, p. 052414, 2020. [6] G. Aleksandrowicz, T. Alexander et al., “Qiskit: An open-source framework for quantum computing,” Jan. 2019. [Online]. Available: https://doi.org/10.5281/zenodo.2562111 [7] J. P. Santos and R. Uzdin, “Drift-resilient mid-circuit measurement and state preparation error mitigation for dynamic circuits,” arXiv preprint arXiv:2506.11270, 2025. [8] T. Proctor, M. Revelle, E. Nielsen, K. Rudinger, D. Lobser, P. Maunz, R. Blume-Kohout, and K. Young, “Detecting and tracking drift in quantum information processors,” Nature communications, vol. 11, no. 1, p. 5396, 2020. [9] H. T. Nguyen, M. Usman, and R. Buyya, “Qfaas: A serverless functionas-a-service framework for quantum computing,” Future Generation Computer Systems, vol. 154, pp. 281–300, 2024. [10] A. Ghodsi, M. Zaharia, B. Hindman, A. Konwinski, S. Shenker, and I. Stoica, “Dominant resource fairness: Fair allocation of multiple resource types,” in Proceedings of the 8th USENIX Conference on Networked Systems Design and Implementation, ser. NSDI’11, 2011, pp. 323–336. [11] K. Bharti, A. Cervera-Lierta, T. H. Kyaw, T. Haug, S. Alperin-Lea, A. Anand, M. Degroote, H. Heimonen, J. S. Kottmann, T. Menke et al., “Noisy intermediate-scale quantum algorithms,” Reviews of Modern Physics, vol. 94, no. 1, p. 015004, 2022. [12] J. R. McClean, J. Romero, R. Babbush, and A. Aspuru-Guzik, “The theory of variational hybrid quantum-classical algorithms,” New Journal of Physics, vol. 18, no. 2, p. 023023, 2016. [13] J. Choi and J. Kim, “A tutorial on quantum approximate optimization algorithm (qaoa): Fundamentals and applications,” in 2019 international conference on information and communication technology convergence (ICTC). IEEE, 2019, pp. 138–142. [14] J. C. Spall, “Multivariate stochastic approximation using a simultaneous perturbation gradient approximation,” IEEE transactions on automatic control, vol. 37, no. 3, pp. 332–341, 2002. [15] M. J. Powell, “A direct search optimization method that models the objective and constraint functions by linear interpolation,” in Advances in optimization and numerical analysis. Springer, 1994, pp. 51–67. [16] A. Peruzzo, J. McClean, P. Shadbolt, M.-H. Yung, X.-Q. Zhou, P. J. Love, A. Aspuru-Guzik, and J. L. O’brien, “A variational eigenvalue solver on a photonic quantum processor,” Nature communications, vol. 5, no. 1, p. 4213, 2014. [17] E. Farhi, J. Goldstone, and S. Gutmann, “A quantum approximate optimization algorithm,” arXiv preprint arXiv:1411.4028, 2014. [18] K. Mitarai, M. Negoro, M. Kitagawa, and K. Fujii, “Quantum circuit learning,” Physical Review A, vol. 98, no. 3, p. 032309, 2018. [19] A. Kandala, A. Mezzacapo, K. Temme, M. Takita, M. Brink, J. M. Chow, and J. M. Gambetta, “Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets,” nature, vol. 549, no. 7671, pp. 242–246, 2017. [20] H. R. Grimsley, S. E. Economou, E. Barnes, and N. J. Mayhall, “An adaptive variational algorithm for exact molecular simulations on a quantum computer,” Nature communications, vol. 10, no. 1, p. 3007, 2019. [21] Qiskit Serverless Team, “Qiskit serverless: Hybrid quantum-classical workflows,” IBM Quantum Documentation and GitHub, 2024–
2025, available: https://quantum.cloud.ibm.com/docs/guides/serverless and https://github.com/Qiskit/qiskit-serverless. [22] Amazon Web Services, “Amazon braket hybrid jobs,” AWS Braket Developer Guide, 2021–2025, available: https://docs.aws.amazon.com/ braket/latest/developerguide/braket-jobs.html. [23] P. Mantha, F. J. Kiwit, N. Saurabh, S. Jha, and A. Luckow, “Pilotquantum: a middleware for quantum-hpc resource, workload and task management,” in 2025 IEEE 25th International Symposium on Cluster, Cloud and Internet Computing (CCGrid). IEEE, 2025, pp. 01–10. [24] I. Faro, I. Sitdikov, D. G. Valiñas, F. J. M. Fernandez, C. Codella, and J. Glick, “Middleware for quantum: An orchestration of hybrid quantumclassical systems,” in 2023 IEEE International Conference on Quantum Software (QSW). IEEE, 2023, pp. 1–8. [25] B. Weder, J. Barzen, M. Beisel, and F. Leymann, “Analysis and rewrite of quantum workflows: Improving the execution of hybrid quantum algorithms.” pp. 38–50, 2022. [26] S. Resch, A. Gutierrez, J. S. Huh, S. Bharadwaj, Y. Eckert, G. Loh, M. Oskin, and S. Tannu, “Accelerating variational quantum algorithms using circuit concurrency,” arXiv preprint arXiv:2109.01714, 2021. [27] P. Murali, J. M. Baker, A. Javadi-Abhari, F. T. Chong, and M. Martonosi, “Noise-adaptive compiler mappings for noisy intermediate-scale quantum computers,” in Proceedings of the twenty-fourth international conference on architectural support for programming languages and operating systems, 2019, pp. 1015–1029. [28] A. Paler, L. Sasu, A.-C. Florea, and R. Andonie, “Machine learning optimization of quantum circuit layouts,” ACM Transactions on Quantum Computing, vol. 4, no. 2, pp. 1–25, 2023. [29] G. S. Ravi, K. N. Smith, P. Gokhale, and F. T. Chong, “Quantum computing in the cloud: Analyzing job and machine characteristics,” in 2021 IEEE International Symposium on Workload Characterization (IISWC). IEEE, 2021, pp. 39–50. [30] E. Jonas, J. Schleier-Smith, V. Sreekanti, C.-C. Tsai, A. Khandelwal, Q. Pu, V. Shankar, J. Carreira, K. Krauth, N. Yadwadkar et al., “Cloud programming simplified: A berkeley view on serverless computing,” arXiv preprint arXiv:1902.03383, 2019. [31] M. Shahrad, R. Fonseca, I. Goiri, G. Chaudhry, P. Batum, J. Cooke, E. Laureano, C. Tresness, M. Russinovich, and R. Bianchini, “Serverless in the wild: Characterizing and optimizing the serverless workload at a large cloud provider,” in 2020 USENIX annual technical conference (USENIX ATC 20), 2020, pp. 205–218. [32] J. R. Gunasekaran, P. Thinakaran, N. C. Nachiappan, M. T. Kandemir, and C. R. Das, “Fifer: Tackling resource underutilization in the serverless era,” in Proceedings of the 21st International Middleware Conference, 2020, pp. 280–295. [33] Y. Shi, P. Gokhale, P. Murali, J. M. Baker, C. Duckering, Y. Ding, N. C. Brown, C. Chamberland, A. Javadi-Abhari, A. W. Cross, D. I. Schuster, K. R. Brown, M. Martonosi, and F. T. Chong, “Resourceefficient quantum computing by breaking abstractions,” Proceedings of the IEEE, vol. 108, no. 8, pp. 1353–1370, 2020. [34] Knative Authors, “Knative: Kubernetes-Based Platform to Deploy and Manage Modern Serverless Workloads,” https://knative.dev, 2023, accessed: 2026. [35] L. Wang, M. Li, Y. Zhang, T. Ristenpart, and M. Swift, “Peeking behind the curtains of serverless platforms,” in 2018 USENIX annual technical conference (USENIX ATC 18), 2018, pp. 133–146. [36] P.-M. Lin and A. Glikson, “Mitigating cold starts in serverless platforms: A pool-based approach,” arXiv preprint arXiv:1903.12221, 2019. [Online]. Available: https://arxiv.org/abs/1903.12221 [37] D. Du, T. Yu, Y. Xia, B. Zang, G. Yan, C. Qin, Q. Wu, and H. Chen, “Catalyzer: Sub-millisecond startup for serverless computing with initialization-less booting,” in Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems, ser. ASPLOS ’20. New York, NY, USA: Association for Computing Machinery, 2020, p. 467–481. [38] J. L. Hennessy and D. A. Patterson, Computer architecture: a quantitative approach. Elsevier, 2011. [39] J. Dean and L. A. Barroso, “The tail at scale,” Commun. ACM, vol. 56, no. 2, p. 74–80, Feb. 2013. [40] Y. Ding, P. Gokhale, S. F. Lin, R. Rines, T. Propson, and F. T. Chong, “Systematic crosstalk mitigation for superconducting qubits via frequency-aware compilation,” in 2020 53rd Annual IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE, Oct. 2020, p. 201–214. [Online]. Available: http://dx.doi.org/10.1109/ MICRO50266.2020.00028
[41] V. K. Vavilapalli, A. C. Murthy, C. Douglas, S. Agarwal, M. Konar, R. Evans, T. Graves, J. Lowe, H. Shah, S. Seth et al., “Apache hadoop yarn: Yet another resource negotiator,” in Proceedings of the 4th annual Symposium on Cloud Computing, 2013, pp. 1–16. [42] Kubernetes Authors, “Topology aware routing,” Kubernetes Documentation, 2023, https://kubernetes.io/docs/concepts/services-networking/ topology-aware-routing/.