acceptodds
Under review as a conference paper at ICLR 2027

CoMILP: Evolving Collaborative Solver Components for Mixed-Integer Linear Programming

10 views

Abstract

Mixed-integer linear programming (MILP) is a fundamental framework for solving combinatorial optimization problems. Modern MILP solvers rely on multiple interacting components whose design and configuration strongly influence performance. During the solving process, these components interact repeatedly, with decisions made in one component reshaping the solver states encountered by others. Although existing work in automated algorithm design has improved MILP solving performance, such approaches typically focus on either parameter tuning or heuristic design for a single selected component rather than optimizing jointly across the solver, leaving improvements that require complementary changes across components unexplored. To address this limitation, we propose CoMILP, a large language model (LLM)-driven framework for cross-component algorithm design in MILP solvers. Specifically, CoMILP jointly optimizes initial parameter settings, dynamic configuration policies across components, and decision rules for cut selection and branching. CoMILP employs a multi-agent coordination framework in which LLM agents repeatedly select solver components and edit type, propose a local update, and reflect on solver feedback, thereby enabling scalable optimization across multiple components. Tree search retains alternative refinement paths and balances exploration and exploitation, enabling complementary updates to build on earlier component changes. Experiments on five problem families and MIPLIB 2017 show large improvements over default SCIP, including a 34.4% reduction in primal–dual integral on MIPLIB. Ablations further establish the benefits of cross-component evolution.

Primary area:
optimization
Keywords:
Mixed-integer linear programming, Combinatorial optimization, Automated algorithm design, Large language models, Algorithm configuration, Multi-agent systems

Reviews

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

The paper introduces CoMILP, an LLM-driven framework for cross-component algorithm design in MILP solvers. CoMILP jointly searches over initial configurations, dynamic configuration policies, and decision rules for cut selection and branching. Three LLM agents (planning, proposal, reflection) apply component-level edits. Tree search is used to expand alternative refinement paths and balance exploration and exploitation. In an instance-specific setting, CoMILP attains the lowest solve time or primal-dual integral (often both) among the compared methods on five generated benchmarks and MIPLIB 2017.

Critical strengths

The paper is well motivated and addresses an important limitation of existing LLM-based solver design methods, which focus on either heuristic design or parameter tuning for a single component. The experiments are broad, covering the full MIPLIB 2017 benchmark set and five additional problem families against a comprehensive set of baselines.

Critical weaknesses

The main results are instance-specific: the method optimizes the PDI on a single instance, using 100 trials of up to 300 seconds each. If the objective is a reusable strategy, the paper should show a clear advantage on unseen instances, but CoMILP+Hydra is only compared to default SCIP. If the objective is instead to solve the instance at hand, the quality of the best incumbent found would be a more meaningful measure than the PDI. As it stands, the evaluation falls between these two objectives without convincingly supporting either.

Questions for authors
  • Could you give some insights into why LLM4Branch and MILP-Evo perform worse than SCIP-default on MIPLIB 2017?
  • On unseen instances, CoMILP+Hydra is only compared with SCIP-default. Could you discuss how it compares with the other baselines?
  • Could you report the best incumbent value found by CoMILP and the baselines in your experiments?
5 comments
AuthorsOpenReview ↗

W1 and Q2. Designing strategies for reuse on new instances

Thank you for asking us to clarify the objective and compare unseen-instance performance with the other baselines. CoMILP's contribution is the automated design of effective solver strategies. The instance-specific experiments evaluate the resulting strategies, and the unseen-instance experiments test their reuse. Reported solving time measures strategy execution.

The table below presents the learned-policy and configuration baselines from the paper alongside CoMILP+Hydra. We add a graph neural network (GNN) selector to improve on the original random forest (RF). Each selector is used throughout Hydra, guiding the generation of its own complementary portfolio and selecting a strategy at test time.

The GNN uses the original, unpresolved variable–constraint bipartite graph, combining variable and constraint features with row-normalized coefficient features on edges to predict per-strategy costs. Across all five families, we use two bidirectional GATv2 layers with hidden dimension 64, eight attention heads, sum pooling, and zero dropout. Training uses measured strategy costs and Adam (learning rate 3×10−43\times10^{-4}, weight decay 10−410^{-4}, batch size 4), with a maximum of 1,000 epochs and early-stopping patience of 80 epochs. Each family's checkpoint is selected by the actual mean PDI of the strategies chosen on its validation set, then frozen for testing. Both versions use the same 200/100/100 training/validation/test split, solver seeds, and five-second SCIP-default probe followed by a selected solve of up to 295 seconds.

