Adaptive CMSA: Construct, Merge, Solve, Adapt

• Adaptive CMSA is a design pattern that uses a four-phase loop (Construct, Merge, Solve, Adapt) with adaptive feedback to refine search strategies.
• It leverages mechanisms such as reinforcement learning, parameter control, and LLM-driven evolution to dynamically adjust construction and component merging.
• Empirical results show that adaptive CMSA outperforms standard methods in challenging instances by efficiently merging components and streamlining exact subproblem solving.

Searching arXiv for recent CMSA and adaptive CMSA papers to ground the article. Adaptive Construct, Merge, Solve, Adapt (CMSA) denotes a family of CMSA-based matheuristics in which the canonical four-phase loop—Construct, Merge, Solve, Adapt—is coupled with feedback-driven control, learned guidance, or automated heuristic redesign. In the cited literature, the adaptive element appears in several forms: ageing and pruning of components in the reduced subproblem, dynamic control of determinism and subsolver effort, self-adaptation of mutation and sampling parameters, reinforcement-guided construction, and LLM-based evolution of the construction heuristic. What remains stable is the central CMSA principle: diverse feasible solutions are constructed, their components are merged into a restricted exact subproblem, that subproblem is solved by an external solver, and the component pool is then adapted before the next iteration (Blum et al., 2018, Sartori et al., 12 Feb 2025, Djukanovic et al., 12 Sep 2025, Sartori et al., 15 Nov 2025, Rodríguez-Corominas et al., 27 Feb 2026).

1. Canonical CMSA structure and the role of components

CMSA is presented as a “matheuristic” that combines a fast randomized search with an exact solver on a reduced subproblem (Sartori et al., 12 Feb 2025). One iteration follows the same high-level pattern across domains. In the Construct phase, the algorithm generates feasible solutions probabilistically; in the Merge phase, it extracts solution components into a restricted component pool; in the Solve phase, it formulates and solves a reduced exact model over those components; and in the Adapt phase, it updates ages or related control variables and prunes stale components (Blum et al., 2018).

The notion of a component is problem-dependent. In the generic binary-ILP formulation of Blum and Santos, the full component universe is $C=\{(x_j,0),(x_j,1)\mid j=1,\dots,n\}$, and the reduced subproblem is built by fixing variables whose value-components are absent from the current restricted set $C'$ (Blum et al., 2018). In Maximum Independent Set (MIS), the components are vertices included in the reduced subproblem $P$, which is then solved by an ILP routine under a time limit (Sartori et al., 12 Feb 2025). In Variable-Sized Bin Packing (VSBPP), the components are “bin-item assignments” collected from construction solutions and injected into a reduced set-covering model (Sartori et al., 15 Nov 2025). In the Longest Filled Common Subsequence problem (LFCSP), the component pools are $\Match_B^S$ and $\Match_{A\M}^S$, restricting the match variables $x_{i,j}$ and deletion variables $y_i$ of the ILP (Djukanovic et al., 12 Sep 2025). In the min-max multiple traveling salesman problem (mTSP), the merged objects are whole routes, and the restricted exact model is a set-covering MILP that selects exactly $m$ routes minimizing the longest route (Rodríguez-Corominas et al., 27 Feb 2026). In prioritized pairwise test data generation, the component pool $subComp$ contains products, and the exact subproblem selects a minimum-cardinality subset still covering all weighted configurations (Ferrer et al., 2024).

Domain	Components merged	Restricted exact solve
Binary ILP	$(x_j,0)$, $C'$0	Reduced BIP
MIS	vertices	Reduced ILP
VSBPP	bin-item assignments	Reduced set-covering ILP
LFCSP	$C'$1, $C'$2	Restricted ILP
Min-max mTSP	routes	Restricted set-covering MILP
Prioritized pairwise testing	products	ILP over $C'$3

This common architecture is the main reason CMSA transfers across domains. A plausible implication is that “adaptive CMSA” is best understood not as a single algorithm, but as a design pattern in which the component generator, the pool-management rules, or both are made responsive to search feedback.

2. What makes CMSA adaptive

