{"id":"f39c8963-e34b-4016-9600-ab6f1dc4177f","arxiv_id":"2506.00260","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"A GNN-PPO scheduler matches MILP makespans on small workflow benchmarks but is slower than MILP on the largest test, and the evaluation has serious methodological gaps.","lead":"GrapheonRL is a scheduler that uses graph neural networks and reinforcement learning to assign workflow tasks to different computers in an HPC cluster. The authors claim it matches an exact optimization solver on small workflows and runs quickly, but the paper's own numbers contradict parts of that claim.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Table III contradicts the claimed 76% speedup: on Workflow 4, GNN-RL inference (1.81 s) is ~4.2× slower than MILP (0.43 s), so the headline speed advantage is unsupported.","rationale":"The paper's central claim has two load-bearing conditions: (i) GrapheonRL inference is drastically faster than MILP at similar makespan, and (ii) it generalizes to workflows not seen in training. The reader's weakest assumption targets (ii), which is important because Section IV-E3 describes storing the learned model for subsequent testing and no explicit split is reported. I agree that this is a serious gap. However, condition (i) is even more directly load-bearing and is contradicted by the paper's own Table III. On Workflow 4, MILP solves the problem in 0.43 s and GNN-RL-Test takes 1.81 s, a 4.2× slowdown. The text's '76% faster in inference' is numerically the reverse: 0.43/1.81 = 0.238, i.e., MILP is about 76% faster than GNN-RL. This is not a subtle modeling assumption; it is an internal arithmetic inconsistency in the headline result. The scale-test HEFT anomaly (makespan 10 for all sizes) further weakens the heuristic comparison, and the absent train/test split undermines generalization, but the speed contradiction alone is sufficient to reject the abstract's central claim as stated. A single recomputation settles it. I therefore keep the reader's verdict unchanged, though my primary concern differs from the reader's stated weakest assumption.","tokens_in":15022,"tokens_out":6208,"duration_ms":59087,"concrete_test":"Recompute the speed ratio from Table III, Workflow 4, using the reported solver times; if MILP_time/GNN_time = 0.43/1.81 ≈ 0.24, then GNN-RL is 4.2× slower, not 76% faster, and the central speed claim fails.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim requires the reported experiments to show that GrapheonRL inference is much faster than MILP while matching its makespan. Table III directly contradicts this. For Workflow 4, the only case where MILP takes non-negligible time, MILP solver time is 0.43 s and GNN-RL-Test is 1.81 s; 1.81/0.43 = 4.2, so GNN-RL is over four times slower, not '76% faster'. The paper's own computation appears to invert the ratio: 0.43/1.81 = 0.238, i.e., MILP's time is about 76% lower than GNN-RL's, which is the opposite of the claimed speedup. This is not a missing control or an ambiguous metric; the headline speed advantage is internally contradicted by the table it cites. Without that speedup, the central novelty claim reduces to 'GNN-RL matches MILP in makespan but is slower', and the comparison to heuristics is also compromised by the scale-test anomaly where HEFT returns makespan 10 at every size. A held-out workflow split is absent as well, so generalization is unestablished. The first thing to settle is whether the table numbers or the prose claim are correct.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes GrapheonRL, a GNN-RL framework for constraint- and data-aware workflow mapping and scheduling in heterogeneous HPC systems. The method models workflows as DAGs, uses a GNN to embed task dependencies and resource requirements, and trains a PPO agent to assign tasks to nodes while enforcing resource, feature, and dependency constraints. The authors compare against MILP, HEFT, and OLB on four standard task graph workflows and on synthetic scale tests, claiming that GrapheonRL matches MILP makespan while being \"76 percent faster\" and only 3.85x slower than OLB. The paper also claims generalization across workflows and scalability to 10,000 tasks.","tokens_in":15245,"tokens_out":3587,"duration_ms":34751,"significance":"If the empirical claims were correct, the work would offer a practical approach to large-scale workflow scheduling that combines the optimality of mathematical programming with the speed of learned policies. The methodological combination of GNN embeddings with PPO and explicit constraint-aware reward shaping is a reasonable direction, and the authors benchmark against standard baselines (MILP, HEFT, OLB) using a recognized task graph set. However, the central quantitative claims are internally contradicted by the paper's own tables, and the generalization evidence is missing. These issues are load-bearing because the abstract and conclusion rest on the \"76% faster\" and \"3.85x slower\" numbers, and the scalability story depends on a HEFT implementation that appears faulty.","major_comments":[{"comment":"The claim that GNN-RL inference is \"76% faster\" than MILP is contradicted by the paper's own Table III. For the Robot Control STG (Workflow 4), GNN-RL-Test takes 1.81 s while MILP takes 0.43 s, making GNN-RL about 4.2 times slower, not faster. The ratio 0.43/1.81 = 0.238 means MILP is 76% faster than GNN-RL, which is the opposite of the stated claim. The same inverted statement appears in the abstract, Section V-C1, and Section VII, so this is not a typo local to one sentence. This invalidates the central claim of \"drastically reduced execution times\" relative to MILP.","section":"§V-C1, Table III, Workflow 4"},{"comment":"The HEFT results in Table IV show a makespan of 10 for every scale from 10x10 to 10000x10000, while GNN-RL and OLB produce makespans from 41 to 189. A constant makespan of 10 across problem sizes strongly suggests a bug in the HEFT implementation or its makespan calculation, rather than a genuine scheduling result. Consequently, the claims that \"HEFT is 94.7% worse than optimal\" and \"HEFT fails at scale\" are unsupported by valid experimental evidence, and the comparison against heuristics is compromised.","section":"Table IV and §V-C3 / §VI-A2"},{"comment":"No train/test split is described for the GNN-RL experiments. The per-workflow results labeled GNN-RL-Train-Test and GNN-RL-Test appear to train and test on the same workflow DAG; there is no indication that a model trained on one workflow is evaluated on a different, held-out workflow. The abstract claims the method \"effectively adapts to different workflows,\" but generalization to unseen workflow graphs is not demonstrated. A held-out workflow cross-validation or a description of how the GNN-RL-Test model was obtained is necessary to support this central adaptability claim.","section":"§V-B, §IV-E3, §I-A"}],"minor_comments":[{"comment":"The phrase \"76 percent faster\" is ambiguous because no baseline is stated; please specify the comparison baseline and report the direction of the comparison clearly.","section":"Abstract and §V-C1"},{"comment":"The statement \"only 3.85 times slower than OLB\" is awkwardly phrased; being slower is a drawback, so describing it as \"only\" is misleading without additional context such as the makespan gains.","section":"§V-C1 and Table IV"},{"comment":"The feature constraint is written as a sum of binary variables equaling an indicator function, which is not a valid linear constraint as presented; a proper linearization or a formulation with auxiliary binary variables is needed for the MILP to be correct.","section":"Algorithm 2, line 24"},{"comment":"The column \"Mem Diff (MB)\" is not defined in the text; it should be clarified what this measures and how it is computed.","section":"Table III"},{"comment":"The footnote states that communication time cost is converted from seconds to milliseconds to adjust results, but the impact of this conversion on the reported makespans is not explained.","section":"§V-C1, Workflow 2 footnote"},{"comment":"Several references are missing venue or year information (e.g., [9], [18], [25], [31], [34], [37]); these should be completed for reproducibility.","section":"References"},{"comment":"The text states both that project codes will be available via GitHub once the proceedings are completed and that the source code is available at a GitHub URL; these statements should be reconciled.","section":"End matter"}],"recommendation":"reject","confidential_remarks":"The paper's core empirical claim is contradicted by its own Table III, and the HEFT baseline appears faulty; these are not presentation issues. Even if the numeric errors were corrected, the central advantage of the method over MILP would disappear, and the generalization claim lacks experimental support. The manuscript needs a substantially revised evaluation before it can be considered for publication."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things to know about this one. The core idea—GNN embeddings plus PPO for constraint-aware workflow scheduling in heterogeneous HPC—is a legitimate incremental extension of an established line, and the single-environment time-based concurrency handling is a reasonable design choice. But the paper's central speed claim is directly contradicted by its own experiments. On Workflow 4 (Robot Control STG, 90 tasks), MILP solves in 0.43 s and GNN-RL-Test takes 1.81 s. That is 4.2× slower, not 76% faster. The abstract and conclusion appear to have inverted the ratio: MILP is 76% faster than GNN-RL, not the other way around. So the headline advantage over MILP is not there.\n\nWhat the paper does well: the problem is real, the modeling of resources, features, dependencies, and data transfer times is clearly specified, and the MILP and heuristic baselines are, on the surface, reasonable. The authors also cite the prior GNN-RL scheduling work and position their contribution as a specific extension. The code is promised (and a GitHub link is given), which is more than many papers do.\n\nWhere it falls down, beyond the inverted speed claim: the HEFT baseline returns makespan 10 for every scale from 10×10 to 10,000×10,000, which looks like an implementation bug and makes the heuristic comparison meaningless. The evaluation also appears to train and test on the same workflow DAGs—no held-out workflow split is described—so the generalization and adaptability claims are unestablished. There are single runs without error bars, some hyperparameters and reward terms are underspecified, and the reward-shaping constants are not listed. These are not minor details; they are the evidence for the central claims.\n\nThe framework itself may be salvageable. The flaws are fixable with corrected experiments, a real holdout split, and a repaired HEFT baseline. But as submitted, the load-bearing claims are not supported by the paper's own tables. It needs a major revision, not minor tweaks.\n\nMy recommendation: send it to peer review, because there is enough substance and the issues are concrete enough that a serious referee could force the fixes. It should not be accepted in this form, and I would not cite its results. For a reading group, it is a useful example of an ML-scheduling evaluation where the headline claim collapses on first inspection.","headline":"GNN-RL scheduling framework with a load-bearing speed claim contradicted by its own Table III; worth refereeing but the evaluation as written does not support the central claims.","tokens_in":15835,"tokens_out":2239,"would_cite":false,"duration_ms":20472,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper claims that GrapheonRL, a graph-neural-network and reinforcement-learning scheduler, reproduces MILP-optimal makespans for heterogeneous HPC workflows at near-heuristic execution speed, adapting to changed constraints through…","keywords":["heterogeneous HPC","workflow scheduling","task mapping","graph neural networks","reinforcement learning","proximal policy optimization","makespan","MILP baseline"],"falsifier":"Time MILP and trained GNN-RL on a held-out workflow DAG the policy never saw during training, and compare makespan and constraint satisfaction; the paper's own table also invites the arithmetic check that its 89-task MILP solve (0.43 seconds) is faster than its reported GNN-RL inference (1.81 seconds), so a specified baseline for '76% faster' is needed.","tokens_in":14749,"feed_emoji":"⚙️","tokens_out":9953,"duration_ms":91576,"temperature":0.7,"pith_summary":"The paper proposes GrapheonRL, a scheduler that uses a graph neural network to encode workflow dependencies and resource requirements and a reinforcement-learning agent to choose which task runs on which node. The central claim is that, once trained, this policy produces makespans equal to those of an integer-linear-programming optimal solver on the workflows tested, while avoiding the solver's exponential growth: the authors report 76% faster inference than ILP and only 3.85 times slower decisions than the fastest heuristic. The motivation is that exact solvers become infeasible as workflows grow and heuristics ignore constraints, so a learned policy that respects dependencies, feature compatibility, and data-transfer costs would be a practical middle path. If the claim holds, GrapheonRL would let heterogeneous HPC systems schedule large, changing workloads without reformulating an optimization model each time.","feed_headline":"GNN-plus-RL scheduler matches MILP makespan at scale","feed_subtitle":"A learned policy schedules up to 10,000 tasks with optimal-quality makespan while staying close to heuristic runtime.","key_machinery":"The central machinery is GrapheonRL: a graph neural network encoder feeding a Proximal Policy Optimization (PPO) agent in a single unified environment. The GNN maps the workflow DAG plus node resource attributes into node embeddings; the agent's action space is every (task, node) pair, restricted by a validity mask that blocks already-assigned tasks, unsatisfied dependencies, feature mismatches, and infeasible resource overlaps. Time-based concurrency is checked by testing whether a candidate assignment's resource usage overlaps in real time with existing node schedules. The reward function is the carrier of all constraints: penalties of 5 to 20 for violations, a positive assignment bonus of 15 minus duration plus a resource factor, a final bonus of 30 minus makespan, and a large penalty for episodes that run out of steps with tasks unassigned. This reward design is what lets the authors claim constraints can be changed or added without reformulating an integer program.","core_discovery":"On its own terms, the paper's discovery is that a single environment that encodes tasks and nodes as one graph, plus a PPO agent with constraint-shaped rewards, can learn to schedule HPC workflows optimally with respect to makespan. The GNN produces per-task embeddings that summarize dependencies and resource demands; the policy then picks valid (task, node) assignments under an action mask, and the reward function punishes constraint violations and rewards shorter completion. The paper reports MILP-matching makespans across four real workflows, including an 89-task robot-control graph scoring 569, equal to MILP, and across synthetic workflows up to 10,000 tasks, where it matches OLB's makespan while HEFT is said to stall. The implication the authors draw is that scheduling quality need not be traded against scalability: the model generalizes across workflow sizes and adapts to new constraints by editing reward terms rather than rebuilding the solver.","pith_inferences":["The printed speed comparison needs scrutiny: in the paper's Table III the 89-task MILP solve takes 0.43 seconds while GNN-RL inference takes 1.81 seconds, so the abstract's '76% faster' cannot refer to this table unless a different baseline, such as total training amortization or a time-limited exact solve, is intended.","Because train and test phases appear to use the same workflow DAGs, the adaptability claim would be sharpened by a held-out evaluation: train on several workflow families and test on a structurally different DAG, which is a direct next experiment.","The same GNN/PPO core could be reused for multi-objective scheduling, such as energy, fairness, or throughput, by reweighting reward terms, so the method's main contribution may be the constraint-as-reward pattern rather than the specific makespan results.","A fairer scalability comparison would include a time-limited exact solver at 1,000 and 10,000 tasks; without that, 'optimal' at scale is only demonstrated relative to the two heuristics."],"forward_implications":["Workflows too large for an exact solver can be scheduled with MILP-matching makespan using a trained policy, so schedule quality need not be sacrificed for scalability.","Changing HPC constraints (cores, memory, features, data-transfer costs) becomes an edit to reward shaping rather than a reformulation of an integer program, which makes the scheduler easier to maintain as systems evolve.","The one-time training cost, about 176 seconds for the 89-task case, is amortized at deployment, where inference takes 1.81 seconds, supporting offline training for online scheduling.","At 10,000-task scale the paper reports GNN-RL and OLB both reaching makespan 189, while HEFT is said to fail at scale, making learned schedulers the constraint-aware option at extreme scale."],"supporting_citations":[{"why":"Supplies the ILP-and-greedy Snakemake scheduler that motivates the work and defines the workflow-management baseline.","marker":"[3]"},{"why":"Defines the graph neural network model used to encode task dependencies and resource attributes.","marker":"[18]"},{"why":"Provides the workflow-as-DAG modeling (tasks and dependencies) that the environment and GNN operate on.","marker":"[33]"},{"why":"Supplies Proximal Policy Optimization, the RL algorithm whose clipped surrogate objective the agent optimizes.","marker":"[34]"},{"why":"Provides the MILP solver used to produce the optimal baseline schedules against which GNN-RL is compared.","marker":"[35]"},{"why":"Supplies the Standard Task Graph Set real workflows used as test cases.","marker":"[36]"},{"why":"Companion source for the standard task graph set and multiprocessor scheduling algorithms used in the real-workflow benchmarks.","marker":"[37]"}],"fun_headline_variants":["GNN+RL matches MILP makespan at scale, near heuristic speed","Learned scheduler beats ILP runtime, matches its makespan","AI workflow scheduler rivals exact optimization, scales to 10k tasks","Graph RL for HPC scheduling: optimal makespan, fast execution","GNN+RL scheduling matches exact makespan with heuristic speed"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that a policy trained on a workflow also schedules that same workflow, or structurally similar ones, well at test time; the paper reports training and testing on the same DAGs, so cross-workflow generalization is asserted but not demonstrated.","fun_headline_variants_meta":{"raw":{"variants":["GNN+RL matches MILP makespan at scale, near heuristic speed","Learned scheduler beats ILP runtime, matches its makespan","AI workflow scheduler rivals exact optimization, scales to 10k tasks","Graph RL for HPC scheduling: optimal makespan, fast execution","GNN+RL scheduling matches exact makespan with heuristic speed"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000267,"raw_usage":{"total_tokens":1654,"prompt_tokens":1028,"completion_tokens":626,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":644,"completion_tokens_details":{"reasoning_tokens":535}},"tokens_in":644,"tokens_out":626,"duration_ms":6751,"temperature":1.0,"reasoning_tokens":535,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-07T12:08:38.824836+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Time MILP and trained GNN-RL on a held-out workflow DAG the policy never saw during training, and compare makespan and constraint satisfaction; the paper's own table also invites the arithmetic check that its 89-task MILP solve (0.43 seconds) is faster than its reported GNN-RL inference (1.81 seconds), so a specified baseline for '76% faster' is needed.","supporting_citations":[{"cited_title":"Snakemake–a scalable bioinformatics workflow engine,","cited_arxiv_id":null,"evidence_quote":"Supplies the ILP-and-greedy Snakemake scheduler that motivates the work and defines the workflow-management baseline."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Provides the workflow-as-DAG modeling (tasks and dependencies) that the environment and GNN operate on."},{"cited_title":"[Online]","cited_arxiv_id":null,"evidence_quote":"Provides the MILP solver used to produce the optimal baseline schedules against which GNN-RL is compared."},{"cited_title":"A standard task graph set for fair evaluation of multiprocessor scheduling algorithms,","cited_arxiv_id":null,"evidence_quote":"Supplies the Standard Task Graph Set real workflows used as test cases."},{"cited_title":"Practical Multiprocessor Scheduling Algorithms for Efficient Parallel Processing,","cited_arxiv_id":null,"evidence_quote":"Companion source for the standard task graph set and multiprocessor scheduling algorithms used in the real-workflow benchmarks."}],"review_version":1}