Table R3.1. Unseen-instance comparison. Mean solving time (s, 300-second cap) and PDI (percentage-seconds), lower is better.

MethodSC TimeSC PDIMIS TimeMIS PDIMK TimeMK PDICA TimeCA PDICFL TimeCFL PDI
SCIP-default120.91008.1219.3687.6121.557.9300.02182.180.9119.4
HEM101.3818.6179.2521.992.644.0300.02377.886.6121.0
Collab67.8559.7167.7549.781.051.3300.01930.169.792.9
DynSep83.7791.3162.8478.254.825.9300.02275.582.3119.4
SMAC-P97.9692.3220.9683.783.330.4300.01979.684.686.6
GP-BO57.0405.3237.3709.786.131.7300.02053.669.183.4
CoMILP+Hydra (RF)75.8636.1196.1486.885.842.9300.02025.077.697.5
CoMILP+Hydra (GNN)54.9400.4163.4481.964.323.7300.01936.764.969.0

GNN-based CoMILP+Hydra achieves the lowest mean PDI on SC, MK, and CFL. It is within 0.8% of the best baseline on MIS and CA and has the lowest mean solving time on SC and CFL. The GNN-based version improves on RF in every family. GNN-guided portfolio construction and test-time selection translate CoMILP's strategy-design gains into improved solving performance on new instances across all five families.

The portfolio and selector are built offline, and each new instance is solved by selecting and executing an existing strategy. On SC, this reuse reduces mean solving time from 120.9 to 54.9 seconds. The design investment is shared across the workload, while solving-time savings accumulate with reuse.

AuthorsOpenReview ↗

W1 and Q3. Incumbents and final optimality gaps

The MIPLIB results also show improvements in feasible solution quality. An incumbent is the best feasible solution found during a solve. We compare its objective value and the final optimality gap with each baseline on the same 240 instances. Pairwise wins, ties, and losses make these comparisons meaningful across MIPLIB's different objective scales and optimization directions. A win means a better feasible objective for that instance, or a smaller final gap.

Table R3.2. CoMILP wins / ties / losses against each baseline on MIPLIB.

ComparatorIncumbent W / T / LFinal-gap W / T / L
SCIP-default100 / 134 / 6117 / 100 / 23
GP-BO71 / 124 / 4580 / 93 / 67
SMAC-I71 / 132 / 3786 / 92 / 62
ColdStart78 / 107 / 55105 / 86 / 49
GRIMIP81 / 105 / 5480 / 92 / 68
LLM4Branch111 / 94 / 35124 / 67 / 49
MILP-Evo76 / 114 / 5090 / 103 / 47

CoMILP wins more often than it loses against every baseline for both metrics. Against GRIMIP, the strongest PDI baseline, CoMILP returns a better incumbent on 81 instances and a worse one on 54. It also finds a feasible solution in 19 cases where SCIP-default fails to do so, compared with two cases in the reverse direction.

Ties include cases where neither method finds an incumbent or both final gaps are infinite. CoMILP's win-loss advantage also holds when both methods find feasible incumbents, and when both have finite final gaps.

AuthorsOpenReview ↗

Q1. Interpreting the MIPLIB PDI results

Thank you for asking why LLM4Branch and MILP-Evo have higher PDI than SCIP-default. Their mean solving times improve, while their PDI increases slightly. PDI integrates the optimality gap over time, so a shorter solve can still have a larger PDI if the gap stays high early in the search.

Table R3.3. Mean solving time and PDI on MIPLIB, lower is better. PDI reduction is relative to SCIP-default.

MethodTime (s)PDIPDI reduction (%)
SCIP-default246.615603.50.0
SMAC-I230.214909.54.4
GP-BO231.213703.612.2
GRIMIP223.812006.023.1
ColdStart245.215041.83.6
LLM4Branch244.716218.2-3.9
MILP-Evo238.415625.0-0.1
CoMILP211.310235.934.4

In our reproductions, we retain each baseline's specified search objective and use PDI when the objective is unspecified or configurable. Accordingly, LLM4Branch optimizes node count [1], which measures search-tree size, and MILP-Evo optimizes solving time [2], which measures time to completion. PDI additionally rewards finding good incumbents and tightening bounds early. This distinction explains why shorter solving times can coexist with a larger PDI.

