acceptodds
Under review as a conference paper at ICLR 2027

DecompPilot: Long-Horizon Agentic Discovery of Decomposition Strategies for Large-Scale Mixed-Integer Linear Programs

Abstract

Large-scale mixed-integer linear programs (MILPs) are computationally intensive due to the combinatorial complexity introduced by discrete decisions. Decomposition-based optimization reduces this complexity by partitioning the original program into smaller subproblems and coordinating the subproblem solutions to satisfy coupling constraints and maintain consistency among linking variables. We propose **DecompPilot**, an LLM-agent framework that uses the semantics of decision variables and constraints to automatically design and execute partitioning and coordination strategies tailored to different problem structures. We formulate decomposition design as a long-horizon experimental search problem rather than a one-shot partitioning task, and study whether LLM agents can discover decomposition operators that can be reused across problem instances. This setting introduces two challenges: preserving useful evidence from successful and failed solver trials over long search histories, and accumulating reusable design knowledge from instance-specific experience. To address these challenges, we propose two complementary mechanisms: a *Trial Memory Tree* that preserves instance-level trial evidence for refinement and backtracking, and *Decomposition Operator Induction* that identifies and validates reusable algorithmic components across instances and triggers targeted trials when further evidence is needed. Across four benchmark suites spanning unit commitment and bin packing, the reusable decomposition operators discovered by DecompPilot achieve a 94.5% feasibility rate on unseen instances, including 73 million-scale PEGASE instances. They reduce total solving wall-time by 52.7% on average relative to Gurobi while keeping the average relative objective gap to the Gurobi reference at 0.95%.

Primary area:
optimization
Keywords:
LLM agents, long-horizon agentic search, agentic optimization, mixed-integer linear programming, decomposition methods

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_pSUNOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies the automated design of decomposition strategies for large-scale mixed-integer linear programs. Classical decomposition relies on expert-crafted, problem-specific schemes, while generic automatic approaches use only the algebraic structure of the constraint matrix. The authors propose DecompPilot, an LLM-agent framework that draws on variable and constraint semantics to propose, implement, and refine model-level decompositions. They treat decomposition design as a long-horizon experimental search problem and introduce two mechanisms. A Trial Memory Tree records successful and failed solver trials to support refinement and backtracking within an instance. Decomposition Operator Induction abstracts recurring patterns from seed instances into reusable operators, which are frozen before held-out evaluation. All solutions are verified for strict feasibility against the original formulation. Experiments on unit-commitment benchmarks, including million-scale instances, and on bin packing show that the induced operators transfer to unseen instances. They yield feasible solutions on most held-out instances, with objective values close to a time-limited commercial solver and generally lower end-to-end runtime.

Critical strengths
  • The paper is clearly written and well organized, which makes a complex multi-agent pipeline easy to follow.
  • The figures are well designed and effectively illustrate the decomposition workflow, the Trial Memory Tree, and the operator induction process.
  • The work is well motivated, addressing the practically relevant problem of reducing the expert effort required to design decomposition strategies for large-scale MILPs.
  • The paper is transparent about its experimental protocol, providing detailed appendices on data splits, timing semantics, and per-instance results.
  • The authors candidly discuss negative evidence and limitations, which is appreciated and helps contextualize the results.
Critical weaknesses

1. Inadequate baselines. The evaluation lacks domain-standard decomposition heuristics, so it cannot show whether simple, well-known schemes would perform comparably. The induced operators closely resemble textbook methods: rolling horizon for CA, generator-wise Dantzig–Wolfe for FERC and PEGASE, and Gilmore–Gomory pattern generation for bin packing. Yet none of these, nor Lagrangian relaxation or relax-and-fix, is evaluated as an expert-configured baseline. The only such baseline, Canonical CG, is effectively absent on all three unit-commitment suites, because the authors acknowledge its mapping to the original MILP did not pass the equivalence check. On bin packing, where it does run, the large runtime gap to DecompPilot is not explained even though both share the same pattern-based structure. The baselines also do not use the integer recovery and original-MILP polishing stages that DecompPilot relies on, so the comparison conflates decomposition design with post-processing. Finally, GCG-Auto is an exact branch-and-price method and is not a natural comparator for a heuristic pipeline. Comparisons with recent LLM-based decomposition methods cited in the related work, such as LLM-LNS and DRAGON, are also missing.

2. Missing ablations of the core components. The paper offers no evidence that its two central mechanisms are necessary. The only experiment labeled an ablation concerns a stopping rule within the FERC operator. There is no comparison of the Trial Memory Tree against linear refinement or against discarding failed trials, and no comparison of Operator Induction against directly reusing the best seed strategy. Most importantly, there is no one-shot baseline in which an LLM is simply prompted with the model description and the operator library, so it remains unclear whether a single prompt would already yield a comparable operator. The contributions of the Verifier and Exploration agents, of semantic descriptions, and of the operator priors are likewise untested. The trial-tree case studies are anecdotal, and the memory-guided search in Figure 5 arguably weakens the case for memory, since all inherited proposals were rejected and the successful candidates were reconstructed from the current instance. The authors also acknowledge that agents sometimes repeat similar refinements, which is the very failure mode the tree is meant to prevent.

3. Overstated discovery and unclear attribution of performance. The paper describes its operators as discovered, but they largely reinstantiate the three primitives supplied in the operator library: rolling horizon, DW/CG, and ADMM-style coordination. The search therefore appears to operate within a small, expert-designed space and to tune parameters such as block count, history depth, and fixing rules, rather than to discover new algorithmic structure. Moreover, a substantial share of the final solution quality appears to come from the commercial solver itself. The PEGASE operator spends about 600 seconds polishing the original MILP from a MIP start, which accounts for the large majority of its key solve time, and the FERC operator likewise ends with an original-MILP polish. Without an experiment that applies the same polish budget starting from a simple warm start, it is difficult to attribute the observed solution quality to the decomposition rather than to the final Gurobi solve.

