acceptodds
Under review as a conference paper at ICLR 2027

SchedulerFM: Reward-Free Pretraining for Generalizable Job-Shop Scheduling

Abstract

Recent studies using deep reinforcement learning (RL) for job-shop scheduling problems (JSSP) have largely relied on task-specific training, where separate policies are optimized for fixed scheduling objectives and settings. This limits reuse when the instance distribution, scale, objective, or scheduling setting changes. We propose SchedulerFM, a strategy foundation model for JSSP that decouples learning scheduling behavior from downstream optimization. SchedulerFM comprises two stages. First, reward-free RL pretraining learns a reusable latent strategy space by factorizing the long-horizon successor occupancies induced by diverse scheduling trajectories, without using a downstream scheduling reward. Second, latent-space test-time optimization freezes the pretrained model and searches over the strategy space, evaluating each candidate based on the downstream objective achieved by its complete rollout. A single JSSP-pretrained model transfers zero-shot across unseen distributions and scales, to flexible JSSP, and to previously unseen scheduling objectives, matching or outperforming strong learning and search baselines without additional training. More broadly, SchedulerFM opens a path toward reusable neural schedulers whose solution quality can scale with test-time compute without repeated task-specific retraining.

Primary area:
reinforcement learning
Keywords:
Reward-free RL pretraining, job shop scheduling, strategy foundation model, test-time scaling

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 4 reviews, above 85% of the others.
Reviewer_4FeMOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents SchedulerFM, a neural scheduling framework combining reward-free offline pretraining with test-time latent strategy search. Forward–backward representations learn a family of scheduling policies, and CMA-ES searches their latent space using complete schedule evaluations while keeping the model frozen. Experiments evaluate transfer across JSSP benchmarks, larger instances, flexible JSSP, and alternative scheduling objectives.

Critical strengths

S1. Separating scheduling representation learning from downstream optimization offers a useful approach to reusing learned policies across different scheduling requirements.

S2. The evaluation covers several dimensions of generalization using a single frozen checkpoint, providing encouraging evidence of transferable scheduling behavior.

S3. The optimizer comparisons and rollout-budget experiments demonstrate that adaptive latent search can improve solution quality without updating the pretrained model.

Critical weaknesses

W1. The current ablations do not isolate the contribution of reward-free FB pretraining from those of the architecture, training data, and test-time search.

W2. Makespan-based demonstration filtering and checkpoint selection leave the extent of the framework’s independence from a specific downstream objective unclear.

W3. The FJSSP experiments do not disentangle transferred scheduling knowledge from the contributions of the added machine-assignment rules and their joint optimization.

W4. The normalized successor-measure definition in Equation (1) is inconsistent with the discount factor γ = 1 in Table 5, leaving its connection to the implemented training objective unclear.

Questions for authors

Q1. Could you compare FB pretraining against reward-based RL and imitation learning under matched architecture, training data, and test-time search budgets? The existing replay-diversity and optimizer comparisons do not establish whether reward-free representation learning is responsible for the observed transfer benefits.

Q2. Appendices A.1–A.2 indicate that CP-SAT demonstrations are filtered by makespan improvement and checkpoints are selected using validation makespan; how sensitive are the transfer results to these choices? Please clarify the intended scope of “reward-free” and provide evidence from removing the CP-SAT demonstrations or using a checkpoint-selection criterion independent of makespan.

Q3. Appendix A.5 introduces five machine-assignment coefficients and initializes the joint search using eight handcrafted assignment rules; how much of the FJSSP performance comes from this additional machinery? Comparisons that fix the latent strategy while optimizing assignment coefficients, or combine standard dispatching rules with the same assignment search, would help isolate the contribution of the pretrained model.

Q4. For the finite scheduling episodes considered here, substituting γ = 1 into Equation (1) makes the successor measure zero because of the factor (1 − γ), whereas the training objective models nonzero future occupancy; is the implementation instead based on an unnormalized finite-horizon measure? Please reconcile Equation (1), the value relation in Equation (2), and the training targets, and clarify whether this discrepancy is purely notational.

4 comments
AuthorsOpenReview ↗

Response to Reviewer 4FeM [1/2]

We thank the reviewer for the constructive feedback. We provide the point-by-point response as follows.

W1 / Q1. Contribution of reward-free FB pretraining

Could you compare FB pretraining against reward-based RL and imitation learning under matched architecture, training data, and test-time search budgets? The existing replay-diversity and optimizer comparisons do not establish whether reward-free representation learning is responsible for the observed transfer benefits.

We compare FB pretraining with imitation learning and reward-based RL using the same graph backbone, logged transitions, and 512 complete-schedule evaluations per instance (cf. global response [G1]).

The closest control replaces FB with behavior cloning (BC) while retaining latent CMA-ES: FB achieves a JSSP gap of 8.01% vs 8.64% under BC for the submitted seed and 8.04 ± 0.24% vs 8.64 ± 0.11% under BC across four and three training seeds, respectively. Because this comparison fixes the backbone, data, and latent-search procedure, it directly tests the contribution of the pretraining objective.

The reward-based TD alternatives achieve 11.11% with four scheduling-cost rewards and reward-weight CMA-ES, and 17.28% with the L2D reward and rollout sampling. These provide additional comparisons under the same evaluation budget, although their adaptation spaces differ, as detailed in [G1].

Moreover, the advantage also extends to unseen objectives. we compare FB and BC on 58 instances, reporting gap (%) to one-hour CP-SAT with one evaluation seed (%, lower is better):

PretrainingMakespanFlow timeTardinessWeighted tardinessMax. tardiness
FB, reward-free (ours)4.454.6418.0838.2718.13
Behavior cloning4.814.9418.6143.7922.27

FB achieves a lower gap on every evaluated objective, with particularly clear improvements in weighted tardiness (38.27% vs 43.79%) and maximum tardiness (18.13% vs 22.27%). Unlike comparison with COMPASS alone, this FB-BC comparison controls the architecture, training data, and latent-search procedure. In summary, with the backbone, data, and search held fixed, FB learns a strategy family that achieves better scheduling performance and transfers more effectively across the evaluated objectives.


W2 / Q2. Makespan-filtered demonstrations, checkpoints, and “reward-free”

Appendices A.1–A.2 indicate that CP-SAT demonstrations are filtered by makespan improvement and checkpoints are selected using validation makespan; how sensitive are the transfer results to these choices? Please clarify the intended scope of “reward-free” and provide evidence from removing the CP-SAT demonstrations or using a checkpoint-selection criterion independent of makespan.

“Reward-free” describes the FB pretraining loss, which uses no downstream reward labels. It does not imply that demonstration or checkpoint selection excludes scheduling-quality information. We clarify this scope and test both makespan-dependent choices separately.

1. Removing makespan-filtered demonstrations. We retrain FB without CP-SAT demonstrations, retaining the architecture and 512-evaluation search budget. JSSP gaps are relative to best-known solutions on 170 instances (four/three training seeds, respectively); cross-objective gaps are relative to one-hour CP-SAT on 58 instances (one seed).

Replay dataJSSP gap (%)Flow timeTardinessWeighted tardinessMax. tardiness
Original, with CP-SAT demonstrations8.04 ± 0.244.6418.0838.2718.13
Without CP-SAT demonstrations8.03 ± 0.294.3116.0536.8719.99

Removing demonstrations preserves JSSP performance and improves three of four non-makespan objectives, although maximum tardiness worsens. Thus, the observed transfer does not require makespan-filtered demonstrations.

2. Removing makespan-based checkpoint selection. The submitted model uses the 12k checkpoint selected by validation makespan (cf. Appendix A.2). To assess sensitivity to this choice, we evaluate all saved checkpoints through the final 16k training step, without requiring checkpoint selection:

Training step2k4k6k8k10k12k (submitted)14k16k (last)
JSSP gap (%)8.638.198.288.208.058.017.817.95

Simply using the final checkpoint, without validation-based selection, achieves 7.95%, versus 8.01% for the submitted checkpoint. Every checkpoint from 4k onward lies within 7.81–8.28%, showing that JSSP performance is insensitive to the specific checkpoint selected.