CoMILP's PDI-guided evolution reduces PDI by 34.4% relative to SCIP-default and also achieves the lowest mean solving time in this comparison.

References

[1] Hou et al. LLM4Branch: Large Language Model for Discovering Efficient Branching Policies of Integer Programs. arXiv, 2026.

[2] Nie et al. MILP-Evo: Closed-Loop Fully Automatic Design of MILP Solvers. arXiv, 2026.

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

This paper proposes CoMILP, an LLM-driven framework for jointly evolving multiple components of a mixed-integer linear programming solver. A complete strategy combines an initial SCIP configuration, dynamic parameter-update policies, and scoring rules for cut selection and branching. Planning, proposal, and reflection agents use solver feedback, documentation retrieval, and shared memory to generate component-level updates. Monte Carlo tree search retains alternative refinement paths, including updates that may become beneficial after subsequent changes. CoMILP reports the lowest mean primal–dual integral (PDI) on nine of eleven benchmark settings, including a 34.4% reduction over SCIP-default on MIPLIB 2017.

Critical strengths
  1. The paper addresses an important problem by jointly optimizing multiple interacting components of a MILP solver rather than focusing on a single component.
  2. The framework is well structured, combining planning, proposal, reflection, memory, and tree search to refine complete solver strategies.
  3. The experimental evaluation is broad and shows strong improvements on both generated benchmarks and MIPLIB 2017, with several useful ablation studies.
Critical weaknesses
  1. The necessity of using LLMs is not sufficiently established. CoMILP combines a larger cross-component search space with MCTS, retrieval, memory, and LLM agents. However, there is no non-LLM baseline that searches the same strategy space under a comparable solver-evaluation budget. It is therefore unclear how much of the improvement comes specifically from LLM reasoning rather than from the enlarged search space and repeated solver evaluations.
  2. The main evaluation is largely instance-specific. Each target instance is given 100 adaptation trials, and the final strategy is then evaluated on different solver seeds of the same instance. This setting demonstrates strong instance-specific tuning, but provides limited evidence of generalization to unseen instances. The Hydra experiment addresses this issue to some extent, but should play a more central role in the evaluation.
  3. The strategy-design cost is not included in the reported solving time. Each target receives up to 100 candidate evaluations, and each solver run can take up to 300 seconds, in addition to the LLM calls. Since the reported solving time excludes this design process, the practical benefit may depend strongly on how often the resulting strategy is reused.
  4. The contributions of the LLM and the search procedure are not fully disentangled. CoMILP uses a specific LLM together with MCTS, but there is limited analysis of how performance changes with different LLMs or simpler search procedures such as greedy search or random tree search. This makes it difficult to identify which part of the framework is mainly responsible for the gains.
Questions for authors
  1. How necessary are the LLM agents for the performance gains of CoMILP? Can the authors compare CoMILP with non-LLM search methods, such as evolutionary search, random search, or MCTS with predefined mutations, using the same cross-component search space and solver-evaluation budget?
  2. How well does CoMILP generalize to unseen instances without instance-specific adaptation? In the main experiments, each target instance receives 100 adaptation trials before evaluation on different solver seeds of the same instance. Can the authors provide more results where the final strategy is applied directly to unseen instances without target-specific search?
  3. What is the total cost of strategy design, and when does this cost become worthwhile? The reported solving time excludes strategy design, while each target requires up to 100 solver evaluations in addition to LLM calls. Can the authors report the total adaptation time and LLM cost, and estimate how many repeated solves are needed to amortize this overhead?
  4. Which part of CoMILP is mainly responsible for the improvement: the LLM, MCTS, or the cross-component search space? Can the authors provide additional ablations using different LLMs and simpler search procedures, such as greedy search or random tree search, while keeping the remaining components fixed?
7 comments
AuthorsOpenReview ↗

Q1. Why use LLMs to evolve solver strategies?

Thank you for asking us to explain why LLMs are suited to this task. CoMILP evolves executable solver heuristics, including the logic that determines when and how different components act.

A candidate contains initial parameter assignments, if-then rules that temporarily change parameters during solving, and feature-based corrections to branching and cut-selection scores. The rules read the solver state, activate an update when their conditions hold, and restore the previous setting after the update expires. The scoring expressions rank the current branching variables or candidate cuts. Together, these instructions determine the solver's behavior across the search.

