- Rating
- 2
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
The paper proposes MSLPM, a constructive scheduling framework for PFSP, JSSP, and FJSP that combines multi-step decision-making with a latent world model. By learning to propagate scheduling representations, it reduces repeated exact-state encoding and achieves substantial inference speedups while retaining competitive solution quality. This conceptual connection is appealing, but the current experiments do not sufficiently isolate the benefits of learned latent updates over simpler representation reuse. The evaluation is also limited in baseline coverage, problem scope, and decoding strategies. Furthermore, the sources of the runtime gains and the reproducibility of the horizon-dependent quality improvements remain insufficiently analyzed, leaving the method’s incremental contribution unclear.
Critical strengths
This work presents a strong and general constructive approach applicable to PFSP, JSSP, and FJSP. It cleverly combines multi-step decision-making with latent world modeling, substantially accelerating solution construction.
Critical weaknesses
The paper attributes its inference speedup to replacing repeated exact-state re-encoding with learned latent transitions. However, MACSIM [5] already constructs a joint assignment through multiple steps that reuse the same logits, without intermediate re-encoding or learned latent updates. This demonstrates a simpler way to reduce inference cost and raises a central question: what does the additional world model contribute beyond direct representation reuse? The comparison between H = 1 and H > 1 does not answer this question, because it changes both the re-encoding frequency and the use of Dynamics. Likewise, removing the latent alignment, decision consistency, and one-step anchor losses only evaluates how Dynamics is trained; it does not establish the value of updating latent representations in the first place. A necessary control is to keep the root embeddings fixed, update the exact feasibility mask, and rerun the Actor at each step under the same horizon and re-encoding schedule. Without this comparison, the current experiments do not justify the additional world-model complexity over simple representation reuse in terms of the quality–runtime trade-off.
Despite its broad framing around “combinatorial scheduling,” the experimental evaluation of MSLPM is incomplete in both baseline coverage and problem scope. Relevant recent methods, including BOPO[4] for JSSP and MACSIM[5] for FJSP, are missing from the comparisons. Moreover, FFSP, which is evaluated in ReSched[2] and MACSIM[5], is not considered, leaving the broader applicability of the framework insufficiently assessed. Although the authors explicitly adopt greedy strategy across neural methods to avoid introducing unequal sampling budgets, the evaluation remains limited to this setting and does not examine sampling decoding strategy, a common strategy for constructive solvers[1,2,3,4,5]. In addition, the sources of the reported runtime gains are not clearly disentangled. It remains unclear how much of the acceleration comes from replacing Encoder forward passes with Dynamics and how much comes from changes in state construction costs. A runtime breakdown separating Encoder/Dynamics network forward pass time from state-construction time would help clarify the efficiency benefits.
Much of MSLPM’s advantage in solution quality over the compared baselines is already achieved by the Encoder and Actor trained in Stage 1. However, the effect of latent planning on solution quality remains insufficiently analyzed. In particular, FJSP solution quality varies nonmonotonically with the planning horizon: H = 3 performs worse than H = 1, whereas H = 5 outperforms both. This warrants further explanation given that Stage 2 trains Dynamics to reproduce the frozen Encoder’s representations and the corresponding Actor decisions. Exact reproduction would yield the same decisions and solution quality as direct Encoder–Actor decoding, yet Dynamics based rollouts sometimes produce better solutions. The paper does not adequately explain the source of these improvements or establish their reproducibility. Results across multiple independent training seeds, with means and standard deviations, are needed to establish the reproducibility of the reported quality differences and the robustness of the balance between solution quality and runtime.
[1]. Flexible Job Shop Scheduling via Dual Attention Network-Based Reinforcement Learning. IEEE Transactions on Neural Networks and Learning Systems, 2024.
[2]. RESCHED: Rethinking Flexible Job Shop Scheduling from a Transformer-based Architecture with Simplified States. International Conference on Learning Representations, 2026.
[3]. Self-Labeling the Job Shop Scheduling Problem. Advances in Neural Information Processing Systems, 2024.
[4]. BOPO: Neural Combinatorial Optimization via Best-anchored and Objective-guided Preference Optimization. International Conference on Machine Learning, 2025.
[5]. Multi-Action Self-Improvement for Neural Combinatorial Optimization. International Conference on Learning Representations, 2026.
[6]. Matrix Encoding Networks for Neural Combinatorial Optimization. Advances in Neural Information Processing Systems, 2021.
Questions for authors
- How does MSLPM compare with a simpler version that directly reuses embeddings without learned latent updates?
- The baseline coverage is insufficient. Can the authors include additional recent methods, such as BOPO for JSSP and MACSIM for FJSP?
- Can the authors separately report network forward pass time and state construction time to clarify the sources of acceleration?
- While acknowledging the consistent use of greedy decoding, how does MSLPM perform with sampling?
- Are the results reproducible across multiple training seeds? Please report means and standard deviations for different H values.
- Can the authors provide results on FFSP?
- Given that Stage 2 trains Dynamics to imitate the original policy, what explains the improvements over H = 1 in some settings?
- What explains the nonmonotonic relationship between H and solution quality?
5 comments
W3: Network and state-construction costs need separate timing.
A3: Thank you for asking where the speedup comes from. On FJSP, the Encoder time saved exceeds the added Dynamics and gate time. Table R1 summarizes Encoder calls, Encoder time, Dynamics and LRG costs, and total time for and Auto; Appendix E provides the full breakdown. From to Auto, Encoder time falls from 2565.61 to 522.19 ms on PFSP, 1996.62 to 486.19 ms on JSSP, and 152.66 to 38.64 ms on FJSP (Appendix E).
On FJSP, mean Encoder calls fall from 149.34 to 49.18 per case. Auto spends 27.84 ms in Dynamics and 1.91 ms in the gate, with 70.00 ms end to end compared with 200.00 ms at . Together, Auto's Encoder, Dynamics, and gate take less time than the Encoder alone at . In Appendix E, Other is the end-to-end total minus the listed module times and aggregates the remaining unitemized runtime. The end-to-end timing scope is specified in Appendix D.5; state construction is included in the total and has no separate component measurement.
On FFSP, mean Encoder calls decrease from 60.00 to 56.40 per instance, and Encoder time falls from 66.10 to 31.70 ms. Auto spends 7.58 ms in Dynamics and 4.24 ms in LRG. The 34.40 ms saved in Encoder time exceeds the combined 11.82 ms cost of Dynamics and LRG, while total time falls from 69.34 to 46.44 ms, an approximately 33.0% reduction (Table R1). These FFSP times measure amortized per-instance throughput under the batched GPU protocol in Appendix D.5; fixed-horizon and Auto evaluation use local per-rank batch sizes 128 and 64, respectively. The reduction therefore describes the evaluated execution configurations.
Table R1: Runtime summary for and Auto. Calls are mean Encoder calls; all times are ms per instance. FFSP uses amortized batched timing (Appendix D.5). Appendix E reports all horizons, remaining components, and percentages.
| Task | Horizon | Calls | Encoder | Dynamics | LRG | Total |
|---|---|---|---|---|---|---|
| PFSP | 693.75 | 2565.61 | – | – | 4110.00 | |
| PFSP | Auto | 91.01 | 522.19 | 84.56 | 11.47 | 690.00 |
| JSSP | 561.25 | 1996.62 | – | – | 2940.00 | |
| JSSP | Auto | 142.03 | 486.19 | 476.92 | 76.59 | 1240.00 |
| FJSP | 149.34 | 152.66 | – | – | 200.00 | |
| FJSP | Auto | 49.18 | 38.64 | 27.84 | 1.91 | 70.00 |
| FFSP | 60.00 | 66.10 | – | – | 69.34 | |
| FFSP | Auto | 56.40 | 31.70 | 7.58 | 4.24 | 46.44 |
Q1: How does best-of-100 sampling compare with greedy decoding?
A4: Thank you for this question. Best-of-100 sampling improves the overall mean gap at a higher inference-time cost. On FJSP, Auto's gap falls from 7.11% to 6.20%, while runtime rises from 0.07 s to 5.55 s. Auto has the lowest overall gap in both decoding modes, and fixed is fastest under sampling at 4.23 s. Gains vary by subset: on Hurink vdata, greedy Auto gives 1.10% and sampled Auto gives 1.86% (Table R2).
Table R2: Overall FJSP gap (%) / time (s), over 130 instances. Frozen Greedy and Sampling share the same solver; Sampling selects the best of 100 schedules. Unfrozen uses greedy decoding after joint Stage-2 training. Full subset results appear in revised manuscript Table 6.
| Horizon | Frozen Greedy | Sampling | Unfrozen |
|---|---|---|---|
| 8.44/0.20 | 7.74/9.65 | 8.92/0.20 | |
| 9.20/0.09 | 6.92/5.16 | 10.06/0.09 | |
| 7.92/0.07 | 6.38/4.23 | 11.13/0.07 | |
| Auto | 7.11/0.07 | 6.20/5.55 | 8.58/0.08 |
Q2: Are the improvements consistent across independent training seeds?
A5: Thank you for asking about reproducibility. We could not complete independent-seed retraining within the available discussion time. Mechanistically, freezing the Encoder-Actor gives Dynamics fixed latent and decision targets, avoiding simultaneous changes in these targets during training. Multi-step alignment and decision consistency further supervise recursive predictions at each rollout depth. We expect this combination to help stabilize Dynamics training across seeds.
Q3: How does the method compare with ReSCHED and MatNet on FFSP?
A6: Thank you for suggesting FFSP evaluation. Table R3 reports results on 3,000 instances. Auto achieves an overall mean makespan of 56.29, compared with 56.72 for ReSched20 and 57.10 for MatNet100. Relative to , Auto lowers mean makespan from 56.36 to 56.29 and reduces mean inference time from 69.34 to 46.44 ms, an approximately 33.0% reduction. Auto matches the makespan on FFSP50 and improves it on FFSP20 and FFSP100. Fixed is faster at 42.06 ms, with a higher mean makespan of 57.57 versus 56.29 for Auto. On FFSP20, ReSched20 achieves a lower makespan of 26.60 than Auto's 26.87. Table R1 reports the corresponding FFSP runtime summary. Appendices D.1 to D.5 specify the data splits, training settings, and batched timing protocol.
Table R3: FFSP mean makespan / time (ms). Overall averages 3,000 instances equally across sizes. Full horizon results appear in revised manuscript Table 4.
| Dataset | ReSched20 | MatNet100 | Auto | ||
|---|---|---|---|---|---|
| FFSP20 | 26.60/11.95 | 27.68/59.57 | 26.96/4.71 | 28.17/2.20 | 26.87/2.99 |
| FFSP50 | 51.17/42.93 | 51.82/78.24 | 50.55/28.30 | 51.69/15.76 | 50.55/17.13 |
| FFSP100 | 92.39/157.67 | 91.80/118.91 | 91.57/175.02 | 92.86/108.22 | 91.46/119.21 |
| Overall | 56.72/70.85 | 57.10/85.57 | 56.36/69.34 | 57.57/42.06 | 56.29/46.44 |
Q4: Why can latent rollouts outperform stepwise re-encoding?
A7: Thank you for raising this apparent paradox. Latent rollouts can outperform because they change the action rankings of a greedy policy. A different feasible choice can lead to a shorter final makespan, and LRG controls when to refresh the representation using predicted decision regret. Table R2 also shows an improvement with fixed refreshes: the frozen solver's mean FJSP gap falls from 8.44% at to 7.92% at .
Auto uses predicted decision cost to decide when to re-encode. During gate training, if the predicted latent and fresh encoding lead to different actions at the same state under the same exact feasibility mask, we complete both schedules with the same policy and measure the signed makespan difference on FJSP. At inference, Auto re-encodes when the predicted regret score reaches its threshold (revised Section 4.3 and Appendix C.3).
Q5: Why does solution quality vary nonmonotonically with rollout horizon?
A8: Thank you for highlighting this behavior. Changing the horizon changes both the refresh positions and the subsequent scheduling trajectory, so solution quality need not vary monotonically. For example, refreshes before the fourth action and uses a predicted latent before the sixth; does the reverse. Different rankings change machine availability and later decisions, making the final makespan depend on where the trajectories diverge.
The Stage-2 loss ablation shows that removing latent alignment increases the FJSP gap by 1.62 percentage points at and 4.67 points at . The longer rollout is more sensitive to this loss. Table R2 shows that the ranking also depends on the trained model. The frozen setting gives gaps of 8.44%, 9.20%, and 7.92% at , , and , respectively. In the unfrozen setting, the gaps at and are 10.06% and 11.13%, reversing their order. Auto chooses when to re-encode based on predicted decision regret and achieves the lowest mean gap in both settings.
Dear Reviewer,
Thank you for proposing the fixed-embedding control, asking us to separate network time from state construction, and pointing out the nonmonotonic FJSP gaps. We address those questions and the requested evaluations below.
W1: The benefit of Dynamics needs a fixed-embedding control.
A1: Thank you for the suggestion. Dynamics updates the information used for action ranking after each scheduling decision. Reusing root embeddings lets the Actor re-contextualize the current feasible set. Dynamics additionally conditions the token update on the selected action, carrying changes in job and machine readiness into successor representations through latent alignment and decision consistency (Sections 4.2 and 4.4).
Our original fixed-horizon experiments showed that increasing the number of imagined steps could improve solution quality. Motivated by this observation, we introduce a new Latent Regret Gate (LRG) in the revision to decide, from predicted local decision regret, when to continue solving in imagination and when to refresh the representation through the Encoder. We denote this adaptive variant as Auto and evaluate its benefit against fixed horizons in the revised experiments below.
Table R2 reports the benefit of using these latent updates together with adaptive refreshing. With the same frozen Encoder-Actor, Auto reduces FJSP gap from 8.44% to 7.11% and time from 0.20 s to 0.07 s relative to H=1. Holding Dynamics fixed, Auto and fixed H=5 both take 0.07 s, with gaps of 7.11% and 7.92%. These results show how action-conditioned representation propagation and regret-guided refreshing work together in the scheduling procedure.
W2: Comparisons with BOPO and MACSIM under matched decoding settings are needed.
A2: Thank you for recommending these comparisons. The revision includes BOPO on JSSP and FJSP, and MACSIM on FJSP, under greedy decoding. On JSSP, Auto lowers BOPO's overall mean gap from 14.44% to 10.80% and runtime from 1.40 s to 1.24 s. Auto has lower gaps on all three benchmark families; on Lawrence, BOPO is faster at 0.39 s versus 0.67 s for Auto (Sections 5.1 and 5.2).
The FJSP benchmark comparison includes MACSIM and BOPO on FJSP. Under greedy decoding, MACSIM uses the same checkpoint across Brandimarte and Hurink, and its gaps use the same instance-wise CP-SAT reference as the other methods. Auto reaches 7.11% in 0.07 s overall, compared with 8.32% in 1.29 s for MACSIM and 8.93% in 0.33 s for BOPO. MACSIM gives a lower gap on Hurink rdata (6.52% versus 8.94%), and BOPO gives a lower gap on Hurink vdata (0.47% versus 1.10%).