In summary, transfer persists without makespan-filtered demonstrations, and strong JSSP performance persists without makespan-based checkpoint selection, supporting the robustness of the pretrained strategy family.

AuthorsOpenReview ↗

Response to Reviewer 4FeM [2/2]

W3 / Q3. FJSSP decomposition of scheduling and machine assignment

Appendix A.5 introduces five machine-assignment coefficients and initializes the joint search using eight handcrafted assignment rules; how much of the FJSSP performance comes from this additional machinery? Comparisons that fix the latent strategy while optimizing assignment coefficients, or combine standard dispatching rules with the same assignment search, would help isolate the contribution of the pretrained model.

We disentangle the contributions of pretrained scheduling strategies from machine-assignment search using both controls suggested by the reviewer: (1) fixing zz while searching machine assignment weights, and (2) replacing the network with handcrafted dispatching rules. We also evaluate the reverse control, searching zz with fixed machine assignment.

Results cover 210 FJSSP instances. All searched variants receive 512 complete-schedule evaluations. The machine-assignment search optimizes five weights initialized from eight handcrafted rules.

SchedulingMachine assignmentGap (%)
Pretrained policy, zz searched (ours)5 weights searched jointly with zz4.28
Pretrained policy, zz searchedFixed earliest-completion rule4.52
No network: searched mixture of 15 dispatching rules5 weights searched jointly4.55
Pretrained policy, zz fixed at shared makespan anchor5 weights searched7.95
No network: best of 15 fixed dispatching rulesBest of 8 fixed assignment rules8.60

Assignment search alone does not recover the full performance, and searching the pretrained scheduling strategy is indeed important:

  • With assignment weights optimized in both settings, searching zz reduces the gap from 7.95% to 4.28% relative to the fixed makespan anchor.

  • Joint assignment search provides a further 0.24-point improvement (4.52% → 4.28%).

  • A searched mixture of handcrafted dispatching rules is also competitive (4.55%), but SchedulerFM achieves the lowest gap (4.28%).

Summary: These controls show that FJSSP transfer benefits from searchable JSSP-pretrained scheduling strategies, beyond machine-assignment search alone, without FJSSP-specific network training.


W4 / Q4. Successor measure at γ=1\gamma=1

For the finite scheduling episodes considered here, substituting γ = 1 into Equation (1) makes the successor measure zero because of the factor (1 − γ), whereas the training objective models nonzero future occupancy; is the implementation instead based on an unnormalized finite-horizon measure? Please reconcile Equation (1), the value relation in Equation (2), and the training targets.

Thank you for pointing out this inconsistency. You are correct that, as written, the (1−γ)(1-\gamma) factor in Equation (1) makes the measure identically zero at our experimental setting γ=1\gamma=1. The intended object is the unnormalized episodic successor measure, consistent with the cumulative-return representation and training objectives already specified in the paper.

To make the definition consistent with the training objective, we correct Equation (1) to

Mπ(s,a,E):=Eπ[∑t=0H(s)−1γt1Xt∈E∣s0=s,a0=a]M^{\pi}(s,a,\mathcal{E}) := \mathbb{E}_{\pi}\left[\sum_{t=0}^{H(s)-1}\gamma^t\mathbf{1}\\{X_t\in\mathcal{E}\\}\mid s_0=s,a_0=a\right]

where H(s)H(s) denotes the number of remaining dispatch decisions, including the final dispatch. This accommodates different training-instance sizes: the remaining horizon is determined by the unscheduled operations already encoded in the state, and each action reduces it by one. No additional state variable or architectural change is required.

At γ=1\gamma=1, this measure has finite total mass, and its integration with a reward gives the usual undiscounted cumulative return:

Ex∼ρ[mπ(s,a,x)r(x)]=Eπ[∑t=0H(s)−1r(Xt)∣s0=s,a0=a]\mathbb{E}_{x\sim\rho}\left[m^\pi(s,a,x)r(x)\right]=\mathbb{E}_{\pi}\left[\sum_{t=0}^{H(s)-1}r(X_t)\mid s_0=s,a_0=a\right]

Thus, Equation (2) remains unchanged and supports the intended nonzero value representation without an additional scaling factor.

Crucially, the existing training equations already follow this unnormalized, episodic convention:

  • Equation (11) includes immediate occupancy without a (1−γ)(1-\gamma) multiplier.
  • Equation (15) masks the bootstrapped continuation at termination
  • Equation (18) uses an unscaled immediate reward with undiscounted continuation. The final dispatch’s immediate outcome remains included through the immediate-occupancy term.

The required revision is therefore limited to correcting Equation (1) and briefly explaining its finite, state-dependent horizon. It does not require changing the stated training objectives, FB factorization, or reward embedding. We appreciate the reviewer for catching this issue, and we have also made the definition consistent with the training formulation in the updated manuscript.

Revision: We have updated Equation (1) and its accompanying explanation in Lines 176–189

Thank you for the detailed responses and additional experiments. The controlled FB–BC comparison, demonstration and checkpoint analyses, and FJSSP decomposition substantially address my concerns about the contribution and reuse of the pretrained representation. The corrected episodic successor-measure definition also resolves my concern regarding γ = 1. While the gains over strong heuristic search remain modest and the computational trade-offs warrant careful qualification, the new evidence strengthens the paper sufficiently for me to raise my recommendation.

AuthorsOpenReview ↗

Thank You for Your Constructive Feedback

Dear Reviewer 4FeM,

Thank you for your thoughtful feedback and for raising your recommendation for our paper. We are excited that our additional experiments and clarifications substantially address your concerns regarding the contribution and reuse of the pretrained representation.

We sincerely appreciate the time and effort you have devoted to reviewing our work. Your constructive feedback has been invaluable in strengthening the paper.

Thank you again.

Reviewer_1GG6OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SchedulerFM combines reward-free forward–backward representation learning with latent-space optimization for job-shop scheduling. It pretrains a latent-conditioned scheduler on offline transitions and CMA-ES searches for latent strategies using the objective values of complete scheduling rollouts. Reported results are competitive with the evaluated learned baselines, and additional experiments examine replay diversity, search algorithms, and rollout budgets.

Critical strengths
  • The motivation is compelling, and the proposed separation is practically useful. Repeatedly training a scheduler for each objective or problem setting is costly. Learning a reusable strategy space and adapting it through schedule-level evaluation offers a coherent alternative.
  • The evaluation demonstrates meaningful breadth of reuse.
  • The search experiments provide evidence beyond simply increasing the number of samples. The compute-scaling experiments further show that additional inference-time search can improve results.
Critical weaknesses

-The successor-measure definition is inconsistent with the actual training setting. Equation (1) multiplies discounted occupancy by 1−γ1-\gamma, while Table 5 sets γ=1\gamma=1. For the finite scheduling episodes used here, the resulting measure is identically zero, which cannot support the intended nonzero value representation.

  • The quality–compute comparison is not sufficiently documented to assess practical efficiency. Figure 1 provides a coarse timing visualization, but the main comparisons use heterogeneous budgets: rollout counts, improvement steps, and a one-hour solver limit. These are not directly comparable computational units. SchedulerFM performs hundreds of complete rollouts, and on extreme-scale instances it additionally changes the encoder window and reduces the search budget. Strong conventional local-search baselines would also help establish whether the learned representation offers an advantage over direct schedule optimization under the same time budget.
  • Some headline gains are small, while each extreme-scale setting contains only five instances.
Questions for authors

Please refer to the weaknesses.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 1GG6 [1/2]

We thank the reviewer for the overall positive assessment and the constructive feedback. We provide the point-by-point response as follows.

W1. Definition of the successor measure

Thank you for pointing out this inconsistency. You are correct that, as written, the (1−γ)(1-\gamma) factor in Equation (1) makes the measure identically zero at our experimental setting γ=1\gamma=1. The intended object is the unnormalized episodic successor measure, consistent with the cumulative-return representation and training objectives already specified in the paper.

To make the definition consistent with the training objective, we correct Equation (1) to