A learned branching policy selects a variable at a solver decision. Evolving CoMILP's strategy requires producing edits to the instructions governing many future decisions. A learning-based editor must jointly handle parameter values, rule conditions and actions, and scoring expressions, while accounting for the components inherited from the parent strategy.

An RL replacement therefore requires an MDP over strategy revisions. Its state must represent the current configuration, conditional rules, scoring expressions, and execution feedback. Its action must choose a component and edit type and then specify the corresponding program change. Constructing a useful MDP is difficult because its state-action representation must preserve dependencies between executable rules, numerical settings, and scoring expressions. The PDI reward arrives after evaluating the complete revised solver, making exploration expensive and tying the learning signal to the combined effect of its components.

Dividing this task among component-specific editing policies introduces a further coordination problem. Separation settings alter the candidate cut pool and the subsequent LP relaxation, linking cut selection and branching. Consequently, an edit's value depends on the other policies' decisions, and the shared PDI reward must be attributed across interacting edits. Changes by one policy also alter the context in which the others learn. Sequential multi-agent dynamic algorithm configuration studies these decision dependencies and credit-assignment challenges [1].

LLM-based code editing fits this task directly. The LLM reads the complete strategy together with solver trajectories and mechanism documentation, identifies a concrete intervention, and expresses it as an executable edit. The same code-editing mechanism handles parameter assignments, conditional logic, and scoring expressions while keeping the complete strategy in context. Planning, proposal, and reflection keep this reasoning tied to the same evolving strategy. Each edit is checked and evaluated with the inherited components, and its measured effect informs subsequent revisions.

In an SC edit, the planner identified bound closure as the remaining bottleneck after incumbents were found early. It used reliability-branching documentation to revise branching parameters while retaining the parent's separation and heuristic settings. Mean PDI fell from 533.93 to 370.03, a 30.7% improvement.

The following ablations test this use of mechanism knowledge, experience, and specialized reasoning with matched candidate-evaluation and LLM token budgets.

Table R2.1. Ablating knowledge, memory, and agent specialization. Mean solving time (s, 300-second cap) and PDI (percentage-seconds), lower is better.

MethodSC TimeSC PDICA TimeCA PDICFL TimeCFL PDI
SCIP-default183.71610.8300.02222.898.7194.2
No retrieval60.4450.5300.01992.240.8143.3
No memory78.1536.4300.01973.867.2154.0
Single agent54.8449.0300.01834.141.3143.9
CoMILP52.4387.0300.01698.432.497.6

Removing retrieval, memory, or agent specialization worsens mean PDI in every family while preserving the strategy space and search procedure. These controls support the use of mechanism-informed, coordinated editing to evolve complete solver heuristics.

Reference

[1] Lu et al. Sequential Multi-Agent Dynamic Algorithm Configuration. NeurIPS, 2025.

AuthorsOpenReview ↗

Q4. Contributions of coordination, search, and the backbone

Thank you for requesting controls that separate these contributions. Holding the component space and evaluation budget fixed, CoMILP improves on independent assembly in all three families. We also compare MCTS with simpler search procedures and replace the LLM backbone.

Independent combined divides the budget equally across components, optimizes them separately, and combines the results. It has access to the same components as CoMILP. Greedy and Random-tree use the same LLM proposal procedure, refining the best strategy found so far or a strategy chosen uniformly from the search tree. Each method evaluates 100 candidate strategies per instance on the paper's ablation benchmarks.

Table R2.2. Coordination and search controls. Mean solving time in seconds and PDI, lower is better.

MethodSC TimeSC PDICA TimeCA PDICFL TimeCFL PDI
SCIP-default183.71610.8300.02222.898.7194.2
Independent combined133.01110.6300.01910.661.2160.8
Greedy65.4467.3300.01674.860.7126.5
Random-tree91.7657.8300.01729.574.0133.1
CoMILP52.4387.0300.01698.432.497.6

With component coverage and total budget matched, joint evolution improves PDI over independent assembly in all three families. Evaluating edits within the current complete strategy lets subsequent proposals account for changes to other components. With the LLM proposal procedure fixed, MCTS improves over Random-tree in all three families and over Greedy on SC and CFL. Greedy's PDI is 1.4% lower on CA. These search controls support allocating evaluations across alternative refinement paths.