4. Limited informativeness of the “Time” metric. Although the paper reports end-to-end wall time alongside key solve time, the latter is of limited value as a basis for comparison. For DecompPilot, key solve time is computed from the column generation critical path, which assumes perfectly parallel pricing, whereas for the monolithic solvers it is simply the actual solver runtime. These quantities are not directly comparable, particularly when the baseline solver’s thread budget is not matched (for FERC, the Gurobi reference is reported as single-threaded). The idealized critical path also does not appear to reflect actual execution: the frozen FERC operator uses a single pricing worker, and for PEGASE the recorded CG work wall time is substantially larger than the reported critical path. I would suggest either removing this column from the main comparison or reporting it under matched parallel resources, so that the claimed speedups rest on the wall-time measurements.

Questions for authors

See the Weaknesses

7 comments

Response labels. R1, R2, ... number our response topics within each reviewer. W and Q retain the reviewer's original weakness and question numbers. Paragraph numbers count the body paragraphs after each weakness heading; the heading itself is excluded. Each response identifies the original comments it addresses, and closely related requests are answered together.


We thank the reviewer for the detailed and constructive assessment, and for the positive comments on the presentation. We have added classical and LLM-based baselines, expanded the ablations, and clarified the timing protocol and the scope of operator discovery. Related comments are grouped into the seven responses below.

R1. Classical and LLM-based baselines under revised evaluation.

Response to W1 (domain-standard and LLM-based baselines), with runtime and polishing addressed in R3–R4.

Response. Thank you for identifying the missing comparisons. We agree that domain-standard and LLM-based baselines are both important here. We have added validated classical pipelines—rolling horizon, relax-and-fix, generator-wise/grouped DW/CG with integer recovery and bounded polish, and strong-initialization Gilmore–Gomory CG—together with LLM-LNS [1] and DRAGON [2]. Unvalidated UC Canonical CG remains a mapping diagnostic, and GCG-Auto remains contextual exact branch-and-price evidence rather than the principal heuristic comparator.

We now evaluate the main comparison under an eight-logical-CPU ceiling, using eight-thread serial solves or concurrent subproblem solves whose thread budgets sum to at most eight (e.g., 8×1 or 4×2).

FERC update relative to the original submission. The weaker objective–wall convergence on FERC motivated a more informative discovery objective. A reference runtime based only on Gurobi's termination time does not show the agents how quickly it reaches a useful solution. We therefore used the saved Gurobi (threads=8) trajectory up to 3600 s to provide quality-matched feedback: for a candidate's final objective, the reference time is the first saved strictly feasible Gurobi event attaining an equal or better objective. This guided DecompPilot’s search toward a more effective LP-quota generator-group operator. The operator constructs integer decisions through local MILPs, recovers global dispatch through a continuous LP, and invokes a predefined four-group fallback when the initial eight-group stage fails.

The current campaign uses a newly sampled 40%/20%/40% discovery/Validation/Test partition, realized as 10/5/9 instances. The Orchestrator selects two Seeds from the discovery pool; the remaining eight discovery instances do not enter Validation or Test. The instance set remains fixed within a campaign, although a new campaign can sample a different set. We now evaluate the frozen operator and all baselines on the nine FERC Test cases. The details of the discovered operator and data roles are described in Appendices G and R.

Table P1 below (Table 3 in the revised manuscript) presents the updated main comparison. The revised agent-search objective uses the saved Gurobi (threads=8) 3600-s trajectories as the reference goal in the system prompt. The additional baseline and ablation evaluations use these same trajectories as their references.

Reading the two columns. The two columns evaluate final solution quality and feasibility, and the speed and coverage of reaching a common quality target, respectively. Let RiR_i denote the best strictly feasible objective found by Gurobi (threads=8) on instance ii within H=3600H=3600 s. The quality column reports the mean relative objective difference, Δref=100(fi(H)−Ri)/∣Ri∣\Delta_{\rm ref}=100(f_i(H)-R_i)/|R_i|, over strictly feasible outputs, together with strict/total, the number of test instances yielding such outputs. Lower values indicate better solution quality, and negative values indicate improvement over the Gurobi reference. The TTT column reports the average time to first reach the common quality target over instances that reach it, together with hits/total, the number of test instances reaching that target. Thus, the reported times show how quickly targets are reached, while the accompanying counts show how broadly each method succeeds across the test set.

For UC, the target is Ri+0.0105∣Ri∣R_i+0.0105|R_i|. For BinPacking, let BiB_i be the number of bins in the common FFD initialization; the target is Bi−1B_i-1. Necessary initialization, construction, coordination, recovery, polishing, and online LLM waiting remain charged before a hit. Appendix N defines the timing conventions; Appendix P provides data-level and instance-level objective–wall trajectories.

Table P1. Main classical and LLM-based baseline comparison.

MethodCACAFERCFERCPEGASEPEGASEBinPackingBinPacking
Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)
Gurobi (threads=8)+0.000 (5/5)49.14 (5/5)+0.000 (9/9)114.56 (9/9)+0.000 (73/73)294.89 (73/73)+0.000 (5/5)904.32 (2/5)
DecompPilot+0.316 (5/5)96.37 (5/5)+0.246 (9/9)60.89 (9/9)+0.317 (73/73)473.02 (73/73)-0.884 (5/5)49.71 (5/5)
Rolling horizon+0.004 (5/5)58.45 (5/5)——————
Relax-and-fix+0.005 (5/5)96.06 (5/5)+0.042 (9/9)569.46 (9/9)+0.196 (72/73)1907.56 (72/73)——
Generator-wise DW/CG——+1.750 (9/9)940.46 (2/9)+0.372 (73/73)1312.21 (73/73)——
Grouped DW/CG——+2.463 (9/9)899.83 (4/9)+0.386 (73/73)1343.53 (73/73)——
Gilmore–Gomory CG——————-0.783 (5/5)113.38 (5/5)
LLM-LNS+1.187 (5/5)228.85 (3/5)+13.391 (9/9)116.70 (7/9)+52.837 (56/73)304.92 (34/73)-0.294 (5/5)43.68 (4/5)
DRAGON——————+0.002 (5/5)108.21 (2/5)