Mπ(s,a,E):=Eπ[∑t=0H(s)−1γt1Xt∈E∣s0=s,a0=a],M^{\pi}(s,a,\mathcal{E}) := \mathbb{E}_{\pi}\left[\sum_{t=0}^{H(s)-1}\gamma^t\mathbf{1}\\{X_t\in\mathcal{E}\\}\mid s_0=s,a_0=a\right],

where H(s)H(s) denotes the number of remaining dispatch decisions, including the final dispatch. This accommodates different training-instance sizes: the remaining horizon is determined by the unscheduled operations already encoded in the state, and each action reduces it by one. No additional state variable or architectural change is required.

At γ=1\gamma=1, this measure has finite total mass, and its integration with a reward gives the usual undiscounted cumulative return:

Ex∼ρ[mπ(s,a,x)r(x)]=Eπ[∑t=0H(s)−1r(Xt)∣s0=s,a0=a].\mathbb{E}_{x\sim\rho}\left[m^{\pi}(s,a,x)r(x)\right]=\mathbb{E}_{\pi}\left[\sum_{t=0}^{H(s)-1}r(X_t)\mid s_0=s,a_0=a\right].

Thus, Equation (2) remains unchanged and supports the intended nonzero value representation without an additional scaling factor.

Crucially, the existing training equations already follow this unnormalized, episodic convention:

  • Equation (11) includes immediate occupancy without a (1−γ)(1-\gamma) multiplier.
  • Equation (15) masks the bootstrapped continuation at termination
  • Equation (18) uses an unscaled immediate reward with undiscounted continuation. The final dispatch’s immediate outcome remains included through the immediate-occupancy term.

The required revision is therefore limited to correcting Equation (1) and briefly explaining its finite, state-dependent horizon. It does not require changing the stated training objectives, FB factorization, or reward embedding. We appreciate the reviewer for catching this issue, and we have also made the definition consistent with the training formulation in the updated manuscript.

Revision: We have updated Equation (1) and its accompanying explanation in Lines 176–189


W2. Quality–compute, window size, and conventional local search

Wall-clock efficiency. Global response [G3] reports end-to-end inference time and quality by instance size. At matched wall-clock, both SchedulerFM variants have lower mean gaps than COMPASS and L2S-5000. SchedulerFM-S, which encodes each instance once, cuts amortized inference time 30× (42.7 → 1.40 s) at a small 0.30-point gap cost, and reaches 7.50% in 3.16 s with 3×512 evaluations. FB pretraining and latent search thus remain effective with much faster inference.

Extreme-scale evaluation. To bound memory and cost, we use an encoder window of 20 operations and 512 / 64 / 32 schedule evaluations for problems of sizes 100×100 / 100×1000 / 1000×100, respectively. We double each test set from 5 to 10 instances by adding the next five public instances in [1]. Mean gaps to best-known upper bounds are:

Method100×100100×10001000×100
CP-SAT (1 h)12.383.8822.12
L2S-50026.052.755.45
BOPO (greedy)13.5315.272.66
BOPO-51212.0512.961.62
SchedulerFM_{512/64/32}12.903.201.73
SchedulerFM-S_{512/64/32}13.083.202.21

On 100×1000, both variants clearly outperform BOPO-512 (3.20% vs. 12.96%). Across the three scales, SchedulerFM stays within 0.85 points of the best method (0.71 on the original five), while every other method trails the best by at least 9.76 points on some scale.

Encoder-window ablation. On the original five instances, window-20 versus full-graph encoding gives 12.90 vs 12.93, 3.30 vs 3.33, and 1.22 vs 1.99% under identical budgets. The window bounds graph size without worsening the gaps.

Conventional search. A public genetic algorithm (DEAP, one CPU core) given SchedulerFM's time budgets reaches 23.05% versus 8.01% (cf. [G3]).

Overall, SchedulerFM improves on COMPASS and L2S-5000 under matched wall-clock, runs 30× faster with an encode-once backbone, and with a reduced search budget remains within 0.85 points of the best method at every extreme scale.


[1] Giacomo Da Col and Erich C Teppan. Industrial-size job shop scheduling with constraint program-ming. Operations Research Perspectives, 9:100249, 2022

Revision: Table 2 now reports ten instances per shape; the encoder-window comparison and SchedulerFM-S results are provided in Appendix B.8.

AuthorsOpenReview ↗

Response to Reviewer 1GG6 [2/2]

W3. Small gains and limited extreme-scale sample size

To assess whether the reported improvement is consistent across instances and problem sizes, we compare SchedulerFM with BOPO-512, the strongest learned baseline on our main JSSP benchmark, using the same 512 complete-schedule evaluations on all 170 instances. This controls the evaluation budget rather than inference time; matched wall-clock comparisons are provided in the global response [G3].

Beyond the mean gap, we report size-specific gaps, per-instance wins, seed variation, and worst-case results against BOPO-512:

MeasureSchedulerFMBOPO-512
Mean gap, all 170 instances (%)8.01 (−8.6% relative)8.76
Mean gap, >225 operations (130 instances)8.94 (−12.9% relative)10.26
Mean gap, ≥400 operations (110 instances)8.95 (−15.0% relative)10.53
Per-instance win / tie / loss, all 17082 / 27 / 61—
Per-instance win / tie / loss, >225 operations76 / 15 / 39 (sign test, p < 0.001)—
Worst-case gap (%)19.725.9
Instances within 15% of best-known solution150131
Mean gap across seeds (%)8.04 ± 0.24 (4 training seeds)8.75 (4 sampling seeds)

The advantage grows with instance size. The relative gap reduction rises from 8.6% overall to 15.0% at ≥400 operations. On the 130 instances with >225 operations, SchedulerFM wins 76 and loses 39 (sign test, p < 0.001), so the gain is not driven by a few favorable instances.

  • The advantage extends beyond the mean. SchedulerFM has a lower worst-case gap (19.7% vs. 25.9%) and places 19 more instances within 15% of the best-known solution. Results are also consistent across four training seeds (8.04 ± 0.24%) and three test-time search seeds (all within 0.07 points of 8.01%).

Extreme-scale evaluation. We extend each configuration from five to ten instances by adding the next five public instances of Da Col & Teppan [1] (see W2 and Appendix B.8). The original and additional sets are reported separately, with their combined means (gap %, lower is better):

Instance sizeOriginal 5Additional 5All 10
100 × 10012.9012.8912.90
100 × 10003.303.103.20
1000 × 1001.222.231.73

In summary, the improvement over the strongest learned baseline is consistent across instances and seeds, grows with problem size (8.6% -> 15.0% relative gap reduction at >= 400 operations), and comes with better worst-case behavior (19.7% vs. 25.9%).


[1] Giacomo Da Col and Erich C Teppan. Industrial-size job shop scheduling with constraint program-ming. Operations Research Perspectives, 9:100249, 2022

Revision: Section 5.2 (Table 2), Appendix B.5 (training-seed variation), and Appendix B.8 (per-instance consistency over BOPO-512).

Thank you for the clarification and additional experiments, which resolve the successor-measure inconsistency and address my concerns about computational efficiency and empirical reliability. I maintain my recommendation.

Reviewer_i4G4OpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
2
Soundness
3
Read review
Paper summary

This paper introduces a reward-free RL approach for scheduling problems. The main focus is on training a common latent representation using reward-free RL on the JSP, which is then evaluated during inference using different reward functions and problem sizes, as well as extended in a zero-shot fashion to the significantly more complex FJSP. The authors demonstrate that their method generalizes well across all conducted experiments. Furthermore, the proposed approach outperforms the selected state-of-the-art baselines on nearly every evaluated dataset and experiment, highlighting its strong generalizability across all considered scenarios with varying ablation studies backing up this claim. Although minor additional experimental setups and tests could be conducted to further strengthen some of the authors' claims, this paper proposes a unique approach to handling generalizability in scheduling problems, an aspect that no prior work addresses in a similar fashion.

Critical strengths

The authors propose a reward-free RL framework for the JSP and its variants, which, to the best of our knowledge, has not yet been explored from a scheduling perspective.

The mathematical background regarding reward-free RL, along with the necessary adaptations to apply it directly to the JSP and FJSP, is presented clearly and is not too difficult to follow. Especially the training and inference pipelines, meaning how the model was trained and how the final inference is done, is explained very well and in great detail.