All six LLM backbones reduce PDI relative to SCIP-default in all three families under the same CoMILP framework.

Table R2.3. CoMILP with different LLM backbones. Mean solving time in seconds. Impr. is PDI reduction from SCIP-default (%).

BackboneSC TimeSC PDISC Impr. (%)CA TimeCA PDICA Impr. (%)CFL TimeCFL PDICFL Impr. (%)
SCIP-default183.71610.80.0300.02222.80.098.7194.20.0
GLM-5.3-flash61.0402.875.0300.01725.622.466.6113.241.7
Qwen3.5-397B-A17B73.4472.570.7300.01711.723.043.872.562.7
Composer-2.596.2706.456.1300.01759.520.880.5130.932.6
DeepSeek-flash68.5653.759.4300.01736.021.956.2124.236.0
GPT-5.6-Luna62.4542.866.3300.01722.322.540.684.656.4
GPT-5.6-Terra (original)52.4387.076.0300.01698.423.632.497.649.7
AuthorsOpenReview ↗

Q2 and Q3. Generalization and the value of strategy reuse

Thank you for asking how strategy reuse can justify the design cost. GNN-based CoMILP+Hydra applies previously generated strategies to unseen instances and achieves the lowest mean PDI on three of the five benchmarks. Strategy generation and selector training take place offline. For each new instance, the selector chooses a portfolio strategy that SCIP then executes. The table below includes the learned-policy and configuration baselines from the paper and adds a graph neural network (GNN) selector to improve on the original random forest (RF). Each selector is used throughout Hydra, guiding the generation of its own complementary portfolio and selecting a strategy at test time.

The GNN uses the original, unpresolved variable–constraint bipartite graph, combining variable and constraint features with row-normalized coefficient features on edges to predict per-strategy costs. Across all five families, we use two bidirectional GATv2 layers with hidden dimension 64, eight attention heads, sum pooling, and zero dropout. Training uses measured strategy costs and Adam (learning rate 3×10−43\times10^{-4}, weight decay 10−410^{-4}, batch size 4), with a maximum of 1,000 epochs and early-stopping patience of 80 epochs. Each family's checkpoint is selected by the actual mean PDI of the strategies chosen on its validation set, then frozen for testing. Both versions use the same 200/100/100 training/validation/test split, solver seeds, and five-second SCIP-default probe followed by a selected solve of up to 295 seconds.

Table R2.4. Unseen-instance comparison. Mean solving time in seconds and PDI, lower is better.

MethodSC TimeSC PDIMIS TimeMIS PDIMK TimeMK PDICA TimeCA PDICFL TimeCFL PDI
SCIP-default120.91008.1219.3687.6121.557.9300.02182.180.9119.4
HEM101.3818.6179.2521.992.644.0300.02377.886.6121.0
Collab67.8559.7167.7549.781.051.3300.01930.169.792.9
DynSep83.7791.3162.8478.254.825.9300.02275.582.3119.4
SMAC-P97.9692.3220.9683.783.330.4300.01979.684.686.6
GP-BO57.0405.3237.3709.786.131.7300.02053.669.183.4
CoMILP+Hydra (RF)75.8636.1196.1486.885.842.9300.02025.077.697.5
CoMILP+Hydra (GNN)54.9400.4163.4481.964.323.7300.01936.764.969.0

The lowest mean PDI is obtained on SC, MK, and CFL, with results within 0.8% of the best baseline on MIS and CA. The GNN-based version improves on RF in every family. GNN-guided portfolio construction and test-time selection improve the transfer of CoMILP's evolved strategies to new instances.

The corresponding use case is a recurring workload that shares an offline strategy-design investment. Once the portfolio and selector are built, each new instance incurs selection and solving costs. On unseen SC instances, mean solving time falls from 120.9 to 54.9 seconds, a measured saving of 66 seconds per instance through reuse of the offline-designed strategies.

For a concrete measure of the design investment, the table below reports the mean design cost per instance for CoMILP on the paper's CFL benchmark (100 facilities, 400 customers).

Table R2.5. Mean design cost per instance for CoMILP on CFL (100 facilities, 400 customers), with 100 candidate strategies evaluated per instance.

Candidates per instanceSolver (h)LLM calls (h)Search interval (h)Input (M)Cached input (M)Output (M)
1008.202.7610.999.312.780.342