Results. On FERC, DecompPilot and Gurobi both attain 9/9 targets in mean recorded times of 60.89 and 114.56 s, a 46.8% reduction; DecompPilot is faster on all nine cases. On BinPacking, DecompPilot and tuned Gilmore–Gomory CG both attain 5/5 targets, with means of 49.71 and 113.38 s, a 56.2% reduction. These are the fastest non-ablation comparators with matching full target coverage on the respective datasets. DecompPilot also improves one final BinPacking objective and ties the other four. Gurobi reaches only 2/5 BinPacking targets; on those two common-hit instances, its mean is 904.32 s versus 38.13 s for DecompPilot, a 95.8% reduction. This two-instance comparison is reported separately from the full-coverage comparison. Conversely, DecompPilot takes 96.1% longer than Gurobi on CA and 60.4% longer on PEGASE, where both methods attain all targets. Worst DecompPilot reference differences are +0.429%, +1.017%, +0.740%, and −0.493% for CA, FERC, PEGASE, and BinPacking, respectively.

Revised conclusion. The frozen procedures return strictly feasible solutions and reach the declared targets on 92/92 Test instances. Relative to the fastest compared non-ablation baseline with matching full target coverage, mean recorded TTT is lower by 46.8% on FERC and 56.2% on BinPacking. These results support the ability of the framework to discover reusable decomposition operators and faster solution procedures on some problem families. We report dataset-specific outcomes, with complete data-level and instance-level objective–wall trajectories in Appendix P.

R2. Trial Memory Tree, induction, and other component ablations.

Response to W2 (stopping-policy limitation, one-shot generation, linear refinement, failure memory, best-Seed reuse, and agent/semantic/prior controls).

Response. We agree that the stopping-rule experiment alone does not test the proposed agent mechanisms. We have added separate single-instance memory and cross-instance operator-reuse comparisons, as shown below and in Appendix M.

Table P2a. Single-instance ablations: objective and original-row CVR.

VariantCA09 Obj. ↓ (CVR % ↓)CA06 Obj. ↓ (CVR % ↓)CA03 Obj. ↓ (CVR % ↓)BP07 Obj. ↓ (CVR % ↓)BP12 Obj. ↓ (CVR % ↓)Saved strict outputs ↑
A: One-shot LLM— (NR)41728.83† (0.467836→0)— (AD)205 (0)199 (0)3/5
A-K: Best-of-K Independent Proposals48331.92 (0)— (AD)— (AD)204 (0)199 (0)3/5
B: Memory-free Iterative Agent— (AD)— (AD)— (0.012644→0‡)204 (0)199 (0)2/5
C: Linear Refinement— (NR)— (NR)— (AD)— (NR)— (NR)0/5
D: Flat Trial Archive— (NR)— (NR)— (AD)206 (0)199† (0)2/5
E: No Failure Memory— (NR)— (AD)— (NR)204 (0)199 (0)2/5
F: Full Trial Memory Tree48298.65 (0)41717.64 (0)31806.43 (0)— (NR)199 (0)4/5

The single-instance table matches the appendix: CA09/06/03 are the three CA Seeds, and BP07/12 are u500_07/12, two BinPacking Seeds. CVR is the percentage of original linear rows with violation above 10⁻⁶. NR means no saved row evaluation; AD means only ADMM residuals, not measured original-row CVR. An arrow shows pre/post repair. † marks numerical strict outputs from interrupted runs with incomplete trial eligibility; they count as saved strict outputs, not completed discovery successes. ‡ is a repaired diagnostic without an independent Strict Check and is not counted as a solution.

The clearest differences arise on the three CA instances. The full Trial Memory Tree obtains strictly feasible solutions on all three, whereas the memory-free, linear-refinement, flat-archive, and no-failure-memory variants obtain none. Independent sampling also leaves no saved strictly feasible solution on CA06 and CA03 despite seven and nine candidate opportunities, respectively; the full method succeeds on both. These results suggest that generating additional candidates or retaining only part of the search history does not reliably replace the structured use of previous trials and feedback on these cases.

Table P2b. Cross-instance induction ablation; definitions match P1.

MethodCA Δref (%) ↓ (strict/total ↑)FERC Δref (%) ↓ (strict/total ↑)PEGASE Δref (%) ↓ (strict/total ↑)BinPacking Δref (%) ↓ (strict/total ↑)
Single-instance operator reuse (G)— (0/5)+0.234 (9/9)+0.064 (66/73)−0.884 (5/5)
DecompPilot+0.316 (5/5)+0.246 (9/9)+0.317 (73/73)−0.884 (5/5)
Reviewer_bb8gOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes an agentic system for producing decompositions for mixed integer linear programs. The agent aggregates native problem structural information with past attempts to produce better decompositions. Two types of generalization are studied: sequential learning while working on one instance, and cross-instance generalization. Empirical evaluations on large scale MILPs show speed improvement with small objective gap sacrifice.

Critical strengths

This work continues existing work on LLM for MILP decompositions. This is an interesting and potentially promising area to leverage LLM strengths to uncover semantic structures in MILPs. This work focuses on designing generalization ability into the system. An agent can learn from its past experiences while working on one problem, and can learn from experiences across many instances. This is a worthy direction for advancement.

Critical weaknesses

This paper lacks comparison with other LLM-based MILP decomposition methods such as LLM-LNS. The reason cited is that DECOMPPILOT does not require an initial feasible solution, however, this seems an addressable issue, either using Gurobi to find a feasible solution to initialize LLM-LNS for example.

The empirical evaluations are mixed, while there is time saving benefit, most comparisons produced worst objectives. It is useful to extend the DECOMPPILOT time to match say 3600s and see what the best objective value it could find, and whether this objective would improve upon that of Gurobi.

Questions for authors
  1. In section 4.1, it is unclear what the definition of a success is in the context of "a failed or partially successful strategy"?

  2. Which LLM model was used for the experiment?

4 comments

Response labels. R1, R2, ... number our response topics within each reviewer. W and Q retain the reviewer's original weakness and question numbers. Paragraph numbers count the body paragraphs after each weakness heading; the heading itself is excluded. Each response identifies the original comments it addresses, and closely related requests are answered together.


We thank the reviewer for the thoughtful comments and for recognizing the promise of learning from decomposition experience. We have clarified the success criterion and model settings, added LLM-based baselines, and expanded the quality–time evaluation. The four responses below follow your questions and main concerns.