The adaptive layer in CMSA can be attached to different parts of the loop. In the generic CP-supported CMSA for binary ILPs, adaptation occurs through two control variables: the subsolver time limit $C'$4 and the determinism rate $C'$5. If the reduced exact solve does not improve the best-so-far solution, both are increased toward upper bounds; if an improvement is found, both are reset to lower bounds (Blum et al., 2018). This produces a restart-like intensification/diversification mechanism.

In the LFCSP variant, adaptation is more explicit and self-referential. The algorithm adapts the mutation threshold $C'$6 and the number $C'$7 of mutants per iteration according to both the solve time $C'$8 and the relative quality of the returned solution $C'$9. If the exact subproblem is solved quickly, $P$0 may be reduced; if the returned solution improves the best-so-far, the method resets $P$1 and $P$2; ties increase $P$3 (Djukanovic et al., 12 Sep 2025). This is an online parameter-control scheme rather than fixed offline tuning.

In MIS, the key adaptive idea proposed by the LLM is to inject the component age $P$4 directly into the construction rule. The weight

$P$5

combines recency and graph structure, and the induced sampling probability $P$6 is then used for deterministic or roulette-wheel vertex selection (Sartori et al., 12 Feb 2025). Here adaptation is not only in pool pruning; it becomes part of the constructive bias itself.

In RL-CMSA for min-max mTSP, adaptation is mediated by learned pairwise $P$7 values. These values are updated from route co-occurrences in the candidate pool and in the best restricted MILP solution, drifting toward $P$8 for reinforced pairs and toward $P$9 for discouraged pairs (Rodríguez-Corominas et al., 27 Feb 2026). The construction phase is therefore continuously reshaped by search history.

In irace-evo for VSBPP, the adaptive layer reaches the code level. Every configuration is a pair $\Match_B^S$0, where $\Match_B^S$1 is a parameter vector and $\Match_B^S$2 is a code variant of the original algorithm $\Match_B^S$3. irace updates a probabilistic model $\Match_B^S$4 over $\Match_B^S$5 using truncated normal sampling and F-Race, while an LLM generates new code variants for the placement-quality function used in the Construct phase (Sartori et al., 15 Nov 2025). The paper states that Merge and Solve are left unchanged, whereas Construct and certain Adapt-related ageing parameters become adaptive objects.

3. Adaptation in the Construct phase

The Construct phase is the most frequent target of adaptation because it determines which components can ever enter the reduced exact model. The literature illustrates several distinct mechanisms.

For MIS, the original expert-designed CMSA construction heuristic maintains a feasible vertex set $\Match_B^S$6, uses a determinism rate $\Match_B^S$7, and either selects the minimum-degree vertex or samples uniformly from a candidate list of the $\Match_B^S$8 lowest-degree vertices (Sartori et al., 12 Feb 2025). The LLM-proposed variant “LLM-CMSA-V1” replaces this rule with one based on degree and component age, while “LLM-CMSA-V2” adds an entropy term

$\Match_B^S$9

The resulting change is not merely a reweighting of randomness; it makes the constructive process responsive to how long components have persisted in the subproblem (Sartori et al., 12 Feb 2025).

For VSBPP under irace-evo, the placement heuristic in Construct is no longer fixed. The paper states that it becomes an evolvable function subject to code mutations by an LLM, while Merge and Solve remain unchanged (Sartori et al., 15 Nov 2025). The framework generates code variants through GenerateCodeVariants, validates and compiles them, and then races mixed pools of old and new $\Match_{A\M}^S$0 pairs. Two highlighted heuristics, $\Match_{A\M}^S$1 and $\Match_{A\M}^S$2, share a “Context-Aware Utilization Factor,” a “Remaining-Items Adjustment,” and a “Combined Efficiency Score,” balancing cost, utilization, and search context (Sartori et al., 15 Nov 2025).

For RL-CMSA, construction begins with probabilistic clustering guided by learned pairwise $\Match_{A\M}^S$3 values and a softmax-style rule $\Match_{A\M}^S$4. Seeding is k-means++-style, and assignment uses a score

$\Match_{A\M}^S$5

which combines insertion cost, load penalty, and $\Match_{A\M}^S$6-compatibility (Rodríguez-Corominas et al., 27 Feb 2026). After clustering, each route is built by greedy best insertion and improved by intra-route 2-opt and Or-opt. This is a markedly richer construction mechanism than classical CMSA, but it still serves the same downstream purpose: generate components for exact recombination.

