Adaptive Candidate Scheduler

• Adaptive candidate scheduler is a cross-domain method that generates potential scheduling actions and selects among them based on real-time state and feedback.
• It integrates simulations, predictive modeling, and ensemble approaches to evaluate candidate actions under explicit objectives across diverse systems.
• Empirical results demonstrate significant improvements over static policies, with throughput gains up to 3.5× and enhanced responsiveness in various applications.

An adaptive candidate scheduler is, in the sense suggested by several scheduling systems published across planning, systems, and machine learning, a mechanism that maintains a set of candidate actions and adaptively selects among them online using current state, predicted outcomes, or observed feedback. The candidates may be planners, expert schedulers, machine partitions, subjob variants, queue assignments, forwarding thresholds, tensor-program schedules, or stopping points along a denoising trajectory. What unifies these designs is a move away from a static rule toward a closed loop in which alternatives are generated or enumerated, scored under an explicit objective, and then enacted through a runtime control path (Ma et al., 2018, Zhang et al., 21 Dec 2025, Wang et al., 7 Nov 2025, Sidik et al., 29 Jan 2026, Sun et al., 27 May 2026).

1. Scope, lineage, and recurring forms

The published record shows that the idea emerged in multiple communities under different names. In automated planning, a two-stage scheduler selects an initial planner from a portfolio $P=\{1,\dots,D\}$, runs it for $T/2$, and may switch at halftime using a conditional failure model (Ma et al., 2018). In heterogeneous runtime systems, schedulers choose among hardware configurations, leader-core/width pairs, or thread partitions by combining phase information with online performance estimates (Novaes et al., 2019, Chen et al., 2019, Abduljabbar et al., 2021). In operating systems and cluster managers, recent work replaces a single fixed policy with adaptive routing among expert schedulers or simulated policies (Wang et al., 7 Nov 2025, Zhang et al., 21 Dec 2025). Related constructions also appear in workflow submission control, tensor-program search, multi-device inference, O-RAN xApp coordination, LLM serving, and robot control (Souza et al., 2024, Zhang et al., 2022, Nikolaidis et al., 2024, Cinemre et al., 9 Apr 2025, Liu et al., 5 Aug 2025, Sun et al., 27 May 2026).

This suggests that “adaptive candidate scheduler” is best understood as a cross-domain pattern rather than a single named algorithm.

System	Candidate set	Online selection mechanism
GNN planner scheduler (Ma et al., 2018)	planners $P=\{1,\dots,D\}$	initial selection plus halftime switch
SchedTwin (Zhang et al., 21 Dec 2025)	policies $\{P_1,\dots,P_k\}$	parallel what-if simulation
ASA, Mixture-of-Schedulers (Wang et al., 7 Nov 2025)	expert schedulers	ensemble voting plus mapping table
ARMS (Abduljabbar et al., 2021)	partitions $R=[LR,W]$	minimize online cost
JASDA (Konopa et al., 16 Oct 2025)	feasible subjob variants	weighted interval scheduling
EWSJF (Sidik et al., 29 Jan 2026)	request queues and head-of-line requests	density-weighted scoring
SANTS (Sun et al., 27 May 2026)	stopping and progression choices on a noise trajectory	cumulative hazard threshold

2. Operational loop

A recurrent control loop begins with state acquisition. SchedTwin maintains $Q(t)$, the set of waiting jobs with arrival times, size, and user-estimated walltimes; $R(t)$, the vector of currently free or occupied nodes; and $E(t)$, the virtual event queue of predicted job completions. PBS hooks queuejob, runjob, and jobobit push real-time metadata into a Redis stream, and the twin classifies each event as arrival, start, or completion (Zhang et al., 21 Dec 2025). ASA collects normalized CPU, memory, disk, process, scheduling, and network metrics; the paper lists 30+ such metrics and uses them as the input to an ensemble of XGBoost, Random Forest, and SVM classifiers (Wang et al., 7 Nov 2025). MultiTASC++ collects per-device SLO satisfaction rates over rounds of duration $T$, and SANTS observes the video representation $z_t$ and current noise level $T/2$0 at each decision point (Nikolaidis et al., 2024, Sun et al., 27 May 2026).

The next step is candidate generation or enumeration. In some systems the candidate pool is fixed in advance. SchedTwin clones a CQSim-based simulator once per candidate policy $T/2$1, while ASA selects from a pre-configured mapping table of expert schedulers (Zhang et al., 21 Dec 2025, Wang et al., 7 Nov 2025). In others, candidates are created dynamically. JASDA receives an announced window $T/2$2, then each job enumerates feasible subjob variants $T/2$3 whose predicted RAM demand satisfies the probabilistic safety condition