R1. Definition of successful and partially successful strategies.

Response to Q1.

Response. Thank you for pointing out this ambiguity. We have clarified the distinction between completing a trial, obtaining a strictly feasible solution, and reaching the quality target. A completed trial may still fail to return a globally feasible assignment. A strictly feasible solution must assign all original variables and satisfy every original row, bound, and integrality condition within tolerance. Target attainment additionally requires its objective to reach the declared threshold.

“Partially successful” refers to intermediate evidence—such as local incumbents or reduced coupling violations—that guides another trial; it is not counted as an original-MILP solution. For example, neither the new FERC fractional allocation LP nor a local MILP incumbent is globally feasible. Only the merged assignment after global dispatch and original-model checking is counted. The Integrator constructs the assignment; deterministic checks establish feasibility, while the Verifier agent diagnoses failures.

R2. LLM models and experimental configuration.

Response to Q2.

Response. Thank you for asking us to clarify the model versions. The LLM components of the additional baseline and ablation experiments and the updated DecompPilot experiments on FERC and CVRPLIB use gpt-6.1-sol, whereas the original DecompPilot experiments on CA, BinPacking, and PEGASE used the provider's earlier gpt-5.4 API endpoint. We used the API endpoints’ default sampling settings without explicitly overriding temperature or top-p. The additional agent-search objective is faster convergence relative to the saved Gurobi trajectory over 3600 s. Appendix R provides the experimental configuration, and Appendix S reports discovery and execution costs.

R3. LLM-based baselines, feasible initialization, and their costs.

Response to W1.

Response. Thank you for this suggestion. We agree that feasible initialization can be supplied when evaluating LLM-LNS, and have added LLM-LNS [1] and DRAGON [2] as complementary LLM-based baselines. Their implementations and initialization protocols are as follows:

  1. LLM-LNS: offline LLM evolution generates a neighborhood-scoring function. Fitness runs start from the first strict Gurobi (threads=8) solution for UC or FFD for BinPacking, then perform destroy/fix/restricted-MILP repair. The selected scoring function is frozen for Test, with no online LLM calls. UC initialization is replayed with its saved availability time charged once. The recorded offline ceiling is 24 h per dataset, with a separate 6-h Validation allowance and a 3600-s Test horizon.
  2. DRAGON: on BinPacking, FFD is followed by online LLM decomposition/reconstruction and native acceptance/stagnation stopping. The frozen artifact fixes interfaces and prompts, while the LLM continues acting on each new instance. The per-instance cap is 3600 active seconds, 128 HTTP attempts, and two million known tokens; runs can stop earlier. No validated UC adapter is included. Supplementary CVRPLIB uses official greedy initialization, rather than FFD or Gurobi.

Detailed budgets, stopping rules, and recorded costs are reported in Appendix S.6. Across ten independent training runs on four datasets, LLM-LNS consumes 71.697 dataset-hours, 153 recorded requests, and 741,331 known input-plus-output tokens; six requests lack complete usage. These totals include subsequent training attempts, rather than only the selected heuristic. DRAGON's 22 Seed/Train, Validation, and Test executions across BinPacking and CVRPLIB consume 8.034 instance-hours, 428 requests, and 1,904,464 known tokens, with five missing usage records. Engineering passes and smoke tests are listed separately. Summed run times are neither CPU-hours nor parallel campaign makespans.

[1] Ye et al. Large Language Model-driven Large Neighborhood Search for Large-Scale MILP Problems. ICML 2025. Paper.

[2] Chen et al. DRAGON: LLM-Driven Decomposition and Reconstruction Agents for Large-Scale Combinatorial Optimization. AAMAS 2026. Paper.

Table B3. Current comparison with the added LLM-based baselines.

MethodCACAFERCFERCPEGASEPEGASEBinPackingBinPacking
Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)
Gurobi (threads=8)+0.000 (5/5)49.14 (5/5)+0.000 (9/9)114.56 (9/9)+0.000 (73/73)294.89 (73/73)+0.000 (5/5)904.32 (2/5)
DecompPilot+0.316 (5/5)96.37 (5/5)+0.246 (9/9)60.89 (9/9)+0.317 (73/73)473.02 (73/73)-0.884 (5/5)49.71 (5/5)
LLM-LNS+1.187 (5/5)228.85 (3/5)+13.391 (9/9)116.70 (7/9)+52.837 (56/73)304.92 (34/73)-0.294 (5/5)43.68 (4/5)
DRAGON——————+0.002 (5/5)108.21 (2/5)

Reading the two columns. The two columns evaluate final solution quality and feasibility, and the speed and coverage of reaching a common quality target, respectively. Let RiR_i denote the best strictly feasible objective found by Gurobi (threads=8) on instance ii within H=3600H=3600 s. The quality column reports the mean relative objective difference, Δref=100(fi(H)−Ri)/∣Ri∣\Delta_{\rm ref}=100(f_i(H)-R_i)/|R_i|, over strictly feasible outputs, together with strict/total, the number of test instances yielding such outputs. Lower values indicate better solution quality, and negative values indicate improvement over the Gurobi reference. The TTT column reports the average time to first reach the common quality target over instances that reach it, together with hits/total, the number of test instances reaching that target. Thus, the reported times show how quickly targets are reached, while the accompanying counts show how broadly each method succeeds across the test set.

For UC, the target is Ri+0.0105∣Ri∣R_i+0.0105|R_i|. For BinPacking, let BiB_i be the number of bins in the common FFD initialization; the target is Bi−1B_i-1. Necessary initialization, construction, coordination, recovery, polishing, and online LLM waiting remain charged before a hit. Appendix N defines the timing conventions; Appendix P provides data-level and instance-level objective–wall trajectories.

DecompPilot has lower final objectives than LLM-LNS on all nine FERC pairs and all five BinPacking pairs, and lower BinPacking objectives than DRAGON on all five. LLM-LNS reaches 7/9 FERC targets; five are already met by initialization, so those hits are not attributed to learned repair. PEGASE retains 56/73 final LLM-LNS outputs and 34/73 target hits, including 33 initialization hits. On BinPacking, DecompPilot covers 5/5 targets, LLM-LNS 4/5, and DRAGON 2/5. LLM-LNS's smaller hit-only mean does not establish better performance across the full test set, and DecompPilot is not faster than every baseline on every common-hit subset.