For LFCSP, construction is mutation-based rather than greedy. ModifyComponents copies the deletion set $\Match_{A\M}^S$7, attempts random same-symbol swaps with probability $\Match_{A\M}^S$8, reconstructs the modified subsequence, and recomputes $\Match_{A\M}^S$9 via an LCS call (Djukanovic et al., 12 Sep 2025). The constructive step is therefore centered on controlled perturbation of the incumbent component pattern.

A recurrent theme is that adaptive CMSA rarely abandons problem-specific knowledge. Instead, it modifies the constructive bias while preserving the component-based merge-and-solve backbone. This suggests that adaptation in CMSA is most effective when it changes which components are exposed to exact optimization, rather than replacing exact optimization itself.

4. Merge, exact subproblems, and pool adaptation

Although many adaptive variants focus on construction, the Merge, Solve, and Adapt phases remain structurally decisive. In generic CMSA for binary ILPs, the reduced BIP is formed by adding constraints $x_{i,j}$0 if $x_{i,j}$1 and $x_{i,j}$2 if $x_{i,j}$3, then calling an ILP solver such as CPLEX on that reduced model (Blum et al., 2018). The component-keeping rule is age-based: a variable-value pair remains in $x_{i,j}$4 as long as it has appeared in one of the solver’s returned optimal solutions within the last $x_{i,j}$5 iterations.

In the SPL testing application, Merge is the union of products appearing in the $x_{i,j}$6 constructed solutions, and Adapt increments the age of products not used by the exact solution while resetting ages of retained products to $x_{i,j}$7. If $x_{i,j}$8, the product is removed from $x_{i,j}$9 (Ferrer et al., 2024). The exact subproblem is a covering ILP over $y_i$0: $y_i$1

In LFCSP, Merge forms $y_i$2, where both component pools are unions over the current solution set $y_i$3. The restricted ILP then limits $y_i$4 and $y_i$5 to these selected components, while preserving the conflict, matching, and multiset-capacity constraints of the full model (Djukanovic et al., 12 Sep 2025). This is a direct example of CMSA’s standard reduced-subproblem philosophy.

In RL-CMSA, Merge inserts newly constructed routes into a route pool $y_i$6, hashes route signatures so that only the shorter duplicate survives, and prunes any route whose length exceeds the current best max-route length $y_i$7 (Rodríguez-Corominas et al., 27 Feb 2026). The restricted MILP is

$y_i$8

subject to

$y_i$9

After the MILP returns $m$0, an additional Adapt stage performs inter-route Remove, Shift, and Swap moves until no further improvement of the longest route is possible (Rodríguez-Corominas et al., 27 Feb 2026).

For VSBPP, the Solve phase is explicitly unchanged by irace-evo: once a subinstance is specified, it is solved as before, exactly via CPLEX or a fast heuristic solver, and any code evolution affects only Construct (Sartori et al., 15 Nov 2025). This is important because it shows that adaptive CMSA does not necessarily imply that all four phases are modified.

5. Empirical behavior across domains

The empirical record reported in the cited papers is consistently favorable, but the pattern depends on the difficulty regime and on which phase is adapted.

For generic CP-supported CMSA on binary ILPs, the reported result is that the technique is able to match the upper bounds of the standalone application of CPLEX in rather easy-to-solve instances, while it generally outperforms standalone CPLEX in hard instances; the support of the constraint propagation engine is useful when finding feasible solutions is rather difficult (Blum et al., 2018). This establishes a baseline claim for CMSA as a generic exact-heuristic hybrid.

For MIS, “LLM-CMSA-V1” and “LLM-CMSA-V2” both outperform original CMSA, with the gap growing as $m$1 and density increase. Critical-difference plots at $m$2 show that V1 is statistically significantly better than Original and V2, and that V2 is significantly better than Original. The convergence plots further indicate that V1 reaches high-quality solutions quickly, well before original CMSA obtains comparable solutions (Sartori et al., 12 Feb 2025).

For prioritized pairwise test generation in software product lines, the analysis reports that CMSA results in statistically significantly better quality solutions in most instances and for most levels of weighted coverage, although it requires more execution time. At full $m$3 coverage across all models, CMSA’s average test-suite size is reported as $m$4 products versus HINLP’s $m$5, while total CPU time is approximately $m$6 s versus approximately $m$7 s for HINLP (Ferrer et al., 2024). This is a direct quality-versus-runtime trade-off.

