Mixed-integer programming solvers expose hundreds or even thousands of parameters whose best setting varies per instance, yet per-instance search is prohibitively expensive. We frame this as configuration for heterogeneous Big Data optimization workloads and propose a nominate-then-adjudicate pipeline built around two design choices. First, a fixed portfolio is sampled once and reused across instances, removing per-instance configuration search at inference; on the evaluated families, the resulting shortlist retains substantial oracle headroom, making selection within it the empirical focus. Second, the fixed 20-feature representation can map structurally different instances to the same vector, preventing a feature-only selector from distinguishing them even when they prefer different configurations. The foundation model receives no task-specific weight updates, and selection is one-pass: one model call and no solver calls at inference. The study represents structural Variety through distinct formulation families and decision Value through solver-performance outcomes; the one-call, zero-solve protocol specifies the decision interface and leaves end-to-end latency unmeasured. Among comparisons exceeding a 20% practical-difference threshold, the complete adjudicator records 538 wins and 185 losses against the top nominee, while its win rate against the default rises from 84.9% to 90.2%. Against per-instance configuration baselines under a matched one-pass protocol it leads the cluster-level methods and the best-performing evaluated per-instance baseline, ISAC+.
Figures & tables
Fig. 1: The nominate-then-adjudicate pipeline. The instance is read twice: one path abstracts it into 20 features that, with each candidate’s 30 parameters, are all the EPM sees; the other passes a compressed constraint matrix to the adjudicator. Portfolio, EPM and skill memory are built offline, so inference is one model call and no solve.
TABLE II: The 30 configured SCIP parameters and their candidate values.
Fig. 2: Feature degeneracy, illustrated on one shared seed (drawn small; 99 vertices, 1094 edges). The independent-set and vertex-cover models differ only in constraint sense and objective direction, neither of which reaches the feature vector, so their 20 features are byte-identical and the nominator must return one shortlist for both. Their measured preferred portfolio configurations differ, and reading the matrix lets the adjudicator pick a different configuration for each (here identifiers 47 and 0 , against a shared top nominee 37 that is slower than the default on both). The numbers illustrate one pair and provide no aggregate estimate.
Fig. 3: Offline construction and refinement of textual skill memory. Cold start induces family-indexed rules from a solved shortlist batch. Later rounds refine, prune and induce rules from measured nominee outcomes; a held-out batch selects the snapshot used online. Model weights remain fixed.
Fig. 4: Per-round record of all five width runs over ten rounds. Top: margin over the top nominee. Middle: deviation rate (dotted linear trends). Bottom: deviation precision. Curves are ordered by k .
k=3
k=5
k=10
k=15
k=20
mean score
0.401
0.409
0.426
0.431
0.434
top-1
0.380
0.379
0.377
0.378
0.378
margin
+0.021
+0.031
+0.049
+0.054
+0.056
oracle
0.491
0.521
0.556
0.572
0.585
headroom
0.112
0.142
0.179
0.194
0.207
harvested
19.2%
21.5%
27.3%
27.7%
27.1%
TABLE III: Shortlist width sweep on the ten 160 -instance batches completed in all five runs ( 1600 instances each). Scores are means over instances; margin is adjudicator minus top-1, headroom is oracle minus top-1, and harvested is margin as a share of headroom. Best width per row in bold where one exists; harvested is unbolded because it is flat from k=10 on.
Fig. 5: Why k=10 . Left: widening the shortlist raises the best-of- k ceiling steadily, but the realized margin flattens after k=10 ; labels give the share of the ceiling harvested, which sits at about 27% for every k≥10 . Right: both costs (prompt tokens and solves per batch) are linear in k . Past k=10 the added ceiling yields negligible realized speedup.
Fig. 6: Where the shortlist mass sits, on the batches shared by all five runs. Left: the rank of the best candidate; right: the rank the adjudicator picks. At k=20 the best candidate often lies past rank 10 and the adjudicator does reach into that tail, but those extra candidates add no margin (Table III ).
Random
no-LLM
with-LLM
Mean score
0.365
0.377
0.426
Win rate vs. default
84.9%
84.9%
90.2%
Median speedup
2.34×
2.43×
2.69×
SGM speedup
1.35×
1.37×
1.42×
Default time saved
41.1%
43.8%
50.4%
Picks the best of 10
10.0%
9.1%
22.5%
TABLE IV: The ablation: chooser implementations over a fixed shortlist. All arms use the same 10 nominees on the same 1600 held-out instances. The with-LLM arm comprises the matrix, skill memory and foundation-model adjudicator, while no-LLM returns the EPM top nominee; a hindsight oracle over the same ten scores 0.556 . Lower block: with-LLM against no-LLM, per instance.
Fig. 7: Margin over the top nominee by family, round by round, at the selected width k=10 ; panels are ordered by mean margin, which is given in each title, and share one vertical scale. Fourteen of sixteen families are positive on average and eight never dip below zero; the damage concentrates in cutting stock.
default
ours ( k=10 )
no-LLM
ISAC+
ISAC+SMAC
ISAC+ROAR
Aggregate, all four families ( n=400 )
Mean score
0.0000
0.5638
0.5429
0.5441
0.4933
0.4318
SGM speedup
1.00
4.48
4.28
4.29
3.66
3.04
Win rate vs. default
—
99.0%
97.8%
98.0%
96.8%
95.5%
Default time removed
—
69.6%
66.4%
66.0%
62.8%
59.2%
Δ vs. ours
—
—
+0.0209
+0.0197
+0.0705
+0.1321
TABLE V: Baselines under a matched one-pass protocol, 400 held-out instances, all arms re-measured in one session against a shared default (round-robin, median of three). Per row, gold is first, silver second, bronze third. Δ is our mean score minus the arm’s; “above threshold” counts instances whose runtimes differ by more than the 20% practical-difference threshold. no-LLM returns the EPM’s top nominee from the same shortlist and portfolio; the matrix–memory–foundation-model adjudicator bundle is absent.
time to gap (s)
mas76
50v-10
(gap 0.001 )
(gap 0.15 )
SCIP default
172.0
68.0
ISAC+ROAR
123.2
83.0
ISAC+SMAC
363.8
55.0
ISAC+
428.6
38.0
ours
87.2
22.0
TABLE VI: Wall-clock time (s) to an instance-specific relative gap on two feature-range-compatible MIPLIB 2017 cases; lower is better. Each instance’s five arms share one measurement session and default run.
Configuring the hyperparameters of Mixed-integer programming (MIP) solvers is a high-dimensional, instance-dependent optimization problem where suboptimal settings can degrade solving time by orders of magnitude. Default configurations are often suboptimal, while traditional tuning methods either suffer from the ``cold-start'' problem and inefficient search or heavily rely on expert experience. This paper introduces GRIMIP (General Reasoning for Instance-specific MIP configuration), a novel hybrid intelligence framework that synergistically integrates the semantic reasoning capabilities of Large Language Models (LLMs) with the sample-efficient search of Bayesian Optimization (BO). GRIMIP enables the LLM to function as a complete probabilistic surrogate within the BO loop, significantly improving performance and reducing sampling and evaluation costs. On seven benchmarks including MIPLIB, GRIMIP achieves over 40% reduction in Primal-Dual Integral on hard instances, outperforming SMAC and other LLM-assisted BO methods. By granting LLMs sufficient autonomy, GRIMIP combines the expert-level reasoning of LLMs with the efficient search of BO, achieving state-of-the-art performance.
Yidong Luo, Xuemin Chen, Chenguang Wang +3
School of Data Science, The Chinese University of Hong Kong, Shenzhen · School of Science and Engineering, The Chinese University of Hong Kong, Shenzhen · Noah’s Ark Lab, Huawei
Generating optimization instances that are both feasible and computationally challenging is crucial for benchmarking solvers and training learning-based optimization algorithms. Existing non-LLM generators rely on seed instances or parameter tuning, resulting in high test-time computational cost, while existing LLM generators lack explicit hardness measures. Recent reinforcement learning methods with verifier feedback evaluate only binary correctness, which is misaligned with generating challenging problems. We note that an optimization solver reports the cost of solving at several stages of its pipeline, and leverage this to design a reward that scores both the solvability and the hardness of generated problems, measured by branch-and-bound nodes and post-cut relaxation gaps. Our key idea is a challenger-solver asymmetric self-play approach, where an LLM challenger generates progressively harder instances and the solver verifies feasibility and hardness, so no seed or training MILP instances are required. We fine-tune Gemma-4-12B and Qwen3.5-4B with GRPO and a size curriculum into OptiScribe-12B and OptiScribe-4B, which generate feasible yet challenging MILP problems from natural language instructions. On capacitated facility location and max-cut, OptiScribe-12B raises median SCIP search nodes by 1.7-5x and post-cut gaps by 1.1-1.7x over its base model and improves the feasibility rate on facility location by 9-19 points, while OptiScribe-4B raises median nodes by up to 15.6x. The problems cover a wider difficulty range than public benchmarks of the same size, follow instructions on density and difficulty, and can tune solver settings for families that public libraries lack. These results indicate that optimization-specific rewards, used in self-play mode, can teach LLMs to generate high-difficulty optimization benchmarks. We will release our code and models publicly on acceptance.
Optimization problems are pervasive in sectors from manufacturing and distribution to healthcare. However, most such problems are still solved heuristically by hand rather than optimally by state-of-the-art solvers because the expertise required to formulate and solve these problems limits the widespread adoption of optimization tools and techniques. We introduce a Large Language Model (LLM)-based system designed to formulate and solve (mixed integer) linear programming problems from their natural language descriptions. Our system can develop mathematical models, write and debug solver code, evaluate the generated solutions, and improve efficiency and correctness of its model and code based on these evaluations. OptiMUS is designed as a productivity tool for optimization practitioners who understand the problem domain and can describe it precisely, but seek to accelerate the modeling and implementation workflow. OptiMUS-0.3 utilizes a modular structure to process problems, allowing it to handle problems with long descriptions and complex data without long prompts. Experiments demonstrate that OptiMUS-0.3 outperforms direct-prompting baselines by over 43% on easy and 18% on hard instances. It remains competitive with fine-tuned specialist models on benchmark problems, and outperforms them on real-world case studies (28.6% vs. 0%) where fine-tuned models fail to generalize. Ablation studies show that modular architecture with error correction is central to these gains. A key finding is that system architecture is a stronger driver of performance than model capability. Structured decomposition with targeted error correction enables weaker models to match stronger models under naive prompting, and remains competitive with fine-tuned specialist models without retraining costs.
Ali AhmadiTeshnizi, Wenzhi Gao, Herman Brunborg +3
a School of Management Science and Engineering, Stanford University, Stanford, California 94305 · b Institute for Computational and Mathematical Engineering, Stanford University, Stanford, California 94305