LLM-guided Cutting-plane Management for Mixed-integer Linear Programming

1 Introduction

Mixed-integer linear programming (MILP) has been widely used in supply chain management [Andrade-Pineda et al., 2017], production planning [Mahmoud et al., 2023], scheduling [Chen, 2010], facility location [Caselli et al., 2022] and bin packing [Mhiri, 2024]. A standard MILP can be formulated as follows:

where c ∈ Rn is the coefficient vector, A ∈ Rm×n is the constraint matrix, b ∈ Rm is the constant vector, x ∈ Rn is A B C D E A B C D E A B C D E objective value of the problem. Modern MILP solvers typically adopt a branch-and-cut (B&C) framework, which combines a branch-and-bound (B&B) tree search with cuttingplane techniques. The B&B procedure systematically partitions the search space into smaller subproblems by branching on decision variables. At each node of the search tree, cutting planes are added to tighten the linear programming (LP) relaxation, thereby improving the lower bound and accelerating the solving process.

∗Corresponding author: Jie Shao.

In cutting-plane-based MILP solving, solver performance is largely determined by cutting-plane management, which comprises two core components: separator configuration and cut selection. Modern MILP solvers implement various cutting-plane generating algorithms, also referred to as separators, to generate cutting planes that tighten the LP relaxations, such as Gomory, clique and flowcover. As illustrated in Figure 1, which reports the results under five different separator configurations (A-E), each configuration is executed five times using the solver's default parameter settings. From this figure, we observe high inter-type diversity in separator configurations: the performance varies substantially across different separator configurations for each problem type. For example, configuration D yields better results for both Carlot and MIS instances, but performs poorly on Knapsack instances. This indicates that different types of MILP problem benefit from different separator settings, and that an inappropriate configuration can severely impair solution quality. However, separator configuration remains relatively underexplored in both the academic literature and solver implementations, where it is typically manually tuned by human experts. For cut selection, the effectiveness of a cut-filtering rule can vary substantially across different stages of the B&B search. However, most MILP solvers still rely on a single fixed, hand-crafted heuristic applied uniformly throughout the search, without adapting to the evolving tree state. Recent studies have explored using machine learning to improve cut selection [Gasse et al., 2019; Huang et al., 2022; Tang et al., 2020; Paulus et al., 2022]. However, these learning-based approaches typically require large amounts of training data and often generalize poorly to unseen instance distributions or problem types.

In this paper, we propose a novel cutting-plane management framework that incorporats LLMs to enhance MILP solving. First, we use CoT prompting to infer an instancespecific separator configuration, determining which separators to activate and how to set their key control parameters (e.g., separation frequency, the maximum number of separation rounds, and the maximum separation depth) based on the problem type and structural characteristics (e.g., numbers of variables and constraints, integrality ratio, and objective structure). Next, since the most effective cuts can vary across different stages of the branch-and-bound search, we condition on the evolving tree state and use the LLM to generate stage-aware cut-selection heuristics and executable code to filter the candidate cut pool, thereby improving overall solver performance. We integrate our approach into the state-of-theart open-source MILP solver SCIP [Bestuzheva et al., 2023] and show that LLM-guided cut management yields notable improvements in solution quality compared with competitive heuristic-based and learning-based baselines.

In summary, our contributions are as follows:

• We introduce an LLM-guided cutting-plane management framework for MILP solving that automates both separator configuration and cut selection, substantially reducing reliance on manual tuning and expert-crafted rules.
• We develop (i) an instance-structure-aware separator tuning mechanism that uses CoT reasoning to jointly decide separator activation and key parameter values, and (ii) a stage-aware heuristic evolution mechanism that monitors the evolving B&B state and generates executable cut-selection policies (code) to filter cuts. Together, these mechanisms significantly improve the effectiveness of cutting-plane-based MILP solving.
• We conduct comprehensive experiments on five widely studied optimization problems, demonstrating that our LLM-guided approach achieves competitive performance.