R4. Same-horizon quality and the request to continue optimization to 3600 s.

Response to W2.

Response. Thank you for suggesting a comparison over the full time budget. Table B4 reports two complementary outcomes: Δref (Strict/total) measures the best retained solution quality by 3600 s and feasible coverage, while TTT (Hits/total) measures how quickly the common objective target is reached and how many instances reach it. Appendix P provides data-level and instance-level objective–wall trajectories.

These additions address same-horizon quality and target attainment, but do not replace the continuation experiment you suggest. We do not yet have a complete experiment that keeps every early-stopped operator optimizing through the remaining hour; progress after its recorded termination is therefore unknown. We have kept this limitation explicit.

We now evaluate the main comparison under an eight-logical-CPU ceiling, using eight-thread serial solves or concurrent subproblem solves whose thread budgets sum to at most eight (e.g., 8×1 or 4×2).

FERC update relative to the original submission. The weaker objective–wall convergence on FERC motivated a more informative discovery objective. A reference runtime based only on Gurobi's termination time does not show the agents how quickly it reaches a useful solution. We therefore used the saved Gurobi (threads=8) trajectory up to 3600 s to provide quality-matched feedback: for a candidate's final objective, the reference time is the first saved strictly feasible Gurobi event attaining an equal or better objective. This guided DecompPilot’s search toward a more effective LP-quota generator-group operator. The operator constructs integer decisions through local MILPs, recovers global dispatch through a continuous LP, and invokes a predefined four-group fallback when the initial eight-group stage fails.

The current campaign uses a newly sampled 40%/20%/40% discovery/Validation/Test partition, realized as 10/5/9 instances. The Orchestrator selects two Seeds from the discovery pool; the remaining eight discovery instances do not enter Validation or Test. The instance set remains fixed within a campaign, although a new campaign can sample a different set. We now evaluate the frozen operator and all baselines on the nine FERC Test cases. The details of the discovered operator and data roles are described in Appendices G and R.

Table B4 below (Table 3 in the revised manuscript) presents the updated main comparison, including tuned classical pipelines and LLM-LNS/DRAGON. The revised agent-search objective uses the saved Gurobi (threads=8) 3600-s trajectories as the reference goal in the system prompt. The additional baseline and ablation evaluations use these same trajectories as their references.

Reading the two columns. The two columns evaluate final solution quality and feasibility, and the speed and coverage of reaching a common quality target, respectively. Let RiR_i denote the best strictly feasible objective found by Gurobi (threads=8) on instance ii within H=3600H=3600 s. The quality column reports the mean relative objective difference, Δref=100(fi(H)−Ri)/∣Ri∣\Delta_{\rm ref}=100(f_i(H)-R_i)/|R_i|, over strictly feasible outputs, together with strict/total, the number of test instances yielding such outputs. Lower values indicate better solution quality, and negative values indicate improvement over the Gurobi reference. The TTT column reports the average time to first reach the common quality target over instances that reach it, together with hits/total, the number of test instances reaching that target. Thus, the reported times show how quickly targets are reached, while the accompanying counts show how broadly each method succeeds across the test set.

For UC, the target is Ri+0.0105∣Ri∣R_i+0.0105|R_i|. For BinPacking, let BiB_i be the number of bins in the common FFD initialization; the target is Bi−1B_i-1. Necessary initialization, construction, coordination, recovery, polishing, and online LLM waiting remain charged before a hit. Appendix N defines the timing conventions; Appendix P provides data-level and instance-level objective–wall trajectories.

Results. On FERC, DecompPilot and Gurobi both attain 9/9 targets in mean recorded times of 60.89 and 114.56 s, a 46.8% reduction; DecompPilot is faster on all nine cases. On BinPacking, DecompPilot and tuned Gilmore–Gomory CG both attain 5/5 targets, with means of 49.71 and 113.38 s, a 56.2% reduction. These are the fastest non-ablation comparators with matching full target coverage on the respective datasets. DecompPilot also improves one final BinPacking objective and ties the other four. Gurobi reaches only 2/5 BinPacking targets; on those two common-hit instances, its mean is 904.32 s versus 38.13 s for DecompPilot, a 95.8% reduction. This two-instance comparison is reported separately from the full-coverage comparison. Conversely, DecompPilot takes 96.1% longer than Gurobi on CA and 60.4% longer on PEGASE, where both methods attain all targets. Worst DecompPilot reference differences are +0.429%, +1.017%, +0.740%, and −0.493% for CA, FERC, PEGASE, and BinPacking, respectively.

Revised conclusion. The frozen procedures return strictly feasible solutions and reach the declared targets on 92/92 Test instances. Relative to the fastest compared non-ablation baseline with matching full target coverage, mean recorded TTT is lower by 46.8% on FERC and 56.2% on BinPacking. These results support the ability of the framework to discover reusable decomposition operators and faster solution procedures on some problem families. We report dataset-specific outcomes, with complete data-level and instance-level objective–wall trajectories in Appendix P.

Table B4. Main comparison under the revised evaluation protocol.

MethodCACAFERCFERCPEGASEPEGASEBinPackingBinPacking
Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)
Gurobi (threads=8)+0.000 (5/5)49.14 (5/5)+0.000 (9/9)114.56 (9/9)+0.000 (73/73)294.89 (73/73)+0.000 (5/5)904.32 (2/5)
DecompPilot+0.316 (5/5)96.37 (5/5)+0.246 (9/9)60.89 (9/9)+0.317 (73/73)473.02 (73/73)-0.884 (5/5)49.71 (5/5)
Rolling horizon+0.004 (5/5)58.45 (5/5)——————
Relax-and-fix+0.005 (5/5)96.06 (5/5)+0.042 (9/9)569.46 (9/9)+0.196 (72/73)1907.56 (72/73)——
Generator-wise DW/CG——+1.750 (9/9)940.46 (2/9)+0.372 (73/73)1312.21 (73/73)——
Grouped DW/CG——+2.463 (9/9)899.83 (4/9)+0.386 (73/73)1343.53 (73/73)——
Gilmore–Gomory CG——————-0.783 (5/5)113.38 (5/5)
LLM-LNS+1.187 (5/5)228.85 (3/5)+13.391 (9/9)116.70 (7/9)+52.837 (56/73)304.92 (34/73)-0.294 (5/5)43.68 (4/5)
DRAGON——————+0.002 (5/5)108.21 (2/5)
Reviewer_EsXjOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