Costs are averaged across instances in this CFL benchmark. Solver and LLM times are cumulative within each search. The search interval runs from the first to the last solver evaluation. Mean total token usage is 9.65 million per instance, with cached input included in the input count.

On the paper's CFL benchmark (100 facilities, 400 customers; Table 19), CoMILP reduces mean solving time from 169.1 to 137.4 seconds and mean PDI from 471.5 to 219.4, corresponding to an 18.7% reduction in mean solving time and a 53.5% PDI reduction. Portfolio construction and selector training are shared offline costs, and each new instance reuses the resulting strategies through selection and execution. The practical return is the accumulated solving-time saving across that workload, supported here by competitive PDI against strong baselines and the measured time reductions on new instances.

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

This paper proposes CoMILP, an LLM-driven framework for jointly evolving multiple MILP solver components. It integrates multi-agent coordination, Monte Carlo tree search, and solver feedback to optimize configurations and decision policies. Experiments on five problem families and MIPLIB 2017 demonstrate improvements over existing methods, including a 34.4% reduction in primal–dual integral on MIPLIB.

Critical strengths
  1. The joint optimization of interacting MILP solver components addresses a practically important problem.
  2. The integration of multi-agent coordination, tree search, and solver feedback is well motivated.
  3. Experiments cover diverse MILP benchmarks and competitive baselines, demonstrating promising performance improvements.
  4. The ablation studies provide evidence supporting the benefits of coordinated component optimization.
Critical weaknesses
  1. The contribution of cross-component synergy is not fully isolated from the benefits of a larger search space.
  2. The effectiveness of Monte Carlo tree search lacks direct comparison with simpler search strategies.
  3. The total computational overhead, including LLM inference and strategy evolution, is insufficiently evaluated.
  4. Generalization improvements are considerably smaller than instance-specific gains.
  5. Statistical uncertainty and sensitivity to different LLMs are insufficiently explored.
Questions for authors
  1. Can the authors compare joint evolution with independently optimized components combined afterward?
  2. How does CoMILP compare with simpler search strategies under matched evaluation budgets?
  3. What is the total computational cost of strategy evolution, including LLM inference?
  4. Why are the improvements on unseen instances smaller than those from instance-specific optimization?
  5. How robust are the results across different LLMs and independent evolution runs?
6 comments
AuthorsOpenReview ↗

Q1. Joint versus independent component optimization

Thank you for suggesting a direct comparison with independently optimized components. CoMILP's joint evolution achieves lower PDI in all three families with the same component space and total search budget.

Independent combined divides the budget equally across components, optimizes each with the others at their defaults, and combines the resulting strategies. CoMILP allocates its search budget while evaluating and refining complete strategies. Each method evaluates 100 candidate strategies per instance on the paper's ablation benchmarks, with 25 instances per family.

Table R1.1. Joint evolution, independent assembly, and component ablations. Mean solving time (s, 300-second cap) and PDI (percentage-seconds), lower is better.

MethodSC TimeSC PDICA TimeCA PDICFL TimeCFL PDI
SCIP-default183.71610.8300.02222.898.7194.2
Branching only132.0991.5300.02071.562.3132.6
No branching90.5762.5300.01962.752.1121.4
Initial config. only75.6612.2300.02125.045.8154.5
Policies only106.1722.3300.02126.742.7130.1
Independent combined133.01110.6300.01910.661.2160.8
CoMILP52.4387.0300.01698.432.497.6

CoMILP reduces PDI relative to independent assembly by 65.2% on SC, 11.1% on CA, and 39.3% on CFL. Assembly changes the setting in which each component was optimized, so a previously beneficial edit can become counterproductive. CoMILP evaluates edits with the current settings of all other components, allowing later proposals to respond to their combined behavior.

To examine component interactions, we remove each component's edits from an independently assembled CFL strategy and measure mean PDI.

Table R1.2. Component interactions in an independently assembled CFL strategy. Mean PDI and its change relative to the complete assembly. Negative values indicate improvement.

StrategyPDIPDI change (%)
SCIP-default412.69+13.0
Remove branching340.02-6.9
Remove conflict analysis359.04-1.7
Remove cut selection327.72-10.3
Remove LP settings314.47-13.9
Remove node selection397.74+8.9
Remove presolve501.61+37.3
Remove primal heuristics427.31+17.0
Remove propagation413.85+13.3
Remove separation/cut management387.16+6.0
Remove separator frequency384.84+5.3
Independent combined365.360.0