2 RelatedWork

2.1 Machine Learning for MILP

In recent years, leveraging machine learning to enhance the performance of MILP solvers gains considerable attention [Bengio et al., 2021; Gasse et al., 2021; Gasse et al., 2019]. Traditional solvers rely heavily on hand-crafted heuristics to make critical decisions during the solving process [Achterberg, 2007], and recent studies explore replacing these heuristics with learned models [Bengio et al., 2021]. This paradigm shift leads to notable improvements in various solver components, including cut selection [Tang et al., 2020; Paulus et al., 2022; Khalil et al., 2016], variable branching [Zarpellon et al., 2021; Balcan et al., 2018; Gasse et al., 2019], node prioritization [He et al., 2014; Sabharwal et al., 2012], column generation [Yuan et al., 2024], and primal heuristic selection [Khalil et al., 2017; Hendel et al., 2018]. In this work, we focus on cut selection management, a key factor influencing solver performance.

In the context of cut selection, a number of learning-based approaches emerge to prioritize cuts by learning a scoring function that reflects their effectiveness [Huang et al., 2022; Tang et al., 2020; Paulus et al., 2022]. For instance, Tang et al. [2020] introduce a reinforcement learning method that learns to evaluate Gomory cuts [Edmunds and Bard, 1992] and selects the one with the highest predicted score. Similarly, Paulus et al. [2022] propose a lookahead-based rule that selects cuts expected to yield the greatest improvement in the dual bound, and learns this rule via imitation learning. Extending beyond the selection of a single best cut, Huang et al. [2022] formulate the task as a multiple instance learning problem, where a scoring function identifies a fixed proportion of high-quality cuts. In addition to determining which cuts to keep, Wang et al. [2023] introduce hierarchical sequential model (HEM) to investigate the preferred order in which selected cuts should be applied-an aspect that also affects the efficiency of solving MILPs. However, most existing methods overlook the importance of deciding the appropriate number and sequence of cuts. Meanwhile, Turner et al. [2023] explore a hybrid approach that learns to combine expert-designed scoring rules via learned weights. On the theoretical front, Balcan et al. [2021] provide provable guarantees for learning-based cut selection strategies. While cut selection has received increasing attention, the complementary task of separator configuration, which involves deciding both which cut generators to activate and how to set their key parameters, remains relatively underexplored. A recent study by Li et al. [2023] proposes a data-driven framework for learning separator activation policies, demonstrating that informed separator selection can reduce the cut candidate space and improve solver efficiency.

2.2 LLM for Optimization

Recent research demonstrates significant progress in leveraging LLMs to automate and enhance various aspects of optimization. For instance, Huang et al. [2025] propose a customizable framework for training LLMs specifically tailored for optimization modeling in the context of operations research (OR). Beyond training domain-specific models, many studies focus on using general-purpose LLMs to support optimization workflows. For example, Liu et al. [2024] and Shi et al. [2025] employ LLMs to generate heuristics that guide evolutionary algorithms such as genetic algorithms (GAs), demonstrating the effectiveness of LLMs in heuristic design and evolution. Similarly, Jiang et al. [2025a] introduce an LLM-based framework that integrates network topology and domain knowledge to address combinatorial optimization (CO) problems. Zhang and Luo [2025] further push the boundary by developing reasoning-based LLM agents that automate the entire OR workflow by interpreting natural language problem descriptions, translating them into code, and solving the resulting optimization problems. In addition, Lawless et al. [2025] incorporate LLMs into MILP optimization to mitigate the cold-start problem by leveraging textual descriptions of both problem instances and available separators. More recently, LLMs are being more tightly coupled with the solver loop through performance-driven search over heuristics or executable code. LLM-LNS [Ye et al., 2025] uses a dual-layer self-evolutionary agent to generate neighborhood-selection strategies for MILP large neighborhood search. LLM4Solver [Jiang et al., 2025b] explores program-space evolution, using LLMs to generate and refine diving-heuristic code. Related heuristic-evolution frameworks, such as Hercules [Wu et al., 2025] and Monte Carlo tree search for automated heuristic design (MCTS-AHD) [Wu et al., 2025; Zheng et al., 2025], further improve LLMgenerated heuristics by incorporating task-aware abstractions and lowering evaluation cost, for example via fitness prediction.