DecompPilot is an LLM-agent framework for discovering reusable decomposition strategies for large-scale mixed-integer linear programs. It uses variable and constraint semantics to choose partitions, identify coupling constraints, construct subproblems, coordinate their solutions, and recover a feasible assignment for the original model.

The framework introduces two mechanisms. A Trial Memory Tree records successful and failed instance-level experiments, supporting refinement and backtracking. Decomposition Operator Induction abstracts these histories into operators that are validated across training instances and then frozen for reuse. A multi-agent workflow proposes experiments and diagnoses failures, while deterministic checks assess model coverage and original-model feasibility.

Experiments cover three unit-commitment suites and one bin-packing suite. The reported operators achieve strict feasibility on 121 of 128 non-seed instances. The paper also reports a 52.7% mean reduction in recorded wall time across four suite-level comparisons and a mean signed objective difference of approximately 0.75% relative to finite-time Gurobi incumbents.

The application is worthwhile, and obtaining verified solutions on million-scale instances is promising. My main concerns are the comparability of the runtime results, the distinction between validation and final-test evidence, and the lack of experiments isolating the proposed agent mechanisms.

Critical strengths

Strength 1: The framework grounds agent-generated strategies in deterministic checks against the original optimization problem.

The paper recognizes that successful subproblem execution does not establish feasibility of the assembled solution. It checks variable coverage, bounds, integrality, and every original constraint against an untouched copy of the MILP. Fractional master solutions, locally feasible blocks, and near-feasible reconstructions are explicitly distinguished from valid original-model solutions.

This is an important design choice for LLM-assisted optimization. The negative examples also illustrate why these checks matter: some strategies produce local incumbents but violate global constraints, while aggressive fixing can preserve feasibility yet substantially worsen the objective. Retaining such evidence makes the search process more interpretable.

Strength 2: The work tackles substantial problem sizes and separates operator discovery from intended deployment.

The PEGASE experiments include 73 final-test instances with million-scale formulations. Applying a common operator without transferring incumbent assignments is more useful than demonstrating successful search on isolated instances alone.

The discovered operators also have concrete, inspectable structures: history-aware rolling horizon for CA, generator-based coordination and recovery for FERC and PEGASE, and pattern generation with integer recovery for bin packing. The appendices provide operator schemas and per-instance outcomes rather than only aggregate scores.

The paper is also appropriately explicit that the Gurobi reference is a finite-time incumbent, not necessarily an optimum, and that the reported objective difference is not a solver primal–dual gap. Its disclosure of missing timing records and unsuccessful transfer cases is useful, even though those limitations affect the conclusions that can be drawn.

Critical weaknesses

Weakness 1: The runtime comparisons do not establish a speed advantage at comparable solution quality and reliability.

The proposed operators use heuristic coordination, recovery, and stopping rules, whereas the Gurobi reference may continue optimizing until the time limit. Comparing their termination times therefore does not establish how much faster DecompPilot reaches a given solution quality. A shorter heuristic run can return a worse incumbent before a monolithic solver finishes improving or certifying its solution.

This distinction is important for FERC, where the proposed method succeeds on 15 of 21 non-seed instances and has a mean signed objective difference of +3.423% on feasible runs. The appendix includes individual differences above 10%. The four-suite mean of approximately +0.75% also combines positive and negative signed differences, so it should not be interpreted as a uniform quality guarantee.

The wall-time aggregates additionally have different coverage. Appendix A states that CA has method wall times for 11 of 16 non-seed instances, while FERC has end-to-end wall times for successful recovery runs. Thus, the headline 52.7% reduction combines incomplete timing populations and does not directly summarize a paired, failure-aware comparison over all evaluated instances.

The paper acknowledges these limitations, but they remain material to the main claim. Time-to-target comparisons, incumbent-quality trajectories, and complete paired end-to-end measurements would provide much stronger evidence.

Weakness 2: The experiments do not isolate the contribution of the Trial Memory Tree or Decomposition Operator Induction.

The central methodological claim concerns long-horizon search with structured trial memory and cross-instance induction. However, the experiments primarily evaluate the resulting operators and illustrate selected search histories. I could not identify direct ablations comparing the full framework with linear refinement, a memory-free agent, a simpler trial archive, or reuse of the best seed strategy without induction.

The stopping-policy ablation in Appendix H is informative about the resulting FERC operator, but does not test the necessity of the proposed agent mechanisms.

The agents are also supplied with substantial decomposition knowledge, including rolling horizon, DW/CG, and ADMM-style primitives. This is reasonable, but makes it important to distinguish the value of the agent framework from selecting and tuning established methods. The current baseline set does not fully resolve this question. In particular, the canonical CG mappings for the three unit-commitment suites are unvalidated and are correctly treated as diagnostic results rather than functioning decomposition baselines.

An equal-budget comparison against simpler search over the supplied operator library would help establish whether structured memory and induction provide benefits beyond ordinary configuration search. Discovery costs, repeated-run variability, and the amount of human intervention also need clearer reporting.

Weakness 3: The headline transfer results mix validation and final-test populations, and the post-freeze repair policy needs a clearer audit.

The abstract describes performance on unseen instances, but the 121/128 feasibility result is computed over non-seed instances rather than exclusively final-test instances. Appendix B shows that these populations include validation or development cases: CA includes 11 validation and 5 held-out instances; FERC includes 13 non-seed development cases and 8 held-out cases; PEGASE includes 2 validation and 73 final-test cases; and BinPacking combines development, gate, and final-test instances.

This does not invalidate the non-seed results, but they measure a different quantity from strictly held-out transfer. Because validation outcomes can inform operator revision, the final-test results should be reported separately and used for the headline generalization claim.