For LFCSP, the adaptive CMSA solves $m$8 of $m$9 problem instances with known optimal solutions, achieving over $subComp$0 optimal solution quality (Djukanovic et al., 12 Sep 2025). On the large benchmark, it attains the highest average objective in all $subComp$1 groups, with an overall mean objective of $subComp$2, versus $subComp$3 for LS$subComp$4 and $subComp$5 for LS$subComp$6 (Djukanovic et al., 12 Sep 2025). The same paper also reports statistical superiority under post-hoc one-sided Wilcoxon signed-rank tests.

For VSBPP under irace-evo, evolved variants achieve win-rates over $subComp$7–$subComp$8 on convex-cost instances $subComp$9 with large $(x_j,0)$0, moderate gains of $(x_j,0)$1–$(x_j,0)$2 on $(x_j,0)$3, and small but significant gains of $(x_j,0)$4–$(x_j,0)$5 on $(x_j,0)$6. The total LLM expense for $(x_j,0)$7 independent irace-evo runs is reported as $(x_j,0)$8, with average per run $(x_j,0)$9, and the framework generates competitive improvements using Claude 3.5 Haiku (Sartori et al., 15 Nov 2025).

For RL-CMSA on min-max mTSP, the reported outcome is that the method consistently finds (near-)best solutions and outperforms a state-of-the-art hybrid genetic algorithm under comparable time limits, especially as instance size and the number of salesmen increase (Rodríguez-Corominas et al., 27 Feb 2026).

Taken together, these results indicate that adaptive CMSA is not tied to one specific adaptation mechanism. Exact solver callbacks, age-aware greedy choice, reinforcement-guided clustering, and LLM-generated construction rules all produce measurable gains in at least one tested setting.

6. Misconceptions, limitations, and current directions

A common misconception is that “adaptive CMSA” requires radical modification of the entire CMSA pipeline. The VSBPP irace-evo paper explicitly states the opposite: Merge and Solve are unchanged, while only the Construct step and certain Adapt-related ageing parameters are turned into adaptive objects (Sartori et al., 15 Nov 2025). Conversely, RL-CMSA modifies both construction and post-solve improvement, while LFCSP emphasizes self-adaptation of control parameters and subproblem content (Djukanovic et al., 12 Sep 2025, Rodríguez-Corominas et al., 27 Feb 2026). The term therefore covers several non-equivalent design choices.

Another misconception is that any additional adaptive or learned ingredient necessarily improves performance. The MIS study reports that the entropy-adjusted variant V2 is not beneficial on average relative to V1, and that the LLM-suggested low-level C++ “perf” optimizations are statistically equivalent to their non-perf counterparts with respect to solution quality (Sartori et al., 12 Feb 2025). The factual implication is that adaptive CMSA benefits depend strongly on which part of the heuristic is changed.

The literature also shows that performance claims must be interpreted relative to problem hardness. In generic BIP CMSA, standalone CPLEX is already competitive on easy instances (Blum et al., 2018). In LFCSP, the paper states that small instances are too easy, with ILP solving all small instances optimally (Djukanovic et al., 12 Sep 2025). In SPL testing, CMSA improves quality but requires more execution time (Ferrer et al., 2024). A plausible implication is that adaptive CMSA is especially valuable where the full exact model becomes too expensive, yet reduced exact recombination over high-quality components remains tractable.

Current directions in the cited work point toward increasingly automated sources of adaptation. One line uses LLMs as “heuristic assistants” that propose new heuristic components or data-structure refinements for existing high-performance code (Sartori et al., 12 Feb 2025). Another line couples automatic algorithm configuration with LLM-driven code evolution over the original source function through the Always-From-Original principle, progressive context management, and a probabilistic model over algorithm parameters (Sartori et al., 15 Nov 2025). A third line uses reinforcement learning to bias component generation by learned co-occurrence structure (Rodríguez-Corominas et al., 27 Feb 2026). These developments suggest an ongoing shift from manually tuned CMSA variants toward CMSA systems that learn, mutate, or self-regulate their own constructive biases while preserving the exact reduced-subproblem core.