$T/2$4

Silent jobs simply produce no bids (Konopa et al., 16 Oct 2025). EWSJF discovers contiguous prompt-length intervals by Refine-and-Prune, then may create a “bubble queue” when an arrival falls into a gap between existing queues (Sidik et al., 29 Jan 2026).

After candidate creation, the scheduler computes scores or estimates. This may be done by predictive simulation, learned classification, cost models, bandit-style weights, or RL value estimates. The action phase is explicit in several systems: SchedTwin invokes PBS’s qrun <jobid> for the selected jobs; ASA swaps schedulers through Linux’s sched_ext interface; the planning scheduler either continues $T/2$5 or aborts it and runs $T/2$6; MultiTASC++ pushes updated thresholds $T/2$7 back to devices; and SANTS either stops and emits an action chunk or advances further along the noise trajectory (Zhang et al., 21 Dec 2025, Wang et al., 7 Nov 2025, Ma et al., 2018, Nikolaidis et al., 2024, Sun et al., 27 May 2026).

Feedback closes the loop. SchedTwin corrects early or late finishes on completion events, ASA augments training data with switching overhead and later fine-tunes on live causal effects of switching, JASDA computes feature-level post-execution errors and a reliability coefficient $T/2$8, and SmartLLMs Scheduler retrains success and cost predictors from an inspected subset while also adapting the cache threshold $T/2$9 (Zhang et al., 21 Dec 2025, Wang et al., 7 Nov 2025, Konopa et al., 16 Oct 2025, Liu et al., 5 Aug 2025).

3. Decision rules and objective functions

The mathematical forms vary, but all of them formalize a choice among candidates. In SchedTwin, the default policy selector computes

$P=\{1,\dots,D\}$0

where $P=\{1,\dots,D\}$1, then selects

$P=\{1,\dots,D\}$2

The simulator then returns the first set of job-start events immediately after time $P=\{1,\dots,D\}$3 (Zhang et al., 21 Dec 2025).

In ASA, every classifier emits a probability vector $P=\{1,\dots,D\}$4. The runtime smoother aggregates the last $P=\{1,\dots,D\}$5 time-steps with exponential decay: $P=\{1,\dots,D\}$6 The voted class is mapped to an expert scheduler by a machine-specific table $P=\{1,\dots,D\}$7 that was calibrated offline to account for switching overhead (Wang et al., 7 Nov 2025).

The two-stage planning scheduler uses a different but closely related rule. It first chooses

$P=\{1,\dots,D\}$8

runs $P=\{1,\dots,D\}$9 for $\{P_1,\dots,P_k\}$0, and if unsolved computes $\{P_1,\dots,P_k\}$1. At halftime it switches only when

$\{P_1,\dots,P_k\}$2

This is an explicit candidate-comparison rule conditioned on partial execution evidence (Ma et al., 2018).

Candidate scoring also appears in resource-molding systems. ARMS defines

$\{P_1,\dots,P_k\}$3

for a task type $\{P_1,\dots,P_k\}$4, Software Topology Address $\{P_1,\dots,P_k\}$5, and partition $\{P_1,\dots,P_k\}$6, and chooses the partition minimizing this quantity (Abduljabbar et al., 2021). The PTT scheduler in XiTAO uses a related score $\{P_1,\dots,P_k\}$7 and updates each entry with a moving average

$\{P_1,\dots,P_k\}$8

after each execution (Chen et al., 2019).

Other adaptive schedulers expose different mathematical objects but retain the same candidate-selection structure. Adaptive Scheduling Algorithm for workflow queue-wait estimation maintains probabilities over candidate waits $\{P_1,\dots,P_k\}$9 and updates them by

$R=[LR,W]$0

a Hedge-style rule (Souza et al., 2024). ATS assigns task-sampling weights from query loss and support-query gradient similarity and trains its scheduler by a bi-level objective with a REINFORCE update on $R=[LR,W]$1 (Yao et al., 2021). SANTS accumulates hazard increments $R=[LR,W]$2, forms $R=[LR,W]$3 and $R=[LR,W]$4, then stops at test time when $R=[LR,W]$5 (Sun et al., 27 May 2026). EWSJF prioritizes the head-of-line request $R=[LR,W]$6 in queue $R=[LR,W]$7 using

$R=[LR,W]$8

and tunes its parameters by Bayesian meta-optimization (Sidik et al., 29 Jan 2026).

4. Integration paths and systems realizations