The framework also permits implementation-only repairs after final-test failures, subject to a preserved semantic hash and renewed training regression. The policy is described, but the paper should report whether such repairs occurred in the presented experiments and what changed. Preserving a high-level semantic description does not by itself establish that a code change cannot affect test behavior. An audit of repairs and the corresponding before-and-after outcomes would make the frozen-evaluation claim easier to assess.

Finally, transfer is demonstrated within unit-commitment and bin-packing families. This supports family-specific reuse, but provides limited evidence for broader applicability across structurally different MILPs.

Questions for authors

Clarification requests (answers could change my assessment).

  1. How does DecompPilot compare with Gurobi on time to the same feasible objective target? Please provide incumbent-quality trajectories and failure-aware comparisons under matched hardware and thread budgets.

  2. Can the headline wall-time comparison be recomputed using complete, paired end-to-end measurements? How are unsuccessful runs accounted for, and how sensitive is the reported reduction to the missing CA and FERC records?

  3. What happens when the Trial Memory Tree is replaced by linear refinement or a simpler trial archive, and when Operator Induction is replaced by direct reuse of the best seed strategy? Please compare under matched LLM and solver budgets.

  4. What are the results on final-test instances alone, separately from validation and gate cases? Were any implementation repairs made after observing final-test failures? If so, please document their scope and outcomes.

  5. Which LLM and version are used, what are the sampling settings, and what are the total discovery costs in tokens, solver time, elapsed time, and number of trials? How much human intervention was required, and how stable are the discovered operators across independent runs?

Suggestions for revision.

  1. Reframe the headline performance statement around the precise reported quantities: non-seed feasibility, signed finite-time incumbent differences, and recorded wall time with incomplete coverage. Avoid presenting these as a single matched-quality speedup.

  2. Report objective-quality distributions and worst cases alongside means. Separate improvements and degradations so that signed averaging does not obscure weaker outcomes.

  3. Add at least one validated, competitive decomposition baseline for the unit-commitment suites, using comparable semantic information and tuning effort. The diagnostic canonical-CG results cannot substitute for this comparison.

  4. Quantify the amortization of discovery cost. Since reuse is a central motivation, report how many subsequent instances are needed to recover the cost of agent search and validation.

  5. Release the exact prompts, model configuration, trial histories, freeze manifests, solver settings, and repair records alongside the anonymized implementation. Clearly distinguish agent-generated decisions from supplied operator implementations and human-authored infrastructure.

8 comments

Response labels. R1, R2, ... number our response topics within each reviewer. W and Q retain the reviewer's original weakness and question numbers. For EsXj, S6–S10 denote the numbered “Suggestions for revision,” retaining their original numbers. Paragraph numbers count the body paragraphs after each weakness heading; the heading itself is excluded. Each response identifies the original comments it addresses, and closely related requests are answered together.


We thank the reviewer for the careful reading and constructive suggestions. We address the concerns in eight topics below, with references to the corresponding weakness paragraphs, questions, and revision suggestions.

R1. Matched-quality target times, quality distributions, and the updated FERC evaluation.

Response to W1 (paras 1–2 and the trajectory request in para 4), Q1, S6, and S7.

Response. Thank you for highlighting the need to assess runtime at comparable solution quality. We agree that termination times alone are insufficient, and have revised the evaluation in three respects.

  1. Comparable solution quality. We have added time-to-target (TTT) to Table 3 in the revised manuscript and Table E1 below to measure when each method first reaches the same declared objective threshold with a strictly feasible solution. For the UC datasets, the target is a strictly feasible solution with a signed relative objective difference of at most 1.05% from the best feasible objective found by Gurobi (threads=8) within 3600 s. For BinPacking, we require at least one fewer bin than the common FFD initialization, so that fast initialization alone does not count as an improvement. Appendix P also provides data-level mean trajectories for each dataset and instance-level objective–wall trajectories for individual problems.
  2. Improvements and degradations. We also agree that averaging signed differences across datasets can obscure weaker outcomes. We have therefore removed the across-suite signed average from the headline claims and now report the quality and timing outcomes for each dataset separately, together with worst cases and per-instance results.
  3. Matched resource limits (Q1). To address the resource-comparability concern, we now evaluate the main comparison under an eight-logical-CPU ceiling, using eight-thread serial solves or concurrent subproblem solves whose thread budgets sum to at most eight (e.g., 8×1 or 4×2). This ceiling applies to revised Table 3 in the manuscript and the frozen-operator reuse comparison in Table E3b in the response.

FERC update relative to the original submission. The weaker objective–wall convergence on FERC motivated a more informative discovery objective. A reference runtime based only on Gurobi's termination time does not show the agents how quickly it reaches a useful solution. We therefore used the saved Gurobi (threads=8) trajectory up to 3600 s to provide quality-matched feedback: for a candidate's final objective, the reference time is the first saved strictly feasible Gurobi event attaining an equal or better objective. This guided DecompPilot’s search toward a more effective LP-quota generator-group operator. The operator constructs integer decisions through local MILPs, recovers global dispatch through a continuous LP, and invokes a predefined four-group fallback when the initial eight-group stage fails.

The current campaign uses a newly sampled 40%/20%/40% discovery/Validation/Test partition, realized as 10/5/9 instances. The Orchestrator selects two Seeds from the discovery pool; the remaining eight discovery instances do not enter Validation or Test. The instance set remains fixed within a campaign, although a new campaign can sample a different set. We now evaluate the frozen operator and all baselines on the nine FERC Test cases. The details of the discovered operator and data roles are described in Appendices G and R.

Table E1 below (Table 3 in the revised manuscript) presents the updated main results under this evaluation protocol. It includes classical decomposition baselines with automated parameter tuning and two LLM-based baselines, LLM-LNS and DRAGON. The revised agent-search objective uses the saved Gurobi (threads=8) 3600-s trajectories as the reference goal in the system prompt. The additional baseline and ablation evaluations use these same trajectories as their references.

Table E1. Main baseline comparison; induction ablation G is reported separately in E3b.