The authors show that their approach generalizes well to different problem sizes and objectives, outperforming state-of-the-art benchmark methods.

The detailed inference technique, ablation studies, and training time implementations further demonstrate the scalability of the proposed approach.

The authors mention that they plan to release their source code upon acceptance, which lifts reproducibility of these results.

Critical weaknesses

The primary weakness stems from the omission of inference runtime comparisons across the evaluated methods. None of the presented baselines include execution time or time complexity metrics. This is particularly critical because the benchmarks encompass methods with vastly different temporal complexities, ranging from lightweight dispatching rules to greedy/sampling constructive heuristics and local search/improvement approaches. A detailed runtime analysis is necessary to properly position the proposed approach relative to these baselines.

Another minor weakness relates to the selection of hyperparameters, which often appear to be chosen without clear justification. This is noticeable across several parameters, including the loss weights in Equation 19, the weighting factors in Table 7, and the replay buffer sizes. Although hyperparameters are frequently omitted from deep analysis in literature, and the authors dedicate sections in the Appendix to explaining their setup, brief ablation studies or additional rationale explaining these specific choices would strengthen the paper.

Questions for authors

The paper states that the event vector ete_t is used to track changes caused by the current state-action pair. Upon inspecting this vector, it is clear that while it does not track the exact reward formulations used later, it covers similar information to the evaluated reward functions (e.g., changes in makespan, machine idle time increments, job completion times). I wonder whether the generalizability across different reward functions still holds if a reward function is used that is not captured by this event vector. For instance, if the objective is to minimize total energy consumption, would this information need to be incorporated into both the observation space and the event vector? I encourage the authors to include ablation studies investigating this behaviour.

Table 7 in Appendix A.5 lists the coefficients appended to the latent variable zz to enable generalizability to the FJSP. However, it is unclear what these values represent and how they are fed into the model. Clarifying this aspect would make it easier to evaluate the model's generalizability to the FJSP and to other scheduling domain variants.

While the model demonstrates generalization to larger problem sizes, its robustness to out-of-distribution instances remains an open question. Specifically, can the model handle processing times drawn from a generator other than L2D (e.g., a Weibull distribution)? The same question applies to the FJSP instances, for instance, when machine flexibility is governed by a different underlying distribution. A natural question arises regarding how well this approach extends to multi-objective optimization, particularly when balancing weighted objectives. How would the method perform if the reward function is a weighted combination of objectives, and the underlying evaluation metric is maximizing the Pareto hypervolume? Can this framework be directly applied to such multi-objective problems? Why or why not?

Finally, one question is about the benchmark methods used in table 3. The current learning based benchmark is the improvement method “Learning Memory-Enhanced Improvement Heuristics for Flexible Job Shop Scheduling”, which the authors do not benchmark against. Why was this not compared against, while improvement methods were used as benchmark for the JSP? Does this have to do with performance or inference speed reasons, or was it simply not considered?

4 comments
AuthorsOpenReview ↗

Response to Reviewer i4G4 [1/3]

We thank the reviewer for the positive assessment and the insightful suggestions. We provide the point-by-point response as follows.

W1. Inference runtime

The primary weakness stems from the omission of inference runtime comparisons across the evaluated methods. None of the presented baselines include execution time or time complexity metrics. This is particularly critical because the benchmarks encompass methods with vastly different temporal complexities, ranging from lightweight dispatching rules to greedy/sampling constructive heuristics and local search/improvement approaches. A detailed runtime analysis is necessary to properly position the proposed approach relative to these baselines.

We report end-to-end inference time alongside solution quality, covering both JSSP and FJSSP. For JSSP, [G3] provides runtime breakdowns by instance size and matched wall-clock comparisons, constructive methods, sampling methods, and improvement-based solvers. All learned methods are evaluated on the same GPU. We also report SchedulerFM-S, which adopts a more efficient encoder–decoder architecture for a fairer runtime comparison with BOPO, reducing mean JSSP inference time from 42.7 s to 1.40 s at 512 evaluations.

For FJSSP, we compare mean end-to-end inference time and optimality gap (%) on the same 210 instances, including whether each method requires FJSSP-specific training:

MethodTime (s/instance)Gap (%)FJSSP-specific training
DANIEL, sampling-1001.126.46Yes (8 models)
ReSched, sampling-1001.697.35Yes (size-specific)
BOPO-5120.444.38Yes
SchedulerFM-5128.14.28No
SchedulerFM-S-5120.474.63No

Computational cost. Both SchedulerFM variants evaluate 512 complete schedules per instance. The original model re-encodes the residual graph at every dispatch decision, making a repeated graph encoding its main computational overhead. SchedulerFM-S instead encodes each instance once and decodes every step with a light per-step network.

The comparison clarifies the quality–time trade-off. SchedulerFM-S achieves inference time comparable to BOPO (0.47 vs. 0.44 s), with competitive solution quality (4.63% vs. 4.38% gap) and no FJSSP-specific neural training. The original SchedulerFM achieves the lowest mean gap among the evaluated learned methods (4.28%), at higher inference cost.


W2. Hyperparameter choices

Another minor weakness relates to the selection of hyperparameters, which often appear to be chosen without clear justification. This is noticeable across several parameters, including the loss weights in Equation 19, the weighting factors in Table 7, and the replay buffer sizes.

Thank you for the suggestion. We evaluate four replay-buffer variants and clarify how the coefficients in Table 7 and Eq. (19) are used.

  • Replay buffer. We retrain FB using fewer transitions, smaller training instances, or fewer dispatching rules. The following results report mean JSSP gap (%) over 170 instances, with the number of training seeds indicated:
Replay bufferTraining seedsGap (%)
Full, 1.33M transitions (submitted)48.04 ± 0.24
One quarter of the transitions18.33
Small instances only (≤15 × 10)38.07
4 of 16 dispatching rules18.14
1 of 16 dispatching rules18.16

The observed gaps remain within 0.29 percentage points of the full-buffer result, even when training data are substantially reduced or restricted. This suggests that performance is not highly sensitive to the evaluated replay-buffer configurations.

  • Table 7: Assignment coefficients. The eight coefficient sets represent predefined machine-assignment heuristics, not weights tuned to the evaluation instances. They provide initializations for FJSSP search; CMA-ES subsequently optimizes the five assignment weights per instance, jointly with the latent strategy zz.

  • Eq. (19): Loss weights. We use fixed coefficients λortho=λQ=1\lambda_{\mathrm{ortho}}=\lambda_Q=1 for the two auxiliary loss terms and a smaller λb=10−3\lambda_b=10^{-3} to downweight the baseline penalty. These are simple, fixed design choices rather than objective-specific tuned values. The same coefficients are also used to train SchedulerFM-S ([G3]) without retuning. These analyses show that performance remains stable across the tested replay-buffer configurations, that the same loss coefficients can be reused across architectures without retuning, and that CMA-ES automatically adapts the FJSSP assignment coefficients to each instance at test time.


Revision: Appendix A.3 (loss coefficients), Appendix A.5 (Table 7 and Equation (20)), and Appendix B.2 (replay-buffer diversity).

AuthorsOpenReview ↗

Response to Reviewer i4G4 [2/3]

Q1. Objectives beyond the event vector, including energy

The paper states that the event vector e_t is used to track changes caused by the current state-action pair. Upon inspecting this vector, it is clear that while it does not track the exact reward formulations used later, it covers similar information to the evaluated reward functions (e.g., changes in makespan, machine idle time increments, job completion times). I wonder whether the generalizability across different reward functions still holds if a reward function is used that is not captured by this event vector. For instance, if the objective is to minimize total energy consumption, would this information need to be incorporated into both the observation space and the event vector? I encourage the authors to include ablation studies investigating this behaviour.

Great question! For the objectives evaluated here, including total energy, no additional information needs to be added to either the observation space or the event vector. The event vector omits due dates, job weights, and machine power, which the corresponding objectives require. At test time, we use these quantities to score complete schedules under the downstream objective. Latent search uses those scores to select a strategy for each instance while keeping the pretrained SchedulerFM policy frozen.