The implementation literature emphasizes that adaptive candidate selection is not merely an abstract optimizer; it is usually embedded into an existing control plane. SchedTwin is a “simulation-in-the-loop” digital twin for PBS-managed clusters. PBS events push to Redis within milliseconds, the synchronization and simulation phases execute within $R=[LR,W]$9 per scheduling cycle on a 32-node Docker cluster, and no modification to PBS core logic is required because enforcement uses only qrun (Zhang et al., 21 Dec 2025).

ASA is implemented around Linux’s sched_ext BPF-based extension. The Action module runs in user space and uses a netlink or ioctl call to unregister the current BPF scheduler and load the selected expert’s BPF object. To minimize oscillation it uses a cooldown interval, with a recommended minimum inter-switch period of $Q(t)$0. Reported overheads are CPU overhead $Q(t)$1 of one core, memory overhead $Q(t)$2, and decision latency average $Q(t)$3 with $Q(t)$4 (Wang et al., 7 Nov 2025).

Some systems place the adaptive scheduler above, rather than inside, the executor. EWSJF runs a strategic loop every $Q(t)$5 to update queue boundaries and meta-parameters, and a tactical loop every few ms to assign arrivals, compute $Q(t)$6, and build batches in $Q(t)$7 time with $Q(t)$8 (Sidik et al., 29 Jan 2026). MultiTASC++ updates forwarding thresholds once per round of duration $Q(t)$9 and can switch the heavy server model according to a threshold-based signal $R(t)$0 (Nikolaidis et al., 2024). SmartLLMs Scheduler routes cache misses to one of several LLMs using predicted performance-to-cost ratio $R(t)$1, then retrains the classifier and regressor periodically when $R(t)$2 (Liu et al., 5 Aug 2025).

Decentralized realizations are also represented. JASDA turns each announced execution window into a weighted interval scheduling instance over submitted variants. Its per-iteration time complexity is

$R(t)$3

and the message complexity is $R(t)$4 bids per job per round (Konopa et al., 16 Oct 2025). In O-RAN, the xApp conflict-mitigation scheduler observes RAN state and selects a binary activation vector $R(t)$5 over pre-trained xApps, optimized by an A2C actor-critic (Cinemre et al., 9 Apr 2025).

5. Empirical behavior across domains

The empirical literature reports repeated gains over static baselines, although the measured objective differs by domain. In automated planning, the two-stage adaptive scheduler increased coverage on the IPC-2018 test set from $R(t)$6 to $R(t)$7 for GCN and from $R(t)$8 to $R(t)$9 for GG-NN; across domain-preserving and random splits, GCN adaptive coverage reached $E(t)$0 and $E(t)$1, compared with $E(t)$2 and $E(t)$3 for the single-planner variant (Ma et al., 2018).

In heterogeneous runtime and HPC settings, the reported gains are often multiplicative. The XiTAO performance-based scheduler achieved up to $E(t)$4 higher throughput than homogeneous work stealing on Jetson TX2, with sequential-DAG speedups of $E(t)$5 for MatMul, $E(t)$6 for Sort, $E(t)$7 for Copy, and $E(t)$8 for Mixed (Chen et al., 2019). ARMS reports up to $E(t)$9 performance gain over prior locality-aware schemes and up to $T$0 fewer L2 misses in stencil and MatMul (Abduljabbar et al., 2021). Astro was faster than GTS in 6 of 8 benchmarks and energy-saving in 5 of 8, with maximum speedup $T$1 and maximum energy saving $T$2 (Novaes et al., 2019). For workflow submission control, ASA -- The Adaptive Scheduling Algorithm reported up to $T$3 reductions in average workflow queue waiting times and $T$4 reductions in makespan, while core-hour usage stayed within $T$5 of the minimal (Souza et al., 2024). SchedTwin achieved radar area $T$6, compared with $T$7 for WFP, $T$8 for SJF, and $T$9 for FCFS, corresponding to an $z_t$0 increase over WFP, while keeping overhead to a few seconds per cycle (Zhang et al., 21 Dec 2025).

In operating systems and online services, adaptive routing among candidates is reported to improve both responsiveness and throughput. ASA, Mixture-of-Schedulers outperformed Linux’s default EEVDF in $z_t$1 of $z_t$2 runs with mean improvement $z_t$3 and $z_t$4 CI $z_t$5; it picked the single best expert in $z_t$6 of cases and ranked in the top three in $z_t$7 of cases, with all win-rate differences against EEVDF significant at $z_t$8 across 1680 runs (Wang et al., 7 Nov 2025). EWSJF improved end-to-end throughput by over $z_t$9 and reduced average Time-To-First-Token for short requests by up to $T/2$00 compared to FCFS; in one $T/2$01-request mixed workload, throughput increased from $T/2$02 to $T/2$03 req/s and from $T/2$04 to $T/2$05 tok/s while average short-request TTFT decreased from $T/2$06 to $T/2$07 (Sidik et al., 29 Jan 2026). SmartLLMs Scheduler reported an average performance improvement of $T/2$08 and an average processing time reduction of $T/2$09 on log parsing and code generation (Liu et al., 5 Aug 2025).