MethodCACAFERCFERCPEGASEPEGASEBinPackingBinPacking
Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)Δref (%) ↓ (Strict/total ↑)TTT (s) ↓ (Hits/total ↑)
Gurobi (threads=8)+0.000 (5/5)49.14 (5/5)+0.000 (9/9)114.56 (9/9)+0.000 (73/73)294.89 (73/73)+0.000 (5/5)904.32 (2/5)
DecompPilot+0.316 (5/5)96.37 (5/5)+0.246 (9/9)60.89 (9/9)+0.317 (73/73)473.02 (73/73)-0.884 (5/5)49.71 (5/5)
Rolling horizon+0.004 (5/5)58.45 (5/5)——————
Relax-and-fix+0.005 (5/5)96.06 (5/5)+0.042 (9/9)569.46 (9/9)+0.196 (72/73)1907.56 (72/73)——
Generator-wise DW/CG——+1.750 (9/9)940.46 (2/9)+0.372 (73/73)1312.21 (73/73)——
Grouped DW/CG——+2.463 (9/9)899.83 (4/9)+0.386 (73/73)1343.53 (73/73)——
Gilmore–Gomory CG——————-0.783 (5/5)113.38 (5/5)
LLM-LNS+1.187 (5/5)228.85 (3/5)+13.391 (9/9)116.70 (7/9)+52.837 (56/73)304.92 (34/73)-0.294 (5/5)43.68 (4/5)
DRAGON——————+0.002 (5/5)108.21 (2/5)

Reading the two columns. The two columns evaluate final solution quality and feasibility, and the speed and coverage of reaching a common quality target, respectively. Let RiR_i denote the best strictly feasible objective found by Gurobi (threads=8) on instance ii within H=3600H=3600 s. The quality column reports the mean relative objective difference, Δref=100(fi(H)−Ri)/∣Ri∣\Delta_{\rm ref}=100(f_i(H)-R_i)/|R_i|, over strictly feasible outputs, together with strict/total, the number of test instances yielding such outputs. Lower values indicate better solution quality, and negative values indicate improvement over the Gurobi reference. The TTT column reports the average time to first reach the common quality target over instances that reach it, together with hits/total, the number of test instances reaching that target. Thus, the reported times show how quickly targets are reached, while the accompanying counts show how broadly each method succeeds across the test set.

For UC, the target is Ri+0.0105∣Ri∣R_i+0.0105|R_i|. For BinPacking, let BiB_i be the number of bins in the common FFD initialization; the target is Bi−1B_i-1. Necessary initialization, construction, coordination, recovery, polishing, and online LLM waiting remain charged before a hit. Appendix N defines the timing conventions; Appendix P provides data-level and instance-level objective–wall trajectories.

Results. On FERC, DecompPilot and Gurobi both attain 9/9 targets in mean recorded times of 60.89 and 114.56 s, a 46.8% reduction; DecompPilot is faster on all nine cases. On BinPacking, DecompPilot and tuned Gilmore–Gomory CG both attain 5/5 targets, with means of 49.71 and 113.38 s, a 56.2% reduction. These are the fastest non-ablation comparators with matching full target coverage on the respective datasets. DecompPilot also improves one final BinPacking objective and ties the other four. Gurobi reaches only 2/5 BinPacking targets; on those two common-hit instances, its mean is 904.32 s versus 38.13 s for DecompPilot, a 95.8% reduction. This two-instance comparison is reported separately from the full-coverage comparison. Conversely, DecompPilot takes 96.1% longer than Gurobi on CA and 60.4% longer on PEGASE, where both methods attain all targets. Worst DecompPilot reference differences are +0.429%, +1.017%, +0.740%, and −0.493% for CA, FERC, PEGASE, and BinPacking, respectively.

Revised conclusion. The frozen procedures return strictly feasible solutions and reach the declared targets on 92/92 Test instances. Relative to the fastest compared non-ablation baseline with matching full target coverage, mean recorded TTT is lower by 46.8% on FERC and 56.2% on BinPacking. These results support the ability of the framework to discover reusable decomposition operators and faster solution procedures on some problem families. We report dataset-specific outcomes, with complete data-level and instance-level objective–wall trajectories in Appendix P.

R2. Complete timing coverage, unsuccessful runs, and missing historical records.

Response to W1 (para 3 and the complete-measurement request in para 4), Q2, and the timing part of S6.

Response. Following your suggestion, we have revised the main performance statement to distinguish two complementary aspects: final solution quality and the time required to reach a common objective target. We also report the corresponding mean values separately for each dataset in Response 1 (R1).

Records of unsuccessful runs. Table 3 in the revised manuscript reports strict feasibility and target attainment across all test instances, together with final solution quality and conditional mean time-to-target (TTT). Specifically, quality means are computed over strictly feasible outputs, whereas mean TTT is computed over instances that reach the declared target. Runs without a target hit have no observed attainment time and are therefore excluded from this conditional mean, but remain in the denominator of the reported hit count.

The problem of missing CA and FERC records. The revised evaluation includes per-instance active wall-time records for all five CA Test instances and all nine updated FERC Test instances, reported in Appendix N.6, Table 45. The corresponding objective–wall trajectories are provided in Appendix P, while Validation results are reported separately in Appendix R.2.

Timing definitions. Active wall time is the end-to-end execution time of the discovered decomposition algorithm, including model reading, construction, initialization, coordination, recovery, polishing, and any unsuccessful attempts within the run. Parallel stages contribute their actual elapsed span. TTT reads this clock at the first recorded qualifying solution, whereas full execution time is measured at completion. Cumulative solver time sums the Gurobi Runtime of all algorithmic LP/MILP calls, so parallel calls can make it exceed elapsed time. Appendices N and S provide further details.

Table E2. Mean per-instance full execution cost of frozen DecompPilot operators.

DatasetTest casesCumulative solver time (s)Active wall time to completion (s)
CA538.4496.37
FERC9154.6260.89
PEGASE731118.10829.19
BinPacking543.0349.71
CVRPLIB, supplementary278.2431.35

The reported execution costs use the same clocks as TTT. In particular, the PEGASE and CVRPLIB records retain their saved publication/checking costs. Completion time and TTT measure different endpoints: PEGASE reaches its target in 473.02 s on average and completes execution in 829.19 s. Where only a final global solution is timestamped, the reported TTT is a conservative upper bound on first attainment.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.