To further investigate this behavior as suggested by the reviewer, we evaluate five such objectives on 58 instances, using 512 complete-schedule evaluations per instance. The results report mean per-instance improvements in objective value relative to the best of 22 dispatching rules selected separately for each instance:

ObjectiveInformation absent from the event vectorImprovement over best of 22 rules
Number of tardy jobsDue dates19.1%
Non-processing energyMachine power34.0%
Total tardinessDue dates16.7%
Weighted tardinessDue dates, job weights13.8%
Maximum tardinessDue dates17.9%

Energy directly addresses the reviewer’s example. Following the distinction between processing and non-processing energy in [1,2], we use a simplified model with machine-specific power levels and idle power set to 30% of processing power. In this JSSP setting, processing energy is constant across schedules, so minimizing total energy is equivalent to minimizing non-processing energy. SchedulerFM reduces non-processing energy by 34.0% and total energy by 1.9%. Machine power is used only to score complete schedules during latent search, so the same pretrained policy can be applied without adding it to either the observations or the event vector.

To directly assess the influence of objective-related event features, we retrain SchedulerFM without job completion time in the backward network's event input. The following results report gap (%) to one-hour CP-SAT on 58 instances, using one training seed and 512 schedule evaluations per instance (lower is better):

Event inputMakespanFlow timeTardinessWeighted tardinessMax. tardiness
Original4.454.6418.0838.2718.13
Without job completion time4.284.2917.1038.1318.12

Removing this feature preserves comparable performance across all five objectives, including flow time (4.29% vs. 4.64%). This provides direct evidence that cross-objective transfer does not depend on this particular handcrafted event feature.

These results highlight that the frozen policy can be reused for objectives requiring information absent from its event vector. At test time, latent search uses that information to score complete schedules under the downstream objective and select a strategy for each instance. This lets SchedulerFM adapt to the evaluated objectives without retraining or adding objective-specific model inputs.


[1] Y. Liu, H. Dong, N. Lohse, S. Petrovic, and N. Gindy. An investigation into minimising total energy consumption and total weighted tardiness in job shops. Journal of Cleaner Production, 65:87–96, 2014.

[2] Y. Liu, H. Dong, N. Lohse, and S. Petrovic. A multi-objective genetic algorithm for optimisation of energy consumption and shop floor production performance. International Journal of Production Economics, 179:259–272, 2016.


Revision: Appendix B.5 (Table 11), and Appendix B.8 (Table 15) report transfer to objectives outside the event vector and the event-feature ablation.

AuthorsOpenReview ↗

Response to Reviewer i4G4 [3/3]

Q2. Meaning of Table 7's coefficients

Table 7 in Appendix A.5 lists the coefficients appended to the latent variable z to enable generalizability to the FJSP. However, it is unclear what these values represent and how they are fed into the model. Clarifying this aspect would make it easier to evaluate the model's generalizability to the FJSP and to other scheduling domain variants.

Table 7 specifies eight handcrafted machine-assignment rules used to initialize test-time search, rather than coefficients learned by the neural network. Each rule scores candidate machines using five terms, including finish time, start time, processing time, remaining load, and a busy-machine indicator, weighted by β∈R5\beta\in\mathbb R^5.

CMA-ES jointly optimizes the 64-dimensional latent strategy zz and the five assignment weights β\beta (69 dimensions). The frozen JSSP policy operates on a JSSP-style graph constructed with provisional machine assignments; β\beta controls the separate machine-assignment mechanism and is not fed into the neural encoder. With a fixed earliest-completion assignment rule, searching zz achieves a 4.52% gap, versus 4.28% under joint search.

In short, the Table 7 coefficients parameterize a separate assignment heuristic and are never fed to the network; the frozen JSSP policy is reused unchanged, which is what makes the same recipe applicable to other scheduling variants.

Revision: Appendix A.5 (Table 7, Equation (20), and the joint-search description).


Q3. OOD processing times and machine flexibility

Can the model handle processing times drawn from a generator other than L2D (e.g., a Weibull distribution)? The same question applies to the FJSP instances.

To evaluate out-of-distribution processing times, we generate 210 JSSP instances across seven problem sizes, ten instances per size, and three processing-time distributions with matched means:

MethodUniform (training distribution)Weibull k=3k=3Weibull k=0.5k=0.5, heavy-tailed
SchedulerFM7.327.409.76
Best of 22 dispatching rules16.4714.6618.96

For FJSSP, Table 3 already spans the three Hurink regimes, which differ in machine flexibility (edata, rdata, vdata). The same frozen JSSP checkpoint obtains gaps of 5.85%, 6.02%, and 0.87% on them, respectively.

Across both unseen processing-time distributions, SchedulerFM roughly halves the gap of the best dispatching rule (7.40 vs. 14.66 and 9.76 vs. 18.96), as it does on the training distribution (7.32 vs. 16.47), and the same frozen checkpoint transfers across the three Hurink flexibility regimes without FJSSP training.

Revision: Appendix B.8 reports the out-of-distribution processing-time experiments.


Q4. Multi-objective optimization and Pareto hypervolume

How would the method perform if the reward function is a weighted combination of objectives, and the underlying evaluation metric is maximizing the Pareto hypervolume? Can this framework be directly applied to such multi-objective problems? Why or why not?

The current framework can directly optimize a weighted combination of scheduling objectives by using the resulting scalar fitness to evaluate complete schedules, without retraining the network.

Maximizing Pareto hypervolume requires a set of schedules that covers different trade-offs. A single CMA-ES run with fixed weights optimizes one trade-off. To approximate a Pareto front with the existing framework, we could run the search for multiple weight vectors, pool the resulting schedules, and compute the hypervolume of the nondominated set. To optimize hypervolume directly, one option would be to maintain a Pareto archive and guide the search by how much each candidate schedule increases the archive’s hypervolume. We consider this as a promising direction for future work, and we thank the reviewer for raising this question.


Q5. Memory-enhanced FJSSP improvement method

The current learning based benchmark is the improvement method “Learning Memory-Enhanced Improvement Heuristics for Flexible Job Shop Scheduling”. Why was this not compared against, while improvement methods were used as benchmark for the JSP? Does this have to do with performance or inference speed reasons, or was it simply not considered?

Thank you for highlighting this work (MIStar). Our FJSSP evaluation focuses on zero-shot transfer of JSSP-pretrained constructive scheduling strategies. We therefore prioritize DANIEL, ReSched, and BOPO, which, like SchedulerFM, construct complete schedules through neural policies. Evaluating them on the same 210 instances provides a focused comparison of solution quality and cross-setting model reuse. MIStar instead learns FJSSP-specific local improvements over completed schedules. Nonetheless, our results highlight the value of reusing JSSP-pretrained scheduling strategies for FJSSP without network retraining.

Thank you for the detailed response. The additional information addresses my concerns and strengthens the paper’s contribution further from my point of view. Overall, I maintain my recommendation towards acceptance.

Reviewer_ZQRJOpenReview ↗
Rating
2
Confidence
4
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

SchedulerFM is a neural-enhanced search-based framework for job shop scheduling that adapts a frozen policy to each instance by searching over latent strategies. The paper describes the method in enough detail to make clear how its components work together. However, the foundation model designation overstates what the experiments establish, and the choice of baselines and lack of matched runtime comparisons make it difficult to assess SchedulerFM’s advantage over established scheduling search methods.

Critical strengths

The paper presents a technically interesting neural-enhanced search framework for job shop scheduling. It evaluates the same frozen model across different instance sizes, distributions, and objectives, and also tests its transfer to FJSP. The method is described in enough detail to make it clear how the components fit together.

Critical weaknesses

Overclaim about the foundation model

The paper presents SchedulerFM as a foundation model and repeatedly emphasizes its generalization across instance sizes, distributions, scheduling settings, and even objectives. In practice, however, SchedulerFM is a search-driven solver augmented by a neural construction policy, with the downstream objective entering the search directly through evaluations of complete candidate schedules. This differs from conventional objective-specific neural construction or improvement methods in how the objective shapes the learned decisions. The neural policy can construct a schedule for a given zz, but it does not take the downstream objective as input. Adaptation to a new objective therefore relies on instance-specific search for a suitable zz. The cross-objective results demonstrate that the frozen policy can be reused within this search framework, but do not by themselves establish the broader model-level generality implied by the foundation model designation.