Removing the edits to any one of four components improves mean PDI, including a 13.9% reduction from removing the LP edits. Separately optimized edits can therefore weaken the assembled strategy.

AuthorsOpenReview ↗

Q2. MCTS versus simpler search strategies

MCTS improves over Random-tree in all three families and over Greedy on SC and CFL. Both alternatives use CoMILP's strategy representation, LLM proposal procedure, and evaluation budget. Greedy always refines the best strategy found so far. Random-tree chooses a strategy uniformly from the search tree for refinement.

Table R1.3. Search methods with the same evaluation budget. Mean solving time in seconds and PDI, lower is better.

MethodSC TimeSC PDICA TimeCA PDICFL TimeCFL PDI
SCIP-default183.71610.8300.02222.898.7194.2
Greedy65.4467.3300.01674.860.7126.5
Random-tree91.7657.8300.01729.574.0133.1
CoMILP52.4387.0300.01698.432.497.6

MCTS's advantage over Random-tree supports using solver feedback to prioritize refinement. Its PDI reductions of 17.2% on SC and 22.8% on CFL relative to Greedy support retaining alternative paths for later component edits. The two methods are close on CA, where Greedy's PDI is 1.4% lower.

AuthorsOpenReview ↗

Q3 and Q4. Generalization and the value of strategy reuse

Thank you for asking about both unseen-instance performance and the cost of strategy design. CoMILP's design investment produces strategies that can be reused across new instances. The table below compares CoMILP+Hydra with the learned-policy and configuration baselines already included in the paper and adds a graph neural network (GNN) selector.

Instance-specific evolution tailors edits using feedback from the target instance. For reuse, Hydra's selector guides both the generation of complementary portfolio strategies and the assignment of strategies to new instances. We strengthen this process by using a GNN in place of the original random forest (RF) throughout portfolio construction and deployment. Each version therefore generates its own portfolio. The GNN-based version improves PDI in all five families, including reductions of 37.1% on SC and 29.2% on CFL relative to the RF version.

The GNN uses the original, unpresolved variable–constraint bipartite graph, combining variable and constraint features with row-normalized coefficient features on edges to predict per-strategy costs. Across all five families, we use two bidirectional GATv2 layers with hidden dimension 64, eight attention heads, sum pooling, and zero dropout. Training uses measured strategy costs and Adam (learning rate 3×10−43\times10^{-4}, weight decay 10−410^{-4}, batch size 4), with a maximum of 1,000 epochs and early-stopping patience of 80 epochs. Each family's checkpoint is selected by the actual mean PDI of the strategies chosen on its validation set, then frozen for testing. Both versions use the same 200/100/100 training/validation/test split, solver seeds, and five-second SCIP-default probe followed by a selected solve of up to 295 seconds.

Table R1.4. Unseen-instance comparison. Mean solving time in seconds and PDI, lower is better.

MethodSC TimeSC PDIMIS TimeMIS PDIMK TimeMK PDICA TimeCA PDICFL TimeCFL PDI
SCIP-default120.91008.1219.3687.6121.557.9300.02182.180.9119.4
HEM101.3818.6179.2521.992.644.0300.02377.886.6121.0
Collab67.8559.7167.7549.781.051.3300.01930.169.792.9
DynSep83.7791.3162.8478.254.825.9300.02275.582.3119.4
SMAC-P97.9692.3220.9683.783.330.4300.01979.684.686.6
GP-BO57.0405.3237.3709.786.131.7300.02053.669.183.4
CoMILP+Hydra (RF)75.8636.1196.1486.885.842.9300.02025.077.697.5
CoMILP+Hydra (GNN)54.9400.4163.4481.964.323.7300.01936.764.969.0

GNN-based CoMILP+Hydra achieves the lowest mean PDI on SC, MK, and CFL and is within 0.8% of the best baseline on MIS and CA.

The design cost is paid when constructing the strategies, and reuse spreads that investment across subsequent solves. On the paper's CFL benchmark (100 facilities, 400 customers), solver evaluations took an average of 8.20 hours per instance and LLM calls took an average of 2.76 hours per instance.

Table R1.5. Mean design cost per instance for CoMILP on CFL (100 facilities, 400 customers), with 100 candidate strategies evaluated per instance.