Despite these advances, most prior work emphasizes domain-specific LLM training or generates external heuristics and code, while largely overlooking how LLMs can enhance the core exact components of mainstream solvers, such as cutting-plane methods. In this work, we leverage LLMs' mathematical reasoning to guide both separator configuration and adaptive cut selection, improving solution quality.

3 ProblemFormulation

Modern MILP solvers commonly adopt a branch-and-cut framework, which combines branch-and-bound with cutting planes to iteratively tighten LP relaxations and prune the search space. Within this framework, separator configuration specifies which separations are activated to generate candidate cuts, while cut selection decides which cuts are added to the relaxation at each separation round. We formally define three components below to facilitate a clearer understanding of our approach.

Definition 1 (Branch-and-Cut). Modern MILP solvers adopt the B&C paradigm, which integrates cutting-plane techniques into the B&B framework [Mitchell, 2002]. The solver builds a search tree by recursively solving LP relaxations and branching on fractional variables, as Figure 2 displays. To strengthen these relaxations, especially at the root node, cutting planes are added to tighten the feasible region, improving bounds and reducing tree size [Bengio et al., 2021].

Definition 2 (Separator Configuration). Given an MILP solver with M separator algorithms, configuring separator is not only about deciding which separators to enable, but also about setting the separator-specific parameters that control their aggressiveness and computational overhead. We formalize a separator configuration as Fm = (zm, θm)Mm=1 , where zm ∈ {0, 1} indicates whether separator Fm is activated, and θm denotes its parameter vector (e.g., separation frequency, the maximum number of separation rounds, and the maximum separation depth). The difficulty lies in exploring both the combinatorial space of separator activations and the coupled parameter space for the activated separators. Even considering zm alone yields 2M combinations, which is already huge for solvers such as SCIP and Gurobi with M = 17 and M = 21 separators, respectively. Parameter tuning of θm further enlarges the search space and is highly instance-dependent, typically requiring substantial expert experience. LLMs offer a promising alternative by inferring reasonable activation decisions and parameter settings directly from semantic instance descriptions and embedded priors.

Definition 3 (Cutting Plane Selection). Given the MILP problem in Eq. (1), we drop all its integer constraints to obtain its LP relaxation, which takes the form of:

Given the LP relaxation in Eq. (2), cutting planes are linear inequalities introduced to tighten the relaxation without excluding any integer-feasible solutions of the original MILP. These cuts are generated by a set of activated separators and applied iteratively during the solving process. The cuttingplane procedure typically includes: (i) solving the current LP relaxation, (ii) generating a pool of candidate cuts C, (iii) selecting a high-quality subset S ⊆ C, and (iv) adding S to the LP model to produce an updated relaxation. Crucially, the best cut-selection rule is not static: it should adapt to the evolving search stage and tree state, where the trade-off between bound improvement and LP overhead can change markedly. Hence, effective and adaptive cut selection is a key driver of MILP solver performance [Tang et al., 2020].

4 Methodology

Different separators are designed to exploit specific structural properties of MILP instances, and their effectiveness often depends on proper parameter settings. For instances with diverse scales and objective structures, choosing and tuning an appropriate separator configuration is crucial, as it directly shapes the candidate cut pool and, ultimately, solver performance. Once candidate cuts are generated, cut selection is equally important and should adapt to the evolving B&B tree to balance relaxation tightening against computational overhead. Unlike prior approaches that rely on expertcrafted rules or large training datasets, we propose to leverage LLMs' semantic understanding of instance characteristics and solver states to automatically configure separators and produce stage-aware cut-selection strategies.