In ML and control pipelines, adaptive candidate scheduling appears both in training and inference. ATS improved performance on miniImageNet and a drug discovery benchmark by up to $T/2$10 and $T/2$11, respectively, under noise and limited budgets (Yao et al., 2021). HARL improved tensor-operator performance by $T/2$12 and search speed by $T/2$13 over the state-of-the-art auto-scheduler (Zhang et al., 2022). MultiTASC++ maintained a satisfaction rate of $T/2$14 percentage points for $T/2$15 devices while throughput scaled to $T/2$16 sps at 100 devices and accuracy stayed near the full-cascade optimum $T/2$17 in the homogeneous Sony C5 plus InceptionV3 setting (Nikolaidis et al., 2024). SANTS reached $T/2$18 overall success on RoboTwin 2.0 with $T/2$19 latency, compared with $T/2$20 and $T/2$21 for full-denoising WAM, and on seven real-robot tasks achieved $T/2$22 mean success with $T/2$23 latency versus $T/2$24 and $T/2$25 (Sun et al., 27 May 2026). In O-RAN conflict mitigation, the extended A2C scheduler with four xApp candidates achieved $T/2$26 normalized throughput in high-load/high-mobility settings, while conflict rate fell from $T/2$27 in the uncoordinated case to $T/2$28, and Jain’s fairness index improved by $T/2$29 in mid-load regimes (Cinemre et al., 9 Apr 2025).

6. Limitations, misconceptions, and open directions

A common limitation is dependence on the fidelity of the underlying predictor or model. SchedTwin currently relies on user-estimated walltimes, and its model accuracy degrades if estimates are very poor; its simulator also assumes instantaneous scheduling and no failures (Zhang et al., 21 Dec 2025). JASDA depends on timely variant generation, calibrated policy weights $T/2$30, and reliable TRP/FMP estimation; the paper states that its clearing is locally optimal per window but globally myopic, and no formal competitive ratio is given (Konopa et al., 16 Oct 2025). SmartLLMs Scheduler requires periodic inspection and retraining to maintain predictor quality, while ATS explicitly addresses the fact that high-loss tasks may be genuinely useful or merely noisy (Liu et al., 5 Aug 2025, Yao et al., 2021).

Switching cost and stability are recurrent concerns. ASA introduces shadow schedulers, BPF preloading, and a cooldown interval to prevent oscillation, and recommends fallback to EEVDF if decision latency exceeds $T/2$31 or classifier confidence is low $T/2$32 (Wang et al., 7 Nov 2025). MultiTASC++ uses conservative threshold updates and multiplicative scaling to stabilize satisfaction-rate control under changing device participation (Nikolaidis et al., 2024). SANTS adds an explicit penalty on redundant video-state updates so that the scheduler is optimized for downstream action quality rather than intermediate video fidelity (Sun et al., 27 May 2026).

A frequent misconception is that adaptivity necessarily means training a single monolithic scheduler end to end. The literature does not support that generalization. Some systems are explicitly portfolio-based: the planning scheduler chooses among planners, ASA chooses among expert schedulers, SchedTwin chooses among simulated policies, and the O-RAN framework schedules pre-trained xApps “without requiring training xApps together or further xApp re-training” (Ma et al., 2018, Wang et al., 7 Nov 2025, Zhang et al., 21 Dec 2025, Cinemre et al., 9 Apr 2025). Others adapt over candidate resource shapes, queue partitions, or stopping depths rather than over whole schedulers (Abduljabbar et al., 2021, Sidik et al., 29 Jan 2026, Sun et al., 27 May 2026). This suggests that the defining property is not a specific learning architecture but the runtime comparison of multiple candidate actions under a state-dependent objective.

Open directions are stated explicitly in several papers. SchedTwin identifies multi-resource scheduling, fault-aware scheduling, elastic scaling, ML-based runtime predictors, and dynamic refinement of the policy pool (Zhang et al., 21 Dec 2025). ASA emphasizes rapid porting to new hardware by retraining only the mapping table $T/2$33 in Stage 3 (Wang et al., 7 Nov 2025). JASDA highlights richer window selection strategies and controlled information visibility for strategic workloads (Konopa et al., 16 Oct 2025). Across the literature, a plausible implication is that future adaptive candidate schedulers will continue to separate candidate generation, candidate evaluation, and enforcement, while pushing more of the uncertainty handling into online feedback and post-deployment calibration.