Candidates per instanceSolver (h)LLM calls (h)Search interval (h)Input (M)Cached input (M)Output (M)
1008.202.7610.999.312.780.342

Costs are averaged across instances in this CFL benchmark. Solver and LLM times are cumulative within each search. The search interval runs from the first to the last solver evaluation. Mean total token usage is 9.65 million per instance, with cached input included in the input count.

Table R1.6. Mean strategy performance on the paper's CFL benchmark (100 facilities, 400 customers; Table 19). Results average four held-out solver seeds per instance and then 25 instances. Impr. is PDI reduction from SCIP-default.

MethodTime (s)PDIImpr. (%)
SCIP-default169.1471.50.0
CoMILP137.4219.453.5

On this CFL benchmark, CoMILP reduces mean solving time by 18.7% relative to SCIP-default. On unseen SC instances, mean solving time falls from 120.9 to 54.9 seconds, a measured reduction of 66 seconds per instance. CoMILP's design investment thus produces strategies whose solving benefits extend to new instances.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Rebuttal Discussion for Reviewers and AC

Dear Reviewers and AC,

We thank the three reviewers for their careful reviews and for acknowledging the following strengths of our work:

  • Addresses a practically important problem by jointly optimizing configurations and heuristic rules across interacting MILP solver components. (xveQ, rZVm, ZswP)
  • Presents a well-motivated, well-structured framework combining coordinated component updates, tree search, and solver feedback. (xveQ, rZVm)
  • Provides a broad evaluation across five problem families and MIPLIB 2017 against competitive baselines. (xveQ, rZVm, ZswP)
  • Includes useful ablation studies supporting the benefits of coordinated component optimization. (xveQ, rZVm)

The table below summarizes the main concerns of the reviewers and our responses. In the revised manuscript, the changes are highlighted in red.

ConcernByOur response
Generalization & strategy reusexveQ (W4/Q4), rZVm (W2/Q2), ZswP (W1/Q2)We moved the unseen-instance evaluation to the main text against all neural and configuration baselines and added GNN-guided portfolio construction and selection, outperforming or closely matching the strongest baseline across all five families without target-specific search (Section 4.5 and Appendix B.5).
Design cost & amortizationxveQ (W3/Q3), rZVm (W3/Q3), ZswP (W1)We reported total evolution and LLM overhead, showing that solver evaluations dominate runtime: end-to-end SC preparation (113.4 h) is comparable to GP-BO and SMAC-P (97.9–118.2 h) and amortizes over unseen solves with no test-time LLM cost (Appendix F.5).
Cross-component synergy & MCTSxveQ (W1/Q1, W2/Q2), rZVm (W4/Q4)Under the same multi-component space and evaluation budget, we showed that independently tuned edits can conflict when assembled whereas joint evolution substantially lowers PDI, and that MCTS overall outperforms simpler random-tree and greedy search (Section 4.3, Table 2, and Appendices F.1 and F.4).
Necessity of the LLM editorrZVm (W1/Q1, W4; follow-up)We showed that replacing the LLM editor with EA or SMAC under the same strategy space, MCTS loop, and budget increases mean PDI in all three families, and that CoMILP restricted to a core parameter subset still outperforms full-space EA and SMAC (Section 4.3, Table 2, and Appendix F.7).
LLM sensitivity & run variancexveQ (W5/Q5), rZVm (W4/Q4)We showed that five additional LLM backbones all improve PDI over SCIP-default across every benchmark and that independently initialized runs prove the same optimum with consistent PDI reductions (Section 4.3, Table 2, and Appendices F.2 and F.3).
Incumbents & baseline objectivesZswP (W1/Q1, Q3)For instance-specific solving, we showed that CoMILP achieves more wins than losses against every baseline on both best incumbents and final gaps across MIPLIB 2017, and clarified how differing baseline objectives relate to PDI (Section 4.2, and Appendices A.4, E.1, and F.6).

Accordingly, we have revised the manuscript to clarify our claims and incorporate these new analyses—in particular, expanding Section 4.3 (cross-component synergy, search, non-LLM editor, and backbone controls) and Section 4.5 (unseen-instance portfolio reuse). Please refer to our individual responses and the revised PDF for details.

We are sincerely grateful to the reviewers and the AC for their time and constructive suggestions, which have helped us improve our paper.

Best regards,

The authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.