4.1 Separator Configuration via CoT

Modern MILP solvers (e.g., SCIP) provide a rich portfolio of separator algorithms, each designed to exploit particular geometric or combinatorial structures in the LP relaxation. However, solver performance is highly sensitive not only to which separators are enabled, but also to how their key parameters are set (e.g., invocation frequency, round limits, cut limits, and depth restrictions). Tuning these choices typically requires optimization expertise and extensive trial-and-error. Moreover, indiscriminately activating all separators in the solver and setting their key parameters to large values can significantly increase computational overhead and, in turn, make the overall solving process more difficult. To address this, we propose an LLM-guided separator configuration method that leverages the mathematical priors and reasoning capabilities of LLMs to produce an instance-specific configuration via CoT reasoning, jointly deciding separator activation and separator-level hyperparameters.

Formally, let the available separator set be F = {F1, . . . , FM}. Our goal is to infer a separator configuration F = {(zm, θm)}Mm=1 that will be used throughout the solving process, where zm ∈ {0, 1} indicates whether Fm is activated, and θm collects its key parameters. Given an instance P, the LLM infers F through CoT prompting:

Concretely, the prompt encodes a compact structural profile of P, including: (i) problem type (e.g., Set Covering, Knapsack), capturing high-level combinatorial structure; (ii) instance scale (numbers of variables and constraints); (iii) variable composition (e.g., integrality ratio and domain statistics); and (iv) objective/constraint structure (e.g., coefficient sparsity, magnitude ranges, sign patterns and density). The prompt also enumerates the available separator set F and the admissible parameter ranges for each Fm, forcing the LLM to choose only supported algorithms and valid parameters.

Our CoT prompting explicitly decomposes separator configuration into an ordered, step-by-step reasoning procedure. For each separator Fm, as formalized in Eq. (4), the LLM first determines a binary activation decision zm. Conditioned on the activated separator zm, it then infers the separator parameters sequentially, where j indexes the j-th parameter and θ(1:j-1) m denotes the set of previously inferred parameters. In the current implementation, the LLM reasons about six core parameters. These six parameters include the invocation frequency, the maximum number of separation rounds at the root and non-root nodes, the maximum number of cuts added per round at the root and non-root nodes, and the maximum B&B depth at which the separator is allowed to operate. Importantly, this reasoning pipeline is fully extensible: if additional separator parameters are exposed (e.g., caps on the number of cuts added and other separator-specific controls), they can be incorporated by appending extra reasoning steps to the chain, without changing the overall framework.

4.2 Cut Selection via Heuristic Evolution

Given a pool of candidate cuts C generated by the activated separators, a cut-selection heuristic defines a rule for filtering C to select a subset of cuts to be added to the LP relaxation. As B&B progresses, the solver moves across different search regimes (e.g., root vs. deep nodes, easy vs. hard subtrees), so a single fixed cut-selection heuristic is often suboptimal.

In this work, we introduce a heuristic evolution mechanism driven by an LLM to adapt cut selection to the current B&B stage. Let st denote the B&B tree state at cut-selection call t, summarizing the current position and progress of the search tree (e.g., depth, node count, gap, LP iterations). Let ht denote the cut-selection heuristic used at time t, and let πt denote the observed short-horizon performance signal after applying it (e.g., gap decrease, LP time, node growth). We first use the LLM to interpret the evolving state-performance stream (sτ , πτ)τ≤t in natural language and assess whether the current heuristic ht is effective under st. If not, the LLM proposes a more suitable heuristic description (a heuristic thought) and the corresponding executable cut-selection policy (code), yielding an updated heuristic ht+1:

where GLLM denotes the LLM-driven generator that, conditioned on the current tree state, produces a better cut-selection heuristic ht+1 for the next search stage.