The claimed zero-shot transfer to FJSP relies on heuristic machine assignment and joint search, while the neural policy still operates on a JSSP-style input. In principle, the same approach could be applied to other compatible JSSP NCO methods, reusing their policies without retraining and using search to improve machine assignments for the downstream objective. The claim of zero-shot transfer across objectives warrants qualification. Although the new objectives are not directly optimized during pretraining, the representation and training data incorporate objective-related priors through handcrafted event features, such as job completion times, and makespan-optimized demonstrations.

Unfair experimental comparisons and ablations

Search-based Comparison: Search-based methods are among the strongest approaches for obtaining high quality solutions in combinatorial optimization, including job shop scheduling. They are therefore essential baselines for SchedulerFM, which is itself a search-driven solver augmented by a neural construction policy. Yet the evaluation focuses primarily on existing NCO methods and omits competitive scheduling metaheuristics such as HTSFP[1] for JSSP and 2SGA[2] for FJSP. The inclusion of CP-SAT does not fill this gap. Without comparisons against these methods under comparable time budgets, the experiments leave a central question unanswered: does the neural-enhanced solver find better schedules in the same time, or reach comparable solution quality faster than established search methods?

Time Comparison: Each candidate zz requires constructing and evaluating a complete schedule. On top of that, the solver runs a sequential, objective driven search: each round uses the previous round’s objective values to generate new candidates, each requiring another full rollout. This raises concerns about end-to-end solving time that rollout counts alone do not address. On standard hardware, construction[3] and improvement[4,5] NCO methods typically take roughly 0.1s to 10 minutes per instance, depending on instance size. For each instance size, the authors should compare SchedulerFM’s solution quality at wall-clock budgets on the same order of magnitude as the measured end-to-end runtimes of the corresponding NCO baselines.

Ablation: The paper examines replay-buffer diversity and compares search optimizers, but neither experiment isolates the contribution of reward-free FB pretraining. In particular, the CMA-ES comparison evaluates a search component already used in COMPASS[6] and does not explain why the learned representation transfers across objectives. Without ablations of the handcrafted objective-related features and makespan-optimized demonstrations, it remains unclear how much of the cross-objective gain is attributable to FB pretraining once these priors are accounted for. The comparison with COMPASS does not resolve this question, since it does not hold the representation design and training data fixed.

[1]. Combining Hash-Based Tabu Search and Frequent Pattern Mining for Job-Shop Scheduling. IISE Transactions, 2025.

[2]. An Efficient Two-Stage Genetic Algorithm for Flexible Job-Shop Scheduling. IFAC-PapersOnLine, 2019.

[3]. BOPO: Neural Combinatorial Optimization via Best-anchored and Objective-guided Preference Optimization. ICML, 2025.

[4]. Deep Reinforcement Learning Guided Improvement Heuristic for Job Shop Scheduling. ICLR, 2024.

[5]. Learning Topological Representations with Bidirectional Graph Attention Network for Solving Job Shop Scheduling Problem. UAI, 2024.

[6]. Combinatorial Optimization with Policy Adaptation Using Latent Space Search. NeurIPS, 2023.

Questions for authors

Please address the weaknesses above.

6 comments
AuthorsOpenReview ↗

Response to Reviewer ZQRJ [1/3]

We sincerely appreciate the reviewer for the detailed and constructive feedback. We clarify the exact scope of transfer and provide controlled evidence on the effectiveness of the learned representation and its computational cost.

W1. Foundation-model scope, objective transfer, and FJSSP

SchedulerFM is a search-driven solver augmented by a neural construction policy, with the downstream objective entering the search directly through evaluations of complete candidate schedules. [...] The neural policy can construct a schedule for a given (z), but it does not take the downstream objective as input. [...] The cross-objective results demonstrate that the frozen policy can be reused within this search framework, but do not by themselves establish the broader model-level generality implied by the foundation model designation. We’d like to clarify the intended scope of the strategy foundation model and the supporting evidence in three respects.

1. Scope of generalization and the contribution of FB pretraining. We thank the reviewer for raising this distinction, which correctly identifies that the downstream objective guides instance-specific latent search rather than entering the frozen network directly. We agree that the cross-objective results demonstrate reuse of a frozen policy within this search framework; they do not, by themselves, establish unrestricted model-level generality. We have revised the manuscript to qualify the “foundation model” terminology and state the demonstrated scope explicitly.

2. What transfers, and how adaptation works. SchedulerFM learns a latent-conditioned strategy family through reward-free pretraining. At test time, its parameters remain frozen while CMA-ES evaluates complete schedules under the downstream objective to select a latent strategy zz, thereby guiding construction decisions. Adaptation requires objective evaluations and test-time computation, but no objective-specific parameter training. Our contribution is reusing this pretrained family across the evaluated settings through latent-space adaptation. We do not claim that one forward pass solves a new objective or that the JSSP policy itself learns FJSSP machine assignment.

FB also supplies a structured connection between event rewards and latent strategies. Recall the reward-derived anchors as starting points of latent space search (cf. Section 4.4): For a linear event reward (r_w(o)=w^\top\phi(o)), Eq. (12) gives

zrw=Λw,Λ=Eo∼ρ[B(o)ϕ(o)⊤].z_{r_w}=\Lambda w,\qquad \Lambda=\mathbb{E}_{o\sim\rho}\left[B(o)\phi(o)^\top\right].

Our implementation uses four reward-derived anchors, corresponding to w=e1,…,e4w=e_1,\ldots,e_4, alongside randomly sampled latent strategies to initialize search. These anchors serve as reward-derived starting points, despite that they do not directly encode every downstream objective. CMA-ES subsequently evaluates schedules under the actual objective, including objectives outside the linear event-reward class.

3. Does reward-free pretraining contribute beyond the backbone, replay data, and test-time search? To examine this question, as shown in [G1], we compare four training objectives using the same graph backbone, logged transitions, and 512 complete-schedule evaluations per instance. Across 170 JSSP instances, the mean gaps are:

PretrainingTest-time adaptation (512 evaluations)Gap (%)
FB, reward-free (ours)CMA-ES over the latent strategy z8.01
Behavior cloningCMA-ES over the learned policy embeddings8.64
TD, 4 scheduling-cost rewardsCMA-ES over the 4 reward weights11.11
TD, L2D makespan reward1 greedy + 511 sampled rollouts17.28
  • Behavior cloning imitates each data source of the replay buffer with its own embedding on the same latent sphere. CMA-ES then searches that sphere, exactly as for FB.

  • TD on 4 scheduling-cost rewards learns values for any weighted sum of the four additive event costs of the paper: makespan increment, machine-idle increment, job completion time, and workload-spread change. CMA-ES searches the four weights.

  • TD on the L2D reward uses the standard dense reward of L2D, the decrease of the makespan lower bound. It has no task vector to search, so it samples complete schedules.

Taken together, the above controlled comparison supports the effectiveness of FB’s learned strategy family for downstream search, while the transfer experiments support reuse of the same frozen family across the tested sizes, distributions, scheduling settings, and objectives. These are complementary findings. We have revised the paper to describe this precisely as reward-free pretraining with objective-guided test-time latent search, and qualify broader foundation-model claims to match the evidence.


Revision: Abstract, Introduction (Section 1), Related Work (Section 2), and Conclusion (Section 6) clarify the scope of foundation-model and zero-shot claims.

AuthorsOpenReview ↗

Response to Reviewer ZQRJ [2/3]

W1. Foundation-model scope, objective transfer, and FJSSP (Cont.)

In principle, the same approach could be applied to other compatible JSSP NCO methods, [...] using search to improve machine assignments.

To test the suggestion that a fixed JSSP policy could transfer to FJSSP through machine-assignment search, we apply the same five-weight assignment heuristic to the released JSSP-trained BOPO policy, without FJSSP-specific training. All searched variants use 512 complete-schedule evaluations:

Scheduling policyMachine assignmentGap (%)
BOPO (JSSP-trained), greedyBest of 8 fixed assignment rules (cf. Table 7); no search9.83
BOPO (JSSP-trained), greedyCMA-ES over 5 assignment weights6.27
SchedulerFM (ours), zz searchedJoint CMA-ES over zz and 5 assignment weights4.28

Assignment search improves BOPO from 9.83% to 6.27%, confirming that a fixed JSSP policy can indeed benefit from this transfer mechanism. SchedulerFM achieves a lower gap (4.28%) by jointly searching its latent strategy zz and machine-assignment weights.

To quantify the contribution of each search component within SchedulerFM, we conduct the ablations:

SchedulerFM schedulingMachine assignmentGap (%)
zz fixed at the shared makespan anchorCMA-ES over 5 assignment weights7.95
zz searchedFixed earliest-completion rule4.52
zz searchedJoint CMA-ES over zz and 5 assignment weights4.28

With assignment weights optimized in both settings, searching zz reduces the gap from 7.95% to 4.28%, relative to the shared makespan anchor. With zz searched in both settings, jointly optimizing assignment weights further improves the gap from 4.52% to 4.28%.

These results establish the contribution of searching pretrained scheduling strategies beyond machine-assignment search alone. FJSSP transfer reuses the frozen JSSP-trained policy without FJSSP-specific model training, and the separate assignment heuristic is optimized at test time. Likewise, objective transfer requires no model updates, while the downstream objective guides test-time search.

Revision: Appendices A.5 and B.7 (Table 13) clarify the separate FJSSP machine-assignment mechanism and the contribution of latent-strategy search.


W2. Search-based comparison and end-to-end wall-clock comparison

We address both concerns through end-to-end wall-clock comparisons and additional conventional search baselines for JSSP and FJSSP.

  • JSSP: Wall-clock fairness and conventional search. [G3] reports solution quality and inference time by instance size, including matched wall-clock comparisons. SchedulerFM-S adopts a BOPO-style encode-once architecture and reaches 8.31% in 1.40 s, versus 8.01% in 42.7 s for the original model. Both variants retain lower mean gaps than COMPASS and L2S-5000 at matched wall-clock time. A public JSSP genetic algorithm (DEAP, TU/e benchmark repository, one CPU core) achieves 23.05%, compared with SchedulerFM’s 8.01%, under SchedulerFM’s time budgets.

  • FJSSP: Specialized metaheuristic comparison. We implement 2SGA [2], the specialized two-stage GA suggested by the reviewer, in C++ with the published settings. (As a sanity check, on the paper's 40 instances, our median makespan is within 0.2% of their reported results)

We compare it with learned methods under matched suite-level wall-clock budgets.

The results cover 210 FJSSP instances. Runtime is total suite wall-clock time divided by the number of instances; learned methods run on one GPU, and SchedulerFM-S solves the instances of a suite together. 2SGA runs on one CPU core. The last column is 2SGA's gap when stopped at each method's runtime (gap %, lower is better):

MethodFJSSP-specific neural trainingTime (s/inst.)Gap (%)2SGA at matched time (%)
DANIEL-100Yes (8 models)1.126.463.78
ReSched-100Yes (size-specific)1.697.353.72
BOPO-512Yes0.444.384.21
SchedulerFM-S-512No0.474.634.14
SchedulerFM-512No8.14.283.57
2SGA, full runNot applicable23.33.45—

SchedulerFM achieves the lowest gap among the evaluated learned FJSSP methods (4.28%) without FJSSP-specific neural training. With batched inference, SchedulerFM-S reaches 0.47 s per instance, close to BOPO's 0.44 s. The specialized 2SGA obtains better makespans at matched time, reflecting the strength of problem-specific search.

These experiments establish the scope of our contribution: competitive performance among learned schedulers, together with a reusable JSSP-pretrained strategy family that transfers to FJSSP and new objectives without network retraining.


Revision: Appendix B.6 (Table 12) and Appendix B.7 (Table 14) report JSSP and FJSSP runtime comparisons, including the GA and 2SGA search baselines.

AuthorsOpenReview ↗

Response to Reviewer ZQRJ [3/3]

W3. FB pretraining versus search and objective-related priors

Ablation: The paper examines replay-buffer diversity and compares search optimizers, but neither experiment isolates the contribution of reward-free FB pretraining. [...] Without ablations of the handcrafted objective-related features and makespan-optimized demonstrations, it remains unclear how much of the cross-objective gain is attributable to FB pretraining once these priors are accounted for. [...] The comparison with COMPASS does not resolve this question, since it does not hold the representation design and training data fixed. Thank you for the helpful suggestions. We address this with a controlled FB–behavior-cloning (BC) comparison and direct ablations of the two identified objective-related priors. All methods retain the same test-time budget of 512 complete-schedule evaluations.

1. Isolating the contribution of FB pretraining. Unlike the COMPASS comparison, the FB-BC comparison in the global response [G1] holds the graph backbone, logged data, and latent CMA-ES procedure fixed. FB achieves lower gaps on both JSSP makespan (8.01% vs. 8.64%) and unseen objectives: weighted tardiness (38.27% vs. 43.79%) and maximum tardiness (18.13% vs. 22.27%). This supports a contribution from FB’s training objective beyond the shared architecture, data, and search procedure.

2. Testing dependence on objective-related priors. We retrain FB after separately removing CP-SAT demonstrations and the job-completion-time event feature. We also pretrain exclusively on uniform-random dispatching trajectories, excluding both solver demonstrations and dispatching-rule data.

The table below reports JSSP gaps to best-known solutions on 170 instances, averaged over the listed training seeds. Cross-objective gaps are relative to one-hour CP-SAT on 58 instances, using seed 42 throughout (%, lower is better).

Pretraining variantTraining seedsJSSP gap (170)MakespanFlow timeTardinessWeighted tardinessMax. tardiness
Paper recipe (4 seeds; submitted model: seed 42)48.04 ± 0.244.454.6418.0838.2718.13
Without CP-SAT demonstrations38.03 ± 0.294.484.3116.0536.8719.99
Uniform-random dispatching only38.07 ± 0.114.474.5217.4637.0519.45
Without job-completion-time event feature18.024.284.2917.1038.1318.12
  • Makespan-optimized demonstrations are not required for the observed performance. Removing CP-SAT demonstrations preserves the mean JSSP gap (8.03% vs. 8.04%) and cross-objective transfer, improving three of four non-makespan objectives. Pretraining solely on uniform-random trajectories also achieves a similar JSSP gap (8.07%) and comparable cross-objective results.

  • The identified job-completion-time feature is likewise not necessary. Removing it from the backward network’s event input preserves performance across the evaluated objectives, including flow time (4.29% vs. 4.64%). Its JSSP gap is 8.02%, compared with 8.01% for the submitted model using the same training seed. This directly tests the feature identified by the reviewer; it does not imply that all handcrafted scheduling statistics are irrelevant.

Together, these experiments provide complementary evidence: FB outperforms BC under controlled data, backbone, and search conditions, while its performance is preserved when the identified priors are removed individually. They therefore support FB pretraining as a contributor to a reusable, searchable strategy family, beyond CMA-ES and the two specified priors.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response [1/2]

Dear Reviewers,

We thank the reviewers for their constructive feedback and insightful suggestions. We added controlled experiments and clarified the claims. Below we answer shared concerns, and reviewer-specific evidence follows.

Scope. SchedulerFM learns a reusable latent-conditioned scheduling policy family through an FB loss without downstream reward labels. At test time, its network is frozen and the requested objective guides instance-specific latent search through complete-schedule evaluations. Thus, zero-shot means no downstream parameter training—not no search. For FJSSP, machine assignment is handled by a handcrafted, parameterized heuristic with test-time-optimized weights. We have clarified this meaning of strategy foundation model in the paper.

[G1] Controlled pretraining comparison (ZQRJ, 4FeM).

To assess the contribution of FB pretraining, we compare SchedulerFM (ours) against three alternative training objectives using the same graph backbone, logged transitions, and 512 complete-schedule evaluations per instance (170 JSSP instances; mean gap %, lower is better):

PretrainingTest-time adaptation (512 evaluations)Gap (%)
FB, reward-free (ours)CMA-ES over the latent strategy z8.01
Behavior cloningCMA-ES over the learned policy embeddings8.64
TD, 4 scheduling-cost rewardsCMA-ES over the 4 reward weights11.11
TD, L2D makespan reward1 greedy + 511 sampled rollouts17.28
  • Behavior cloning imitates each data source of the replay buffer with its own embedding on the same latent sphere. CMA-ES then searches that sphere, exactly as for FB.

  • TD on 4 scheduling-cost rewards learns values for any weighted sum of the four additive event costs of the paper: makespan increment, machine-idle increment, job completion time, and workload-spread change. CMA-ES searches the four weights.

  • TD on the L2D reward uses the standard dense reward of L2D (Zhang et al., 2020), the decrease of the makespan lower bound. It has no task vector to search, so it samples complete schedules.

SchedulerFM achieves the lowest gap (8.01%), outperforming the closest latent-search control–behavior cloning (8.64%), as well as both reward-trained TD variants (11.11% and 17.28%). The comparison holds the backbone, replay data, and evaluation budget fixed; the TD controls use different test-time adaptation spaces.

Revision: Appendix B.5 (Tables 10–11) reports the controlled pretraining comparisons and objective-related prior ablations.


[G2] γ=1\gamma=1 correction and definition consistency of successor measure (4FeM, 1GG6).

We thank the reviewers for identifying the issue with the (1−γ)(1-\gamma) factor in Equation (1). To address this, we have corrected Equation (1) to define the intended unnormalized episodic successor measure. Specifically:

Mπ(s,a,E):=Eπ[∑t=0H(s)−1γt1Xt∈E∣s0=s,a0=a]M^{\pi}(s,a,\mathcal{E}) := \mathbb{E}_{\pi}\left[\sum_{t=0}^{H(s)-1}\gamma^t \mathbf{1}\\{X_t \in \mathcal{E}\\}\mid s_0=s,a_0=a\right]

where H(s)H(s) is the number of remaining dispatch decisions, including the final dispatch. This horizon is already determined by the scheduling state and accommodates different instance sizes without the need for adding a state variable.

Notably, at γ=1\gamma=1, the measure has finite total mass, and integrating a reward with it yields the usual undiscounted cumulative-return Q-function, and Equation (2) therefore remains unchanged.

This is only a localized correction to the definition in Equation (1): Note that the existing training objectives (cf. Equations (11), (15), and (18)) already use unnormalized immediate terms and terminal-masked continuation. Therefore, no changes to the training objectives, architecture, FB factorization, or reward embedding are required.

Revision: Equation (1) and its accompanying explanation in Lines 176–178 and Lines 188-189.

AuthorsOpenReview ↗

General Response [2/2]

[G3] Wall-clock comparison (ZQRJ, 1GG6, i4G4).

We evaluate end-to-end inference time and solution quality on the 170 JSSP instances (as used in Table 1), with multiple competitive neural methods running on the same RTX 5070 Ti. We report both matched schedule-evaluation budgets and matched wall-clock comparisons.

Note that the proposed SchedulerFM is an architecture-agnostic method that can be integrated with any GNN architecture for encoding the graphs induced by JSSPs. To make the comparison with fast NCO baselines more meaningful, we evaluate two implementations:

  • SchedulerFM (original): The submitted model re-encodes the residual graph at every scheduling decision.

  • SchedulerFM-S: To reduce architectural differences in the runtime comparison with BOPO, we leverage its encode-once design: the same GAT encodes each instance once, and a per-step network decodes every step. This separately trained variant retains the same reward-free FB objective, replay data, and latent CMA-ES search.

We first report mean optimality gap (%) and end-to-end runtime (seconds, in parentheses) across instance sizes. To broaden the comparison beyond neural solvers, we additionally evaluate a conventional genetic algorithm (GA) from the TU/e JSSP benchmark [1], implemented using DEAP. GA uses one CPU core with size-group time limits matched to the original SchedulerFM; CP-SAT uses seven CPU threads with a one-hour limit:

Method≤150 ops200–300400–600750–10002000All
L2S-5002.35 (0.92)16.37 (1.34)23.89 (1.55)22.39 (2.48)7.69 (7.1)17.78 (2.0)
L2S-50001.69 (8.9)10.67 (12.9)17.96 (15.0)16.28 (24.9)2.40 (70.9)12.66 (19.9)
COMPASS-16002.80 (10.4)12.06 (37.2)15.17 (170)13.70 (344)4.27 (912)11.64 (214)
BOPO-5121.77 (0.09)8.16 (0.24)12.01 (0.49)10.87 (0.86)1.44 (2.39)8.76 (0.60)
SchedulerFM-5122.89 (3.5)8.74 (10.1)10.64 (25.2)8.82 (63.6)1.06 (238)8.01 (42.7)
SchedulerFM-S-5122.64 (0.37)9.39 (0.60)10.96 (1.18)9.28 (1.62)0.60 (6.81)8.31 (1.40)
SchedulerFM-S-3×5122.43 (0.50)8.24 (0.91)9.92 (2.12)8.46 (4.12)0.65 (18.0)7.50 (3.16)
CP-SAT 1 h, non-delay (7 CPU threads)1.04 (157)6.26 (2335)15.47 (3203)15.00 (3400)5.50 (3605)10.73 (2658)
CP-SAT 1 h, unrestricted (7 CPU threads)0.00 (5)0.75 (1961)2.72 (2719)2.99 (2311)0.00 (952)1.83 (1940)
GA (DEAP, 1 CPU core)6.87 (3.5)23.92 (10.1)28.50 (25.2)27.17 (63.6)12.69 (238)23.05 (42.7)

Quality–compute trade-off. SchedulerFM achieves the lowest gap among evaluated learned JSSP methods (8.01%) and beats the time-matched GA (23.05%). Retaining FB and latent CMA-ES, SchedulerFM-S is 30× faster for a 0.30-point gap increase; further search reaches 7.50% in 3.16 s. The reusable strategy framework thus remains competitive with a faster architecture.

Matched wall-clock comparison. Cutoffs use baseline mean runtimes by benchmark family and shape (COMPASS-160: one tenth of COMPASS-1600). SchedulerFM uses its last completed batch, with times estimated from measured 512-evaluation runtimes. SchedulerFM-S completes 512 evaluations within every cutoff (amortized). Parentheses show median cutoffs:

Baseline (median time)Baseline gap (%)SchedulerFM gap (%)SchedulerFM-S gap (%)
COMPASS-1600 (141.6 s)11.648.018.31
COMPASS-160 (14.2 s)15.129.448.31
L2S-5000 (16.3 s)12.669.108.31

Both variants outperform COMPASS and L2S-5000 at matched time. At the tighter COMPASS-160 budget, SchedulerFM-S also beats the original (8.31% vs. 9.44%).

Near-matched BOPO runtime. BOPO-512 finishes before SchedulerFM's first batch, so we compare BOPO-2048 (1.34 s) with SchedulerFM-S-512 (1.40 s). BOPO times individual instances; SchedulerFM-S reports same-shape batch-amortized time. Entries show gap (%) and time (s):

OperationsnBOPO-2048 (2,048 schedules)SchedulerFM-S-512 (512 schedules)
≤150251.39 (0.16)2.64 (0.37)
200–300357.57 (0.46)9.39 (0.60)
400–6005011.33 (1.01)10.96 (1.18)
750–10005010.36 (1.90)9.28 (1.62)
2000101.04 (6.21)0.60 (6.81)
All1708.20 (1.34)8.31 (1.40)

With 4× fewer evaluations, SchedulerFM-S achieves lower gaps at ≥400 operations (110/170 instances); BOPO leads overall and in single-instance latency.


[1] Reijnen et al., “Job shop scheduling benchmark: Environments and instances for learning and non-learning methods,” Annals of Mathematics and Artificial Intelligence, 2026.

Revision: Appendix B.6 reports end-to-end runtime, the encode-once variant, and the matched-time comparison.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.