Because generating high-quality heuristics (and code) via the LLM can be time-consuming, prior work often relies on expensive evolutionary procedures such as genetic algorithms (GA) to iteratively score and evolve candidates [Ye et al., 2025; Wu et al., 2025]. In this work, we build an offline strategy repository D = (uk, hk)Kk=1 , where each entry stores a heuristic hk together with a concise semantic summary uk (the heuristic thought) describing its intended operating regime and best-use conditions. At runtime, given the current state st, the LLMmatches st to the most semantically compatible thought uk and selects the corresponding heuris-

Here, k⋆ denotes the index of the strategy in the repository D = {(uk, hk)}Kk=1 whose heuristic description uk is considered by the LLM to be the most semantically compatible with the current B&B state st. We then activate the corresponding cut-selection heuristic hk⋆. This realizes heuristic evolution as stage-aware switching among a curated set of effective cut-selection behaviors, rather than costly GA-style population evolution.

5 Experiments

We conduct a series of experiments to address the following research questions: (1) Overall Performance: How does our method compare with heuristic-based, learning-based, and LLM-based approaches in solution quality across benchmark datasets, particularly on large-scale instances? (2) Efficiency: How does the time consumption of our method compare with the baselines? (3) Ablation Study: How do the separator configuration and cut selection modules individually contribute to the overall performance? (4) Interpretability: What can we observe from visualizing the cuts selected by the LLM?

5.1 Datasets

We evaluate our approach on five NP-hard MILP benchmarks. Three of them-Set Covering [Balas and Ho, 2009; Ye et al., 2025], Maximum Independent Set (MIS) [Bergman et al., 2016], and Knapsack [Scavuzzo et al., 2022]-are synthetic instances generated following the methodology of Gasse et al. [2019]. Specifically, the Set Covering (small) dataset contains 1,000 variables and 500 constraints, while the (large) dataset contains 200,000 variables and 200,000 constraints. the Maximum Independent Set dataset has 500 variables and 1,593 constraints; and the Knapsack dataset comprises 720 variables and 72 constraints. The remaining two benchmarks, MIK [Atamt¨urk, 2003] and CORLAT

[Gomes et al., 2008], are real-world problem instances commonly used for evaluating MILP solvers. The MIK dataset includes 413 variables and 346 constraints, while the CORLAT dataset contains 466 variables and 486 constraints. A summary of dataset statistics, including the number of variables (x) and the number of constraints (y), is provided in Table 1.

5.2 Setup

We use SCIP 8.0 [Bestuzheva et al., 2023] as the backend solver for all experiments. As a state-of-the-art opensource solver, SCIP is widely adopted in machine learning research for combinatorial optimization [Gasse et al., 2019; Huang et al., 2025]. After extensive evaluation of various LLMs, we adopt Qwen3-30B or Claude-3.5 to guide both separator configuration and cut selection, depending on the problem characteristics. All other SCIP parameters are kept at their default settings to ensure fair and reproducible comparisons. A time limit of 300 seconds is imposed for solving each instance. More implementation details can be found in our code repository and online appendix: https://github.com/ BeeeeenWANG/LLM-guided-cutting-plane-management.

5.3 Baselines

The first baseline uses the built-in cut selection strategy of SCIP 8.0, referred to as Default. The second baseline selects a fixed number of cuts at random and is denoted as Random. The third and fourth baselines adopt the normalized violation (NV) and efficacy (Eff) heuristics, respectively, to guide cut selection. The fifth baseline is a state-of-the-art learningbased method, hierarchical sequential model (HEM) [Wang et al., 2023], which learns cut selection policies through hierarchical reinforcement learning. The sixth baseline is an LLM-based solver, LLM-LNS [Ye et al., 2025], which uses LLM-generated heuristics to guide large neighborhood search for MILPs. Additionally, we evaluate two ablation variants of our method. NoSep disables the LLM-guided separator configuration and uses SCIP's default separators and parameters, while retaining the LLM-guided cut selection. NoCut disables the LLM-guided cut selection and relies on SCIP's default cut selection rule, while preserving the LLMguided separator configuration.

5.4 Metrics

We adopt three widely used evaluation metrics: average primal-dual gap integral (PDI), primal bound, primal-dual gap (PD gap) and primal integral. PD integral measures the area under the primal-dual gap curve over time, reflecting both the convergence speed and solution quality throughout the solving process. A lower PD integral indicates faster and more stable convergence. Primal bound refers to the best feasible objective value found during the solving process. For minimization problems (which is standard in MILP), a lower primal bound implies a better solution. Primal-dual gap (PD gap) is the relative difference between the primal and dual bounds at termination. It quantifies how close the solution is to optimality. A lower PD gap indicates better optimality and is therefore preferred. A PD gap of 0 means that the primal and dual bounds have converged, indicating that a provably optimal solution has been found. In addition to these metrics, we also compare the solving time, where shorter time reflects better efficiency. Primal integral measures the area under the primal-bound trajectory over time (relative to the optimal or best-known objective value), reflecting the solver's anytime performance; a lower primal integral indicates that high-quality feasible solutions are found earlier and improved more steadily.

5.5 Results

Performance Comparison (Answering Q.1)

The comparison with other baselines is presented in Table 1, where the best-performing model is shown in bold, and the strongest baseline in each case is underlined. Our LLMguided cut management approach and its two ablated variants consistently demonstrate competitive performance across all benchmarks. Specifically, on relatively easier datasets such as Set Covering and Maximum Independent Set, the learningbased method HEM performs strongly in terms of solution quality. However, as the problem complexity increasessuch as in more challenging datasets with more intricate cut structures-HEM struggles to maintain its performance, while our method begins to show clear advantages. It is also noteworthy that applying LLM-guided separator configuration alone can sometimes achieve strong results without the additional cost of cut selection. This is especially evident on datasets like Knapsack, where the number of generated cuts is small or relatively simple. In such cases, introducing cut selection may add overhead without significantly improving solution quality. The p-values also confirm that the experimental results are of statistical significance.

Since LLM-LNS is not built on a tree-search solving mechanism, it does not maintain valid dual bounds. To enable a fair comparison with LLM-based solvers, Table 2 reports results on Set Covering at both small and large scales using primal integral and primal bound. On the small instance, Default and our method achieve the lowest primal integrals, indicating strong anytime performance, while our method further improves the final primal bound compared with hand-crafted rules and learning-based baselines. Random performs worst, confirming the importance of informed cut management. NV and Eff provide moderate improvements but remain inferior to adaptive strategies. On the large-scale instance, our method attains the best overall performance, with the lowest primal integral and the strongest primal bound among all methods, demonstrating superior scalability and robustness. HEM and LLM-LNS achieve competitive final bounds but suffer from significantly larger primal integrals, reflecting weaker convergence behavior over time. Overall, the results show that the proposed LLM-guided cutting-plane management effectively balances convergence speed and solution quality across problem scales.

We further evaluate the impact of different LLMs as reasoning engines, including Qwen3-30B, DeepSeek-V3, KimiK2-Instruct, GPT-4o, Claude-3.5, Gemini-2.5, and Grok-3. A brief comparison is presented in Table 3, with detailed results provided in our online appendix. All models are able to find optimal solutions (i.e., PD gap equals 0) on the three evaluated datasets. The primary differences lie in their performance in the PDI (primal-dual integral) metric, which reflects the LLMs' inference efficiency and reasoning effectiveness. Among these models, Qwen3-30B, Claude-3.5, and Gemini2.5 achieve the best overall results, exhibiting lower PDI values. In particular, Qwen3-30B and Claude-3.5 deliver strong performance while maintaining relatively low inference costs. While models such as Grok-3 and Gemini-2.5 demonstrate competitive efficiency, they occasionally yield slightly less stable cut quality. Based on this analysis, we select Qwen330B and Claude-3.5 as our primary reasoning engines, enabling a flexible trade-off between solution quality and inference budget.

Time Consuming Analysis (Answering Q.2)

We report the average runtime of all methods on the Set Covering dataset in Figure 3(a), averaged over 10 trials. For fairness, we exclude the LLM inference time for separator configuration, since it is a one-time preprocessing step performed before optimization, whereas all methods report only the solving time during cut selection. Under this protocol, our approach does not exhibit a clear advantage in terms of runtime compared with other methods. HEM approaches achieve the lowest reported solving time, although their training cost is not included. In contrast, random cut selection exhibits the largest variance due to the inconsistent quality of the selected cuts.

Figure 4: Ablation study on LLM-guided separator configuration and cut selection.

To understand the runtime bottleneck, Figure 3(b) breaks down the time spent on LLM reasoning. Across most datasets, LLM inference accounts for nearly half of the total solving time. While it helps select high-quality cuts, its cost remains high, motivating future work on accelerating LLM inference for more efficient cut selection.

Ablation Study on Separator Configuration (Answering Q.3)

We analyze the number of cuts generated by separators during the cut selection process on the Set Covering and Carlot datasets. To evaluate the impact of the separator configuration module, we compare our approach with (denoted as 'w') and without (denoted as 'w/o') this component. The results in Figure 4(a) show that, on both datasets, particularly Carlot, the number of cuts considered for selection is significantly reduced when the separator configuration is applied. This demonstrates that separator configuration effectively narrows the search space by filtering out unproductive separators, which plays a critical role in improving cut selection efficiency.

Ablation Study on Cut Selection (Answering Q.3)

We analyze the LLM-guided cut selection by comparing it with two typical baselines in terms of primal gap: the default setting of the SCIP solver and HEM. The results in Figure 4(b) show that our LLM-guided approach achieves faster convergence from a lower initial gap and exhibits greater stability in reducing the gap, with less fluctuation than the other two methods. These advantages can be attributed to the LLM's inherent mathematical reasoning capabilities, which allow it to select effective cuts rather than relying solely on simple heuristics or learned parameters.

Visualization on Cut Selection (Answering Q.4)

During the cutting plane procedure, the solver typically relaxes integer constraints using linear programming and iteratively adds cutting constraints to eliminate non-integer solutions. This process progressively tightens the feasible region. Figures 5(a) and (b) illustrate how the feasible region is incrementally reduced through successive cuts. In these figures, black solid lines represent the cuts selected in the previous round, and the blue-shaded area enclosed by these lines and the coordinate axes denotes the current feasible region under linear relaxation. Red lines indicate candidate cuts: the red solid line is the one selected by the LLM for the next round, while the red dashed lines are those rejected by the LLM.

After the red solid cut is added, the feasible region (grayshaded area) becomes smaller, enabling more non-integer solutions to be excluded and bringing the relaxed region closer to the true integer feasible set. This visual evidence demonstrates the effectiveness of selecting appropriate separators and adaptive cut-selection heuristics.

6 Conclusion and FutureWork

In this paper, we propose an LLM-guided cutting-plane management framework for MILP that integrates LLM reasoning into both separator configuration and cut selection. By leveraging chain-of-thought reasoning, the LLM automatically infers instance-specific separator activation and parameter settings, while a stage-aware heuristic switching mechanism adaptively selects effective cut-selection strategies based on the evolving B&B state. Experimental results on diverse benchmarks show that the proposed method consistently outperforms baselines in solution quality, demonstrating the potential of LLMs for enhancing core components of exact MILP solvers.

Looking ahead, several directions worth further exploration. First, we plan to accelerate the reasoning process of LLMs to enable faster solving. Furthermore, integrating finetuned, domain-specific LLMs may provide a better trade-off between inference cost and decision quality, paving the way for scalable and efficient LLM-guided optimization pipelines.

Acknowledgments

This work is supported by the National Natural Science Foundation of China (No. 62276047), China Postdoctoral Science Foundation (No. 2025M771590 and No. GZC20251104), and Yibin Science and Technology Program (No. 2024JC007 and No. 2025SF004).