Survey current as of September 2026. This is a long-form deep dive (~20,000 words) — use the table of contents below to jump to the sections you care about. A Chinese version of this report is also available.
Table of Contents
- Executive Summary
- 1. Scope and Taxonomy
- 2. Paradigm 1: End-to-End Neural Combinatorial Optimization (NCO)
- 3. Paradigm 2: Learning-Augmented Classical Solvers
- 4. Paradigm 3: Learning to Optimize (Learned Optimizers)
- 5. Paradigm 4: Decision-Focused Learning and Differentiable Optimization (Predict-then-Optimize)
- 6. Paradigm 5: LLM-Driven Optimization
- 7. Paradigm 6: Learning-Based Planning and Control
- 8. Scheduling and Manufacturing: The Practical Landscape of Deep-Learning Scheduling
- 9. Industrial Adoption Panorama: A Global Practice Map
- 10. Open-Source Toolchain Panorama and Selection
- 11. Engineering Adoption Guide
- 12. Challenges, Controversies, and Open Problems
- 13. Frontier Trends (2025–2026) and Outlook
Executive Summary
"Learning-based optimization and planning" refers to the family of methods that use machine learning—especially deep learning, reinforcement learning, and large language models—to replace, accelerate, or augment traditional optimization and planning algorithms. Over the decade-plus since 2015, the field has evolved from the academic demonstration of Pointer Networks into a vast technical system spanning combinatorial optimization, mixed-integer programming, production scheduling, robot control, autonomous driving, and automated algorithm discovery, delivering quantifiable gains in real production environments such as Google data center cooling, the LLVM standard library, DiDi's dispatch system, and Google TPU chip design.
This report divides the field into six paradigms—end-to-end neural combinatorial optimization (NCO), learning-augmented classical solvers, learning to optimize (L2O), decision-focused learning (DFL), LLM-driven optimization, and learning-based planning & control—and for each traces its technical lineage, representative methods, toolchain, and maturity, with engineering selection advice. On industrial adoption, the report systematically maps global practice by industry (Chapter 9): semiconductor EDA (Synopsys DSO.ai; Cadence Cerebrus production cases with Samsung/MediaTek/Phison), energy & power (Tesla Autobidder; Yokogawa × Saudi Aramco/ENEOS reinforcement-learning autonomous control; France's RTE grid competitions), logistics & warehousing (UPS ORION, Amazon DeepFleet, Ocado), urban transportation (Pittsburgh Surtrac, Google Green Light, Alibaba City Brain), financial execution (JPMorgan LOXM), and commercial platforms (Blue Yonder, NVIDIA cuOpt, Huawei OptVerse)—more than 20 traceable cases in total. Four core conclusions follow. First, the hybrid route (learning-augmented classical solvers) is the most reliable mainstream in industry today; end-to-end neural solvers still lag classical methods such as LKH-3, HGS, and Gurobi in generality, scale extrapolation, and feasibility guarantees. Second, the LLM-driven "generate–evaluate–evolve" paradigm (the FunSearch/AlphaEvolve lineage) is the fastest-growing direction since 2023, lifting the object of optimization from "solutions" to "algorithms themselves." Third, multiple large-scale industrial deployments have demonstrated quantifiable value, yet virtually all successful cases worldwide adopt a conservative "learned model + classical solver/safety layer" architecture and follow a staged deployment path of "simulator training → shadow mode → human-in-the-loop → bounded closed-loop autonomy." Fourth, open-source tools such as RL4CO, PyEPO, Ecole, OpenEvolve, and cuOpt have dramatically lowered the engineering barrier, allowing small teams to complete a proof of concept within weeks. Every chapter includes a "frontier progress" section covering the latest literature through 2026: cross-problem unified neural solvers (URS covers 107 routing problems), LLM-discovered solver branching policies (LLM4Branch), the birth and industrialization of the Muon optimizer (adopted end-to-end by the trillion-parameter Kimi K2), the crystallization of LLM-optimization evaluation suites (CO-Bench, SolverLLM), VLA robot foundation models (π0.5, GR00T N1), and large driving models (Tesla FSD V14; commercial Waymo/Tesla robotaxi in Austin), among others.
1. Scope and Taxonomy
1.1 What Is "Learning-Based Optimization and Planning"
Traditional optimization and planning rely on hand-crafted algorithms: branch-and-bound, cutting planes, column generation, and metaheuristics in operations research; model predictive control (MPC) in control; sampling- and graph-search-based planners such as RRT/A* in robotics. These methods carry solid theoretical guarantees, but their performance depends heavily on rules hand-tuned by experts for each specific problem (e.g., branching variable selection rules, neighborhood structure design, dispatching rules), and they cannot benefit from historical data when facing large volumes of repeated problems drawn from the same distribution. The core idea of learning-based optimization and planning is this: since industrial optimization problems are typically "the same family of problems, re-solved day after day with different data" (daily vehicle routing, per-shift production scheduling), data-driven methods can learn regularities in the problem distribution and inject them into the solving pipeline, thereby outperforming general-purpose algorithms on that distribution.
In their foundational 2021 survey in the European Journal of Operational Research, Bengio, Lodi, and Prouvost organized the field's methodology into two complementary machine-learning paradigms: learning by demonstration (imitation learning)—using supervised learning to approximate expensive but effective expert decisions (such as strong branching), trading approximation for computational efficiency; and learning by experience (reinforcement learning)—modeling the solving process as a Markov decision process (MDP) and discovering entirely new decision policies through trial and error. The two can be combined, initializing with imitation learning and fine-tuning with reinforcement learning (Bengio et al., EJOR 2021). This "imitation + reinforcement" dichotomy remains the basic coordinate system for understanding the field today.
1.2 A Six-Paradigm Taxonomy
With the rise of LLMs, the original "machine learning for combinatorial optimization" framing no longer covers the full picture. This report classifies existing methods into six paradigms according to the role learning plays in the optimization/planning pipeline, as shown in Figure 1:
Figure 1. The six-paradigm taxonomy of learning-based optimization and planning algorithms
The six paradigms are: (1) end-to-end neural combinatorial optimization—a neural network directly outputs solutions; representatives include Pointer Networks, the Attention Model, POMO, and recent diffusion-model approaches; (2) learning-augmented classical solvers—learned models are embedded as components inside classical frameworks such as branch-and-bound and large neighborhood search; representatives include GNN branching prediction, RL cut selection, Neural Diving, and NeuroLKH; (3) learning to optimize (L2O)—the object being learned is the optimization algorithm itself (e.g., the update rule of gradient descent, hyperparameter search policies); representatives include LSTM meta-optimizers, VeLO, OptFormer, and Lion; (4) decision-focused learning (DFL)—connecting the two-stage "predict–optimize" pipeline so that predictive models are trained for downstream decision quality; representatives include the SPO+ loss and differentiable optimization layers; (5) LLM-driven optimization—using large language models as black-box optimizers, heuristic generators, or automated modelers; representatives include OPRO, FunSearch, AlphaEvolve, EoH, and OptiMUS; (6) learning-based planning & control—sequential decision-making for continuous physical systems, covering learning-augmented MPC, diffusion motion planning, end-to-end autonomous driving, and LLM embodied task planning. These six paradigms share the same underlying technologies (GNNs, Transformers, RL, diffusion models) but face radically different problem forms and engineering constraints.
1.3 Historical Arc: Three Eras
Figure 2. The development arc of learning-based optimization and planning
The timeline in Figure 2 summarizes a decade-plus of progress in three eras. The Foundations era (2015–2019) was marked by sequence-to-sequence models entering combinatorial optimization: in 2015 Vinyals et al. proposed Pointer Networks, the first neural network to solve TSP; in 2016 Andrychowicz et al. learned optimizers with LSTMs and Khalil et al. approximated strong branching with imitation learning; in 2017 Bello et al. introduced reinforcement learning to escape dependence on optimal-solution labels and Khalil et al. proposed S2V-DQN on graphs; in 2019 Kool et al.'s Attention Model and Gasse et al.'s GNN branching model established the technical foundations of the end-to-end and hybrid routes respectively; during the same period DiDi had already put an RL-based dispatch system into production (see Chapter 9) (DiDi KDD 2018 paper walkthrough). The Systematization era (2020–2022) witnessed methodological maturation and the first heavyweight industrial results: POMO, the L2D scheduling model, Neural Diving, and RL cut selection appeared in succession; in 2021 Bengio et al.'s survey gave the field its canonical account, and Google's RL chip macro-placement result was published in Nature; in 2022 AlphaTensor used RL to discover faster matrix-multiplication algorithms, the SPO+ loss was finalized, and SayCan opened up LLM embodied planning (survey of AI for algorithm discovery). The LLM era (2023–present) is defined by bringing LLMs into the optimization loop: FunSearch and AlphaEvolve turned "LLM + evolutionary search + automatic evaluator" into a general-purpose algorithm-discovery engine; AlphaDev's discovered sorting algorithms entered the LLVM libc++ standard library; OPRO demonstrated that an LLM itself can act as an optimizer; and systems such as OptiMUS and ORLM began automating operations-research modeling—the most labor-intensive step of all. Meanwhile, the establishment of unified benchmarks such as RL4CO (KDD 2025) and ML4CO-Bench-101 (NeurIPS 2025) marks the field's entry into a phase of standardized evaluation (RL4CO, KDD 2025, awesome-ml4co).
1.4 Representative Surveys and Community Resources
For readers who wish to follow the field systematically, the following surveys and resource lists are the most reliable entry points today. At the methodological-overview level, the Bengio–Lodi–Prouvost EJOR survey (cited in §1.1) establishes the "imitation + reinforcement" coordinate system; a systematic survey of the LLM × combinatorial optimization intersection was published in ACM Computing Surveys in 2026, comprehensively mapping LLM intervention points along the optimization workflow (modeling, solving, verification, explanation) (ACM CSUR 2026); the LLM-driven meta-optimizer direction also received a dedicated 2026 survey covering three frontier lines—neuro-symbolic hybrids, agent-assisted optimization, and domain-specific optimizers (Springer survey 2026). A 2024 "learning to optimize" tutorial for continuous and mixed-integer optimization offers an on-ramp for practitioners moving from purely data-driven approaches toward "neural networks guiding classical solvers" (L2O tutorial).
For community-maintained living lists, awesome-ml4co (Thinklab, Shanghai Jiao Tong University) systematically indexes neural combinatorial optimization papers and code, while awesome-fm4co (the AI4CO community) tracks the "foundation models for combinatorial optimization" direction at monthly granularity—the density of its 2025–2026 entries vividly illustrates that direction's explosive growth (awesome-fm4co, awesome-ml4co). On evaluation resources, beyond RL4CO and ML4CO-Bench-101 (§2.4), the 2026 FrontierCO benchmark is the first to systematically evaluate contemporary ML solvers on real-world, large-scale instances (covering branching learning, LNS learning, FJSP reinforcement learning, and more), making it an important reference for judging the engineering value of any published method (FrontierCO). A recommended following cadence combines "one overview survey + one living list + one unified benchmark": the survey sets the framework, the list tracks increments, and the benchmark checks truth.
2. Paradigm 1: End-to-End Neural Combinatorial Optimization (NCO)
2.1 Three Technical Routes
End-to-end neural combinatorial optimization (NCO) pursues the most radical goal: train a neural network that takes a problem instance as input and directly outputs a near-optimal solution, invoking no traditional solver at inference time. Its industrial appeal lies in inference speed—a single forward pass takes milliseconds and natively supports batched GPU parallelism, making it theoretically suitable for online scenarios that must solve massive volumes of instances in extremely short time. A 2025 industrial-engineering survey in Artificial Intelligence Review systematically summarizes the application landscape of NCO-RL across vehicle routing, bin packing, assignment, scheduling, and planning problems, noting that the paradigm has become one of the standard candidate techniques for NP-hard problems in industrial engineering (AI Review 2025).
Technically, NCO falls into three routes. Constructive methods model solution generation as sequential decision-making, autoregressively selecting elements one by one: from Pointer Networks (supervised learning), through Bello et al.'s RL training framework, to Kool et al.'s Transformer-based Attention Model (AM) and Kwon et al.'s POMO (which exploits solution symmetry to build multi-start baselines), forming the current mainstream skeleton; subsequent works such as Sym-NCO, MatNet, and BQ mostly improve encoder architectures, baseline design, and decoding strategies (RL4CO). Improvement methods learn operator-selection policies for local search: given an initial solution, a policy network decides which neighborhood operation (2-opt, relocate, exchange, etc.) to apply; typical representatives include NeuRewriter, DACT, and learned large neighborhood search (Neural LNS); this route's advantage is that solution quality keeps improving as search time is extended. Non-autoregressive / heatmap methods have a GNN output, in one shot, the probability that each edge (or decision variable) belongs to the optimal solution, then decode legal solutions with beam search, Monte Carlo tree search, or guided sampling; representative works include UTSP, DIFUSCO, and the diffusion-model solvers emerging since 2024 (e.g., the unsupervised diffusion framework at ICML 2024 and StruDiCO structured denoising diffusion at NeurIPS 2025) (awesome-ml4co). Since 2025 there has also been a trend toward unifying all three: UniCO (ICLR 2025) reduces multiple combinatorial problems to a matrix-encoded general TSP for unified solving, while Unify ML4TSP (ICLR 2025) distills methodological principles from a streamlined "learning + search" design space (awesome-ml4co).
2.2 Comparison of Representative Methods
The table below summarizes representative end-to-end methods and their key characteristics as a reference for engineering selection.
| Method | Year / Venue | Route | Training | Core idea | Applicable problems |
|---|---|---|---|---|---|
| Pointer Networks | 2015, NeurIPS | Constructive | Supervised | Pointer attention outputs a permutation of the input sequence | TSP and geometric problems |
| Bello et al. | 2017, ICLR | Constructive | RL (REINFORCE) | Label-free; train policy on rewards | TSP, knapsack |
| S2V-DQN (Khalil et al.) | 2017, NeurIPS | Constructive | RL (DQN) | Graph embedding + Q-learning to build solutions node by node | Graph CO (MIS, MaxCut) |
| Attention Model (Kool et al.) | 2019, ICLR | Constructive | RL (rollout baseline) | Transformer encoder–decoder for routing | TSP/VRP family |
| POMO (Kwon et al.) | 2020, NeurIPS | Constructive | RL | Multi-start policy exploiting solution symmetry | TSP/CVRP/scheduling |
| L2D (Zhang et al.) | 2020, NeurIPS | Constructive | RL (PPO) | GNN encodes disjunctive graph to learn dispatching rules | Job-shop scheduling (JSP) |
| NeuroLKH (Xin et al.) | 2021, NeurIPS | Hybrid (heatmap + LKH) | Supervised + unsupervised | Learned edge scores and node penalties injected into LKH | Large-scale TSP |
| DACT / improvement Transformers | 2021–2023 | Improvement | RL | Learn sequences of neighborhood operators | TSP/CVRP |
| DIFUSCO / diffusion solvers | 2023–2025 | Heatmap | Supervised / unsupervised | Graph diffusion generates solution distributions + guided sampling | Graph CO, TSP |
| UniCO | 2025, ICLR | Unified constructive framework | RL | Multiple problems reduced to matrix-encoded general TSP | Multiple CO classes |
| LLM end-to-end solvers | 2025, NeurIPS | Constructive | Supervised / RL | LLMs directly as CO solvers | Classical graph problems |
(Compiled from RL4CO, awesome-ml4co, and AI Review 2025)
It must be emphasized that the relative performance of the methods above is highly sensitive to the evaluation setup. RL4CO's systematic comparison under a unified implementation found that some new methods claiming SOTA actually fall behind their predecessors once the evaluation criterion changes (zero-shot performance, generalization, adaptability), and that simple inference-time data augmentation can even outperform sampling-based decoding schemes with far higher computational cost (RL4CO, KDD 2025). This finding has a direct lesson for engineering practice: selection decisions must re-test methods under a unified framework on your own instance distribution, rather than trusting numbers reported in papers.
2.3 The Real Gap with Classical Solvers: A Critical Assessment
End-to-end NCO enjoys great academic visibility, but engineering must confront its gap with classical methods head-on. The 2024 ACM paper Applicability of Neural Combinatorial Optimization offers a critical analysis of the literature, noting that many NCO works compare only against weak baselines on randomly generated small-scale instances—MatNet, for example, still loses to LKH-3 on asymmetric TSP, and a considerable share of papers never compare against state-of-the-art metaheuristics at all (ACM 2024). A 2025 systematic review covering 253 papers on "machine learning for routing problems" from 2016–2025 likewise observes that despite the explosive growth of learning-based publications, classical solvers such as LKH-3 and HGS retain near-optimal accuracy thanks to decades of engineering accumulation, while end-to-end NCO models are generally constrained by missing scalability, generalization, and convergence guarantees (ML-for-routing survey, neural-guided ACO paper).
Concretely, the engineering shortcomings of end-to-end NCO concentrate in four areas. First, scale extrapolation: a model trained on 100-node instances degrades significantly when applied directly to 1,000-node instances, requiring additional mechanisms such as GLOP-style "global partitioning + local construction" or curriculum learning (e.g., the Oxford team's RASCL adaptive stair curriculum, which reduced the average optimality gap on Taillard scheduling benchmarks to 10.46%) (Oxford Math). Second, feasibility guarantees: learned models may output constraint-violating solutions, so industrial problems with hard constraints must append repair procedures. Third, distribution shift: performance becomes uncontrollable when the training distribution diverges from the live distribution. Fourth, training cost: training an NCO model often takes days of GPU time, a cost typically hidden in papers' "inference-time comparisons." That said, the gap is closing fast: recent work such as RsGCN has reached LKH-level quality on large-scale TSPs above 1,000 nodes (while still lagging the exact solver Concorde), with far fewer parameters and lower training cost than earlier NCO models (RsGCN).
2.4 Benchmarks and Evaluation Infrastructure
Standardized evaluation is a prerequisite for the end-to-end route to become engineering-ready. The most important public infrastructure today is RL4CO: a unified RL-for-CO library built on TorchRL, TensorDict, PyTorch Lightning, and Hydra, covering 27 combinatorial optimization environments (TSP, CVRP, job-shop scheduling, facility location, EDA placement, and more) and 23 baseline algorithms, fully decoupling policies, environments, RL algorithms, and trainers—researchers can launch a complete training run in under 30 lines of code (RL4CO GitHub). Published at KDD 2025, the library's greatest value is not the methods themselves but the reproducible comparison benchmarks it provides—the community has since discovered that evaluation protocols influence conclusions far more than expected (RL4CO, KDD 2025).
On the benchmark side, Shanghai Jiao Tong University's Thinklab team built ML4CO-Bench-101 (NeurIPS 2025), a unified benchmark for classical combinatorial problems on graphs (maximum cut, maximum independent set, minimum vertex cover, maximum clique, etc.), complemented by COExpander (ICML 2025, adaptive solution expansion) and diffusion generative search methods targeting test-time scaling (NeurIPS 2025); the awesome-ml4co repository continuously maintains problem-categorized paper lists and benchmark results, including leaderboards for standard settings such as TSP-1000 (Thinklab-SJTU, awesome-ml4co). For engineering teams, the recommended evaluation discipline is: start from RL4CO or ML4CO-Bench, add at least one strong classical baseline (LKH-3/HGS/Gurobi) on your own instance distribution, and report all three metrics—solution quality, end-to-end latency, and amortized training cost.
2.5 Frontier Progress (2024–2026): From Single-Task Specialists to Cross-Problem Generalist Solvers
Since 2024, end-to-end NCO has undergone a clear paradigm shift: the research focus has moved from "training one expert model per problem" to training a single unified (multi-task) solver that generalizes across problems. This route unfolds along two technical paths. The first is constraint-compositional multi-task learning: treating different VRP variants as different combinations of constraint attributes and training a unified model in the combinatorial space to share knowledge—MTPOMO (KDD 2024) and MVMoE (ICML 2024, mixture-of-experts architecture) pioneered coverage of 16 problems; RouteFinder (2024) expanded to 48 VRP variants with an explicit "vehicle-routing foundation model" goal; CaDA (ICML 2025) introduced constraint-aware dual attention to further improve cross-problem capability; and URS (2025) pushed coverage to 107 routing problems through a unified data representation while retaining zero-shot cross-problem generalization (URS). The second path is shared backbone + problem adapters: GOAL (ICLR 2025) trains a generalist agent covering 9 problem classes with supervised learning, while TSP-FT and MTL-MAB use adapters to cut re-training costs for new problems (URS related-work table, MTL-KD). The table below summarizes key attributes of representative unified solvers:
| Method | Year / Venue | Training paradigm | Problems covered | Zero-shot cross-problem | Mechanism highlights |
|---|---|---|---|---|---|
| MTPOMO | 2024, KDD | RL | 16 | ✓ | Constraint-compositional multi-task |
| MVMoE | 2024, ICML | RL | 16 | ✓ | Mixture of experts (MoE) |
| RouteFinder | 2024 | RL | 48 | ✓ | Toward a VRP foundation model |
| CaDA | 2025, ICML | RL | 16 | ✓ | Constraint-aware dual attention |
| GOAL | 2025, ICLR | Supervised | 9 | ✗ (adapter fine-tuning) | Generalist CO agent |
| URS | 2025 | RL | 107 | ✓ | Unified data representation |
(Sources: URS paper, Table 1, NCO-VRP literature list)
A parallel main line confronts NCO with the complexity of real-world routing: RRNCO (ICLR 2026) observes that the uniform random point sets of academic benchmarks differ enormously from demand distributions on real road networks, and its systematic evaluation on real map data shows that many methods that excel on standard benchmarks change rank significantly under real distributions—echoing the critique in §2.3 and marking the community's adoption of "real-distribution generalization" as a first-class evaluation target (RRNCO, ICLR 2026). In addition, a 2026 paper in AI (MDPI) explores a "near-training-free" foundation-model route—constructing routing solvers directly from pre-trained representations and attempting to compress NCO's training cost toward zero, the latest attempt to lower the adoption barrier of the end-to-end route (MDPI AI 2026). Overall assessment: the unified-solver direction has significantly expanded the practical imagination of the end-to-end route, but its solution-quality gap relative to HGS/LKH-3 on real distributions and large-scale instances persists, and the hybrid architecture of Chapter 3 remains the holder of the current performance ceiling.
3. Paradigm 2: Learning-Augmented Classical Solvers
3.1 Learning Components Inside MIP Solvers
In contrast to the end-to-end route's "replacement" philosophy, the learning-augmented route (learning-augmented / learning-guided optimization) embeds learned models at decision points inside classical solvers, preserving the solver's completeness and feasibility guarantees while letting machine learning take over heuristic decisions that traditionally rely on human experience. This is currently the most theoretically robust and industrially accepted route. A 2024 survey in Mathematical Programming systematically organizes learning tasks in mixed-integer programming (MIP) into five categories: branching variable selection, node selection, cut selection, primal heuristics, and solver configuration (Math. Programming 2024).
In branching, Khalil et al. pioneered imitation learning of strong branching in 2016; Gasse et al. (2019) introduced bipartite-graph representations + graph convolutional networks, exploiting the permutation invariance of the MIP variable–constraint bipartite graph and becoming the standard encoding for all subsequent learned branching methods; theoretical work in 2025 further proved that carefully designed second-order GNNs can approximate strong-branching scores on general MIPs with high precision, providing a theoretical foundation for the route (survey of math-programming solvers). In cut selection, Tang et al. (2020) modeled cut selection as an MDP trained with RL; Paulus et al.'s 2022 follow-up validated solving-time gains in SCIP, and other work performs adaptive learning directly on the convex-combination weights of SCIP's four default cut-scoring functions (Math. Programming 2024). In primal heuristics, Nair et al.'s Neural Diving (2020) uses a deep network to predict partial assignments of integer variables, leaving the rest to the MIP solver; Han et al.'s Predict-and-Search framework (2023) combines GNN prediction with trust-region search, reducing the primal gap by 51% relative to SCIP and 9.9% relative to Gurobi; subsequent work includes RL primal heuristics that model feasible-solution search as an MDP (improving the average primal gap over classical heuristics by up to 44×) and FMIP, which uses flow matching to generate joint solution distributions over integer and continuous variables (improving mean absolute gap by 50% over classical GNN heuristics) (Guided Diffusion for IP, MILP learned-heuristics survey). The 2025–2026 frontier is MIP foundation models: MILP-Evolve uses LLMs to generate training data and trains unified neural models across problem categories, serving integrality-gap prediction, branching, and language–MIP alignment tasks alike (EmergentMind MILP).
3.2 Learning-Guided Neighborhood Search and Hybrid Frameworks
On the metaheuristic side, learning's role is to guide search toward more promising regions. NeuroLKH (NeurIPS 2021) is the landmark of this route: it uses a sparse graph network to learn edge scores (supervised) and node penalties (unsupervised), injecting them into the classic Lin-Kernighan-Helsgaun algorithm; trained on instances of at most 500 nodes, it generalizes to 5,000-node instances and outperforms the original LKH overall on 72 TSPLIB instances (ML-for-TSP survey, Springer 2025). Similarly, learned large neighborhood search (Neural LNS) learns where to destroy in the destroy-and-repair operator; new 2026 work injects neural guidance into ant colony optimization (ACO), replacing hand-crafted pheromone rules with dynamic neural signals—the paper explicitly states that such learning-guided optimization (LGO) usually achieves state-of-the-art performance by combining the strengths of both paradigms (neural-guided ACO).
Another important form of the hybrid route is combining learning with decomposition/column generation: for example, using ML to predict pricing-subproblem heuristics in column generation, using classifiers to identify structural features of high-quality solutions, or using RL to guide search trees in constraint programming to minimize search size (already validated on scheduling benchmarks) (CIIRC project description). The common trait of these works is "small but precise"—the learned model is responsible for only one narrow decision point, and training data can be generated offline by the solver itself, so training cost is low and failure risk is contained: precisely the properties industrial deployment values most.
3.3 Why the Hybrid Route Is Today's Industrial Mainstream
From an engineering perspective, the hybrid route beats the end-to-end route for three reasons. First, risk structure: in hybrid methods, even if the learned component fails entirely, the solver degrades to its default heuristic rules and still produces legal solutions with guaranteed quality—this "graceful degradation" property is vital for production systems, whereas an end-to-end model's failure modes are uncontrollable. Second, evidence accumulation: commercial and open-source solvers (Gurobi, SCIP, CP-SAT) have been validated for decades, and the organizational cost of migrating trust far exceeds what a few percentage points on academic metrics can motivate. Third, data availability: training data for hybrid methods (branching decision logs, cut-plane payoffs, solutions to historical instances) accumulates automatically during everyday solving, requiring no extra labeling. A strong corroborating data point: even on academic benchmarks, the strongest "learning-based" results today mostly come from hybrid architectures—for example, a scalable "learning + integer linear programming" framework improves large-scale CVRP solving while preserving feasibility and practical constraints (PeerJ CS 2026).
For teams adopting this route, Ecole is the most important piece of infrastructure: a Gym-like library that exposes decision points inside the SCIP solver (branching, node selection, etc.) as standard reinforcement-learning environments, turning the training of customized solver components into an ordinary RL engineering task (Ecole cited in the RL4CO paper). Together with PySCIPOpt and open-source SCIP, a two-person team can build a "learned branching policy" prototype within weeks.
3.4 Frontier Progress (2024–2026): LLMs Enter the Solver; the Predict-and-Search Family Grows
Learning-augmented solvers deepened along three directions in 2024–2026. First, the engineering and lightweighting of learned branching. Gupta et al.'s hybrid architecture (whose influence from NeurIPS 2020 continues to grow) showed that a "heavy–light" arrangement—GNN only at the root node, MLP for subsequent nodes—can cut solving time by up to 26% in a pure-CPU environment, a result of major significance for deployment since virtually all commercial MILP solving runs on CPUs (Hybrid Learn2Branch). A 2025 paper in Soft Computing further unifies node selection and variable selection in a single GNN framework, surpassing SCIP and then-current RL baselines on four classical benchmark families (Soft Computing 2025); meanwhile Symb4CO uses symbolic regression to search directly for human-readable branching rules, and SORREL combines offline pre-training with self-imitation learning, advancing on the pain points of "interpretability" and "escaping expensive expert demonstrations" respectively (LLM4Branch related work).
Second, the predict-and-search family is growing rapidly. After Neural Diving and Predict-and-Search came the contrastive-learning variant Contrastive Predict-and-Search, SymILO exploiting MILP permutation symmetry, DiffILO introducing gradient information, the "predict–correct" framework Apollo-MILP, and—in late 2025—CoCo-MILP, which further improves GNN solution prediction with inter-variable contrastive losses and intra-constraint competition layers (CoCo-MILP, Apollo-MILP related work). Third—and most paradigm-significant—LLMs are entering the design loop of internal solver components. LLM4Branch (2026) lets an LLM (DeepSeek-R1) automatically discover branching policies as executable programs: the LLM generates program skeletons for policies, zeroth-order optimization (Bayesian optimization) fine-tunes parameters against real solver feedback, and the whole evolutionary loop—built on OpenEvolve and Ecole—automatically evolves policies that beat hand-crafted rules, optimizing the geometric mean of branch-and-bound node counts (LLM4Branch); contemporaneous work includes LLM-driven large neighborhood search for MILP (ICML 2025), LLM-guided dynamic scheduling of branching rules, and online algorithm configuration (awesome-fm4co). This means the two threads of "learning-augmented components" (this chapter) and "LLM-evolved heuristics" (Chapter 6) are now converging inside solvers.
On the evaluation side, the 2026 FrontierCO benchmark systematically stress-tested contemporary ML solvers on real-world and large-scale instances; entrants span tree-MDP branching (tMDP), SORREL, GCNN branching, IL-LNS/CL-LNS neighborhood search, MPGN for FJSP, and learning-guided rolling-horizon optimization (L-RHO), among others. Its conclusions extend this report's thesis: learning methods deliver real speedups on in-distribution cases, but classical solvers remain the baseline of performance and robustness under distribution shift and at very large scale (FrontierCO). The direct advice for engineering teams: when evaluating any learning-augmented component, prefer results from such third-party unified benchmarks over the speedups self-reported in the original paper.
4. Paradigm 3: Learning to Optimize (Learned Optimizers)
4.1 Replacing Hand-Designed Optimization Algorithms with Learning
Learning to Optimize (L2O) is the most "meta" of the six paradigms: the object being learned is not the solution to some problem, but the optimization algorithm itself. Its standard formalization: given a family of training optimization problems , learn a parameterized update map (where contains historical iterates and gradient information) such that, on new problems sampled from the distribution, the learned optimizer converges faster than analytic optimizers like SGD/Adam or reaches better solutions under the same compute budget (OpenReview L2O). The direction was founded by Andrychowicz et al.'s 2016 LSTM optimizer and Li & Malik's RL optimizer, followed by a long period of improvements overcoming pathological long-unroll gradients and improving cross-task generalization; the 2022 JMLR paper Learning to Optimize: A Primer and A Benchmark (by teams including USTC and Huawei Noah's Ark) established unified implementation standards and a benchmark, and remains the standard introductory reading (JMLR 2022).
L2O has long been criticized for "working only on the training distribution and lacking convergence guarantees"; both shortcomings have seen substantive progress recently. On generalization, an AISTATS 2023 paper used Hessian regularization to give learned optimizers provable generalization to unseen network architectures and datasets (AISTATS 2023); on convergence guarantees, a 2024 framework decomposes the update rule into a "convergence-guaranteed gradient-descent term + a performance-boosting neural-network innovation term," achieving—for the first time—an optimizer with both provable convergence on smooth non-convex functions and learned acceleration (technical overview). A more theoretical sub-line interprets Transformers' in-context learning as implicitly executing (preconditioned) gradient descent, mechanistically connecting "large-model inference" with "learning to optimize" (arXiv 2024).
4.2 The Industrialization of HPO and Symbolic Optimizer Discovery
The most mature industrial form of L2O is not in neural-network training but in black-box / hyperparameter optimization (HPO). Google's OptFormer (NeurIPS 2022) is the landmark: it serializes entire hyperparameter-optimization processes (including task metadata text) into tokens and pre-trains a Transformer on years of real optimization trajectories accumulated by Google's Vizier service plus the public HPO-B and BBOB benchmarks; the resulting model can both imitate the behavior of classical algorithms such as Regularized Evolution and serve as a better-calibrated objective predictor than Gaussian processes—a first sketch of a "universal hyperparameter optimizer" (Google AI Blog). OptFormer's significance is the demonstration that when an organization possesses massive historical optimization-experiment data, meta-learning can convert that sediment into transferable optimization capability.
A second sub-line with more direct industrial impact is symbolic optimizer discovery. Google's VeLO (Versatile Learned Optimizer, 2022) meta-trained a general-purpose learned optimizer over thousands of tasks; the 2023–2024 "symbolic discovery of optimization algorithms" work used evolutionary search in program space to discover the Lion optimizer directly—its update rule consists of simple symbolic expressions, uses less memory than Adam, and performs better on many models, and it has since been adopted by numerous open-source training frameworks (DeepMind math-optimization research roundup). This idea of "searching algorithm space rather than numerical space" descends from the same lineage as Chapter 6's FunSearch/AlphaEvolve family, jointly pointing to one trend: optimization algorithms themselves are turning from hand-crafted artifacts into searchable, evolvable objects.
4.3 Frontier Progress (2024–2026): The Muon Event and the Industrialization of Optimizer Discovery
In late 2024 the L2O field saw its most industrially consequential event in a decade—the birth and explosive adoption of the Muon optimizer. Muon (MomentUm Orthogonalized by Newton-Schulz) was forged by Keller Jordan and collaborators in the NanoGPT speedrun competition: momentum updates to hidden-layer parameters are orthogonalized via Newton-Schulz iteration before being applied. In October 2024 it improved the NanoGPT training-speed record by 1.35×; the record was subsequently refreshed 12 times by 7 different researchers without being overturned, compressing GPT-2 training wall-clock time from a 45-minute baseline to under 3 minutes (original Muon blog post, modded-nanogpt). In February 2025, Moonshot AI and UCLA's Muon is Scalable for LLM Training demonstrated roughly 2× compute efficiency over AdamW on 3B/16B-parameter MoE models and proposed stabilization techniques such as MuonClip; the trillion-parameter-class MoE model Kimi K2, released in July 2025, was trained end-to-end with the Muon family without a single loss spike—marking this "competition artifact's" formal entry into frontier-LLM production pipelines (Muon is Scalable, Kimi K2). Microsoft's Dion (August 2025) works to adapt orthogonalized updates to the communication constraints of distributed training, further clearing engineering obstacles (Microsoft Dion coverage).
The Muon event's significance for L2O methodology arguably exceeds that of the optimizer itself. Jordan states explicitly in his blog that the NanoGPT speedrun, as a competitive task framework, fundamentally solves the "undertuned baseline" problem that has long plagued optimizer research: anyone can overturn Muon's record by switching back to carefully tuned AdamW, so the record's continued existence is itself publicly verifiable evidence—a brand-new empirical-sociological mechanism for the controversy over "whether learned/searched optimizers are actually good" (original Muon blog post). Building on this, the 2025 automated LLM speedrun benchmark goes one step further: having AI agents automatically reproduce and surpass the NanoGPT lineage of improvements, turning "optimization-algorithm design" itself into an automatically scoreable agent task (Automated Speedrun Benchmark); the speedrun competition subsequently added Track 3, which fixes model, data, and scripts while opening only the optimization algorithm and hyperparameters—dedicated to evaluating automated optimizer discovery—and platforms such as Prime Intellect have begun running autonomous AI research agents against that track (Prime Intellect). With this, L2O has closed a loop: from "learning an optimizer" (§4.1) to "screening optimizers with competitive benchmarks" to "letting AI agents design optimizers autonomously"—optimizer design is becoming an automatable, verifiable, iterable engineering discipline.
5. Paradigm 4: Decision-Focused Learning and Differentiable Optimization (Predict-then-Optimize)
5.1 Problem Setup: Making Predictions Accountable to Decisions
Real industrial optimization pipelines are almost always two-stage: first use machine learning to predict uncertain parameters (demand, prices, travel times), then feed the predictions into an optimization model. Traditional "predict-then-optimize" trains the predictive model to minimize prediction error (e.g., MSE), but accurate prediction does not equal good decisions—a symmetric prediction error can have highly asymmetric effects on decision cost (overestimating demand and underestimating it carry completely different costs). Decision-focused learning (DFL) targets precisely this mismatch: at training time it embeds the downstream optimization problem into the computation graph and trains directly on final decision quality (regret). Mandi et al.'s 2024 survey systematically maps the DFL technical landscape, classifying gradient-acquisition methods into four families—surrogate losses, differentiable relaxations, perturbation methods, and gradient-free estimation—and experimentally compares 11 mainstream techniques on benchmark problems (Mandi et al. 2024).
The paradigm's cornerstone is Elmachtoub and Grigas's Smart Predict-then-Optimize (SPO) framework and its convex surrogate loss SPO+: since the true regret's gradient with respect to predicted coefficients is zero almost everywhere, SPO+ constructs a Fisher-consistent convex upper-bound surrogate and provides a subgradient usable for neural-network backpropagation, (Mandi et al. 2024). Other important techniques include Fenchel–Young losses (structured prediction), Berthet et al.'s differentiable perturbed optimizers (obtaining smooth gradients by averaging over perturbed solutions), and the OptNet line of methods that embed optimization problems as differentiable layers in networks. A 2025 contextual-optimization survey in EJOR broadens the view to contextual decision problems under uncertainty, covering the full spectrum from sample average approximation to distributionally robust approaches (TRISTAN 2025 proceedings).
5.2 Toolchain and Applicable Scenarios
DFL has the most complete engineering loop of the six paradigms, and its core tool is PyEPO: a PyTorch-based end-to-end "predict–optimize" library with built-in autograd functions for mainstream methods (SPO+, differentiable perturbation, contrastive losses), optimization backends connectable to Gurobi and other solvers; users only need to subclass optGrbModel to define their optimization model and gain end-to-end training capability. The library has been formally published in Mathematical Programming Computation (PyEPO). Its surrounding research ecosystem also includes decision-focused fine-tuning (2025)—balancing prediction accuracy against decision loss in a constrained-optimization form for data-limited settings (arXiv 2025).
Engineering-wise, DFL fits best when three features coincide: the optimization model's objective coefficients depend on predictions (costs, demand, travel times); there is a known asymmetry between prediction error and decision cost; and historical (features, realizations, decision outcomes) data is abundant. Typical applications include electricity-price prediction + unit commitment in power markets, travel-time prediction + vehicle routing in logistics, and demand prediction + replenishment optimization in inventory. Conversely, if prediction error is already near the noise floor, or decisions are insensitive to prediction error, DFL's extra complexity (each training iteration must solve an optimization problem, significantly increasing compute) is hard to recoup. In practice, first use PyEPO on small-scale data to compare decision regret between the "two-stage MSE baseline" and "SPO+ end-to-end," then decide whether to invest.
5.3 Frontier Developments: Benchmark Standardization and a Unified View of Contextual Decisions
DFL's important progress in 2024–2026 lies not in any single new algorithm but in standardized evaluation and a unified problem perspective. Mandi et al.'s 2024 survey, beyond organizing the technical genealogy, conducted the first controlled experimental comparison of 11 mainstream DFL methods on unified benchmark problems, revealing the global picture of "the trade-off curve between training efficiency and decision quality for surrogate-loss methods"—previously obscured by papers' individual reporting conventions—providing the first horizontal evidence base for engineering selection (Mandi et al. 2024). The 2025 contextual-optimization survey in EJOR places DFL under a larger umbrella: any problem that makes uncertainty-facing decisions conditioned on covariates (features)—whether using SPO-style regret training, sample average approximation, or distributionally robust optimization—shares the same theoretical framework of "how predictive distributions should serve decisions" (TRISTAN 2025 proceedings).
Another noteworthy development is DFL's interface with the foundation-model era. Decision-focused fine-tuning (2025) transplants DFL's objective to the adaptation stage of pre-trained models: in data-limited settings it simultaneously constrains prediction accuracy and decision loss in constrained-optimization form, preventing the fine-tuning process from degrading downstream decision performance (arXiv 2025). The implicit judgment of this direction: as predictive models are increasingly carried by general-purpose foundation models, "how to preserve decision quality when freezing or fine-tuning a foundation model" will replace "how to train a decision-friendly predictor from scratch" as DFL's main battleground. The engineering action advice is unchanged—first run a small-scale PyEPO comparison between the two-stage MSE baseline and SPO+ end-to-end—but the evaluation checklist should gain one item: if the prediction side already uses (or plans to use) a foundation model, prefer decision-focused fine-tuning methods over full retraining.
6. Paradigm 5: LLM-Driven Optimization
6.1 LLMs as Optimizers: OPRO and Prompt-Space Search
Since 2023, large language models have brought an entirely new working mode to optimization. The most direct form is OPRO (Optimization by PROmpting, ICLR 2024): treat the LLM itself as a black-box optimizer—place previously evaluated "solution–score" pairs in the prompt, let the model generate better candidate solutions, and iterate. OPRO validated the idea on linear regression and the traveling salesman problem; its essence is to hand the optimization "proposal distribution" to the language model's prior knowledge (SimTIO survey chapter). The paradigm's advantages are a zero-code threshold and native multi-objective trade-off ability (preferences can be described in natural language); its limitations are suitability only for small-scale, textually representable search spaces, with evaluation costs borne by the caller.
OPRO's idea quickly combined with classical prompt engineering, spawning variants such as automatic prompt optimization, adaptive zeroth-order optimization (AdaEvolve), and EvoX, which lets the LLM evolve both candidate solutions and the search strategy itself; academia has also begun systematically building evaluations, such as OPT-BENCH (measuring LLM agents' optimization ability in large search spaces), ALE-Bench for long-horizon algorithm engineering (a NeurIPS 2025 datasets-and-benchmarks track), and HeuriGym (ICLR 2026, an agentic benchmark for LLM-designed combinatorial-optimization heuristics) (awesome-fm4co). For engineering teams, the best current positioning of such methods is rapid prototyping and small-scale black-box tuning, not replacing numerical optimizers.
6.2 Heuristic Evolution and Algorithm Discovery: The FunSearch–AlphaEvolve Lineage
The most influential form of LLM optimization is the triple structure of "LLM generation + automatic evaluation + evolutionary search." DeepMind's FunSearch (Nature 2023) is the paradigm's founding work: it frames problems as "search in the space of functions (programs)"; the LLM rewrites the priority functions of candidate programs; an automatic evaluator scores candidates and filters hallucinations; and island-style evolutionary strategies maintain population diversity. The system discovered a new size-512 construction for the Cap Set problem in combinatorial mathematics (surpassing known human results) and evolved heuristics for online bin packing that beat first-fit/best-fit—becoming the first LLM system to produce verifiable new knowledge (DeepMind blog, Wikipedia: FunSearch).
The lineage then evolved rapidly: EoH (Evolution of Heuristics, 2024) co-evolves heuristics' natural-language "thoughts" and their corresponding code, surpassing FunSearch on multiple combinatorial problems; ReEvo (NeurIPS 2024) introduces reflection, converting performance comparisons into linguistic feedback guiding the next generation; MCTS-AHD organizes candidate programs with Monte Carlo tree search; and AlphaEvolve (DeepMind, May 2025) pushed the entire paradigm to industrial scale—a Gemini-powered evolutionary coding agent that can evolve entire codebases (rather than single functions), supports arbitrary programming languages, can evaluate in parallel for hours, and optimizes multiple metrics simultaneously; its results include breaking the matrix-multiplication algorithm record (48 multiplications for 4×4 complex matrices) and improving Google's data-center scheduling and chip-design circuits (FunSearch vs AlphaEvolve comparison, awesome-llm-evolution). The table below compares the capability differences of the lineage's two milestone systems:
| Capability dimension | FunSearch (2023) | AlphaEvolve (2025) |
|---|---|---|
| Code scope | Evolves a single function | Evolves entire codebases |
| Code size | 10–20 lines | Up to hundreds of lines |
| Language support | Python only | Any programming language |
| Evaluation compute | ≤20 min / single CPU core | Parallel, accelerators, hours-long runs |
| LLM usage | Millions of samples | Thousands of samples suffice |
| Context feedback | Historical solutions only | Rich context and evaluation feedback |
| Optimization target | Single metric | Multiple metrics simultaneously |
| Representative results | New Cap Set construction; bin-packing heuristics | Matrix-multiplication record; data-center scheduling improvements |
(Source: Richard Suwandi's technical blog)
On the open-source side, OpenEvolve provides an open reproduction framework of AlphaEvolve (supporting multi-language generation, integrated agents, and custom evaluation loops), while LLaMEA uses GPT-4 to iteratively evolve optimization-algorithm code and surpasses classical optimizers on benchmark suites; the community-maintained awesome-llm-evolution list continuously indexes frameworks in this space by direction—code discovery, game strategies, molecules and materials, prompt optimization, and more (awesome-llm-evolution). The lesson for engineering teams is clear: if your team has a programmatically evaluable objective function (even a simulator), a FunSearch-style framework is currently the most cost-effective path to "automatically inventing domain heuristics," and OpenEvolve has brought the setup cost down to an acceptable level.
6.3 LLM Automated Modeling: From Natural Language to Solver Code
The biggest labor bottleneck in OR adoption has never been solving but modeling—translating business language into mathematical programming models. LLMs are systematically attacking this step. Milestone works include: the NL4OPT competition's natural-language-to-LP modeling benchmark; Microsoft's Chain-of-Experts multi-agent framework, which significantly surpasses GPT-4 baselines; OptiMUS (ICML 2024), which completes MILP modeling and solving with a structured agent sequence (preprocessing—connection graph—per-item modeling—code generation—unit testing—debugging iterations), improving over the previous best method by more than 20% on a simple dataset and by more than 30% on its released complex dataset NLP4LP; and ORLM, which instead fine-tunes open-source models on semi-synthetic data, achieving performance comparable to OptiMUS while protecting data privacy (OptiMUS, ICML 2024, ORLM). Microsoft's OptiGuide uses LLMs to explain supply-chain optimization results and support "what-if" interactive queries, while OptiChat specializes in diagnosing infeasible models (ORLM literature review).
The engineering value of this direction is immediate: business users describe problems in natural language; the LLM generates models and solver code; classical solvers guarantee correctness and optimality—the LLM never touches numerical computation, doing only the semantic translation it excels at, and the architecture's risk structure is exactly that of Chapter 3's hybrid route. Follow-up work in 2025–2026 (ORMind's cognition-inspired end-to-end reasoning framework, AutoOR's scalable automated-formalization post-training, NED-Tree's support for nonlinear-optimization modeling) is further covering more complex modeling scenarios (awesome-fm4co). On the commercial side, NVIDIA has released validated "agent skills" for cuOpt, letting AI agents complete the "natural-language business problem → mathematical model → optimized decision" loop in seconds (NVIDIA cuOpt).
6.4 LLM End-to-End Solving and Inference-Time Search
The most radical direction has LLMs directly output solutions to combinatorial optimization problems. NeurIPS 2025's Large Language Models as End-to-end Combinatorial Optimization Solvers explored the feasibility of training LLMs as end-to-end solvers, covering classical graph problems such as maximum independent set and vertex cover (awesome-ml4co). A concurrent rise is "LLM + tree search" for inference-time planning: an October 2025 unifying survey systematically organizes MCTS variants in LLM reasoning (MCTSr, RethinkMCTS, AB-MCTS, etc.); the core design question is reliable value estimation for partial reasoning trajectories—from training external reward models, to LLM self-evaluation, to backpropagating environment rewards, to simply dropping the rollout step and guiding expansion directly with self-evaluation scores (tree-search unifying survey).
A sober assessment is needed: LLM end-to-end solving currently cannot touch specialized NCO models in scale or precision, let alone classical solvers; its strategic value lies in generality and interface naturalness—the same model can cross problem types and directly consume natural-language constraints. The pragmatic judgment: as of 2026, the LLM's best position in the optimization stack is the "modeling layer" and the "heuristic-design layer" (§6.2, §6.3), not the "numerical-solving layer"; but with the rapid accumulation in FM4CO (foundation models for combinatorial optimization)—the awesome-fm4co list indexed dozens of related papers in 2025–2026—this judgment warrants quarterly re-examination (awesome-fm4co).
6.5 Frontier Progress (2025–2026): Evaluation Suites Crystallize and Paradigms Fuse
The most significant change in LLM optimization in 2025–2026 is the rapid crystallization of evaluation infrastructure, moving the field from "case demonstrations" to "capability characterization." On the modeling side appeared a large batch of benchmarks and datasets: OptiBench (with the ReSocratic reverse-synthesis data method, ICLR 2025), ORQA measuring OR reasoning (AAAI 2025), CP-Bench for constraint-programming modeling (ECAI 2025), the cross-domain modeling dataset Text2Zinc, and DRoC, a constraint-decomposition retrieval method covering 48 VRPs (ICLR 2025) (awesome-fm4co). On the algorithm-discovery side, beyond ALE-Bench, OPT-BENCH, and HeuriGym introduced earlier, AAAI 2026's CO-Bench specifically measures language-model agents' end-to-end ability in combinatorial-optimization algorithm search; on training methods, NeurIPS 2025's SolverLLM uses a training-free improved MCTS (dynamic expansion + prompt backpropagation + uncertainty backpropagation) to search the "modeling-solution space" at inference time, while Solver-Informed RL (NeurIPS 2025) uses solver feedback directly as reinforcement-learning reward to train modeling models, and StepORLM (2025) further introduces generative process supervision for self-evolution (SolverLLM, StepORLM).
The second change is fusion among paradigms. Beyond the FunSearch lineage, 2025–2026 brought CALM (co-evolution of algorithms and language models, ICLR 2026), ShinkaEvolve (open-ended, sample-efficient program evolution, ICLR 2026), EvoCut (evolution-guided strengthening of cutting planes for integer programming), and FormuEvo (LLM-guided evolution to discover more easily solvable MILP formulations, EMNLP 2026)—extending the object of evolution from "heuristic functions" to cutting planes, model formulations, and multi-objective heuristic portfolios (awesome-fm4co). Especially noteworthy is EALG's adversarial co-evolution: letting the LLM simultaneously evolve "ever-harder problem-instance generators" and "heuristics that solve them," integrating instance generation and solver design into one closed loop and exploring automatic benchmark renewal to avoid overfitting (EALG). The publication of a systematic survey in ACM Computing Surveys (April 2026) and a dedicated LLM meta-optimizer survey (January 2026) signals that knowledge accumulation in this direction has reached a density requiring secondary synthesis (ACM CSUR 2026, Springer survey 2026).
For engineering practice, these developments carry three direct implications. First, selection should prefer publicly available results on unified benchmarks such as OptiBench and CO-Bench, and be wary of single-paper claims on self-built datasets. Second, "solver-in-the-loop" has become standard design at both training and inference—SolverLLM and Solver-Informed RL prove from two paths the necessity of constraining LLM outputs with solver feedback. Third, the boundary between LLMs and solvers/evolutionary search is blurring; per Chapter 11's architectural principles, design the LLM layer as a replaceable module so the system can absorb the latest results of this fast-moving layer.
7. Paradigm 6: Learning-Based Planning and Control
7.1 Learning-Augmented MPC and Safety Guarantees
In continuous control, the most mature form of "learning-based planning" is the fusion of learning with model predictive control (MPC). Hewing et al.'s 2020 review in the Annual Review of Control, Robotics, and Autonomous Systems laid the framework: use data to learn MPC's dynamics model, cost function, or constraints (e.g., Gaussian processes for residual dynamics) while exploiting MPC's constraint-handling ability to guarantee safety (cited in arXiv 2509.15799). Reiter et al.'s 2025 Synthesis of Model Predictive Control and Reinforcement Learning in the IEEE Open Journal of Control Systems further provides a unified taxonomy of MPC × RL: MPC can serve as RL's function approximator (parameterizing MPC with value functions/policies), and RL can serve as MPC's global approximator (learning value functions to shorten prediction horizons and reduce online computation)—the two routes complement each other in engineering (Reiter et al. 2025).
Safety is the paradigm's central concern. Representative mechanisms include: Koller et al.'s 2018 safe exploration for learning-based MPC (constraining exploration regions with Gaussian-process confidence bounds), Zanon & Gros's robust-MPC-based safe reinforcement learning (IEEE TAC 2021), and Wabersich & Zeilinger's predictive safety filter—wrapping the learned policy's output in an MPC safety layer that intercepts actions that might cause constraint violations (cited in arXiv 2509.15799). In engineering practice, this "learned policy + safety filter" sandwich architecture has become the standard pattern for deploying learned policies in robotics and industrial control: 2024 quadrotor wind-disturbance-rejection research used incremental Gaussian processes to learn wind-disturbance models online, embedded in an MPC framework, significantly improving trajectory accuracy in gusty environments (ACM 2024); DeepSafeMPC combines deep-learning dynamics predictors with MPC constraint enforcement for multi-agent safe reinforcement learning (arXiv 2024).
7.2 Robot Motion Planning and Task-and-Motion Planning (TAMP)
The learning-ization of robot motion planning has two main threads. The first is using learning to accelerate or replace sampling/optimization planners: from early neural motion planning (RL achieving faster planning than sampling planners on new environments) through CoMPNetX (conditional generative networks + neural projection operators generating constraint-satisfying configurations) to 2024's Neural MP—a large-scale neural motion planner aimed at generalization, targeting single-model cross-scenario planning (ACM TAMP trends, cited in NeurRAFT). The second is diffusion-model planning: Motion Planning Diffusion (IEEE T-RO 2025) models trajectory generation as a diffusion process with test-time cost guidance; EDMP guides diffusion with cost ensembles; DiffusionSeeder (CoRL 2025) uses diffusion models to generate high-quality initial solutions (warm starts) for optimization-based planners; and 2026's NeurRAFT further introduces flow matching and gap-aware preference fine-tuning (NeurRAFT). The diffusion route's engineering appeal: after one training run, planning becomes a few denoising forward passes, and multimodal solution distributions naturally fit the interaction scenario of "offering operators multiple candidate trajectories."
At the higher level of task-and-motion planning (TAMP), learning's role is to guide the coupling of symbolic and geometric planning: learning importance distributions for sampling, learning feasibility classifiers to replace expensive motion-feasibility checks, learning low-level transition models for operators, and even using video world models in place of analytical simulators for zero-shot planning (TAMP learning survey). These component-level learning methods share Chapter 3's hybrid philosophy: the symbolic planner guarantees logical correctness; learned modules provide acceleration and generalization.
7.3 End-to-End Autonomous Driving Planning
Autonomous driving is the most industrially invested area of learning-based planning. In 2023, UniAD (CVPR 2023 Best Paper) integrated perception, prediction, and planning into a single network with a "planning-oriented" unified framework, eliminating error accumulation from module cascades and opening the end-to-end paradigm; the VAD series improved efficiency with vectorized scene representations, and VADv2 introduced probabilistic planning over 8,192 anchor trajectories to handle multimodality; in 2024–2025 diffusion policies entered the planning module (DiffusionDrive generates diverse trajectory proposals on anchor trajectories with truncated denoising), the world-model route (WoTE uses a BEV world model for online trajectory evaluation and selection) and the VLM/LLM-augmented route (DriveVLM, EMMA, etc., using language models' world knowledge for long-tail scenarios) advanced in parallel (DeepSight related work, AutoMoT related work).
The core shortcoming of end-to-end methods lies in imitation learning's inherent flaw: the training objective is reproducing expert trajectories rather than optimizing driving performance, leading to insufficient generalization and interpretability in long-tail closed-loop scenarios (DeepSight). A clear trend since 2025 is using reinforcement learning to complement imitation learning—the READ framework, for example, uses RL on top of a diffusion planner to explicitly optimize driving-performance metrics, unlocking the full potential of multimodal action spaces; NeurIPS 2024's closed-loop evaluation benchmark (an end-to-end driving benchmark augmented with world-model RL experts) provides a standardized arena for such research (READ, OpenReview, Thinklab repositories). The engineering conclusion: autonomous-driving planning stacks are converging to a composite architecture of "imitation learning as the base + diffusion/anchor representations for multimodality + RL fine-tuning + a rule-based safety layer as backstop," highly isomorphic to robotics' "learning + safety filter" pattern.
7.4 LLM Embodied Task Planning
What LLMs bring to robotics is not low-level control but commonsense-driven task-level planning. SayCan (Google, 2022) is the foundational work: the LLM scores candidate skills for semantic relevance; each skill's learned value function (affordance) evaluates executability in the current state; their product selects the next action—achieving 84% planning success and 74% execution success across 101 real kitchen tasks (Figure 3a), with performance automatically improving as the underlying language model is upgraded (SayCan website). Code as Policies (Google, 2022) has the LLM directly generate executable robot policy code, exploiting code's loops, conditionals, and library calls to express complex logic; Voyager (2023) demonstrated a lifelong-learning agent paradigm of "automatic curriculum + skill library + iterative prompting" in Minecraft; Inner Monologue, SayPlan, LLM+P and others explored environment-feedback loops, 3D scene-graph planning, and the neuro-symbolic combination of "LLM translation + classical planner solving" respectively (embodied-agent attack-surface survey, ITP paper).
Figure 3. (a) SayCan planning/execution success rates by task family in mock and real kitchens (data: Ahn et al. 2022, 101 tasks in total); (b) summary of quantified gains from representative industrial deployments (sources cited throughout Chapter 9)
Figure 3a reveals a law vital to engineering deployment: there is a systematic gap between planning success and execution success, and noun-based instructions (involving object reference) and embodied-reasoning tasks have significantly higher failure rates—SayCan's error analysis attributes roughly 65% of errors to the LLM side and 35% to the affordance-evaluation side (SayCan paper). This means that when deploying LLM task planning, the bottleneck often lies not in the language model itself but in skill-library coverage and the calibration quality of affordance models; behavior-tree execution shells, failure-retry mechanisms, and decision audit logs are mandatory components of production systems.
7.5 Frontier Progress (2024–2026): VLA Robot Foundation Models and Large Driving Models
Between 2024 and 2026, robot learning completed a paradigm leap from "task-specific policies" to vision–language–action (VLA) foundation models—essentially the sinking and fusion of §7.4's LLM task planning into low-level control. Physical Intelligence's π0 (2024) established the mainstream architecture: a pre-trained VLM (PaliGemma 3B) as the backbone inherits internet-scale semantic understanding, while an attached "action expert" module generates continuous action sequences via flow matching, achieving unprecedented completion on long-horizon dexterous tasks requiring 5–20 minutes of continuous execution (laundry folding, table bussing), with pre-training roughly doubling fine-tuning efficiency for new tasks versus training from scratch (π0). π0.5 (April 2025) further achieved open-world generalization—performing mobile manipulation in entirely unseen home environments (VLA industrial-transfer survey). NVIDIA's GR00T N1 (March 2025) takes a "dual-system" route: a vision–language module (System 2) handles environment understanding and instruction parsing, while a diffusion Transformer module (System 1) generates fluid actions in real time; the two modules are trained end-to-end jointly on a heterogeneous mixture of real robot trajectories, human videos, and synthetic data, and the system has been deployed on the Fourier GR-1 humanoid for language-conditioned bimanual manipulation (GR00T N1). Google's Gemini Robotics (2025) and the open-source ecosystem's OpenVLA, Octo, RDT-1B and others complete the spectrum of this direction (VLA model genealogy list). The table below summarizes the architectural divides among mainstream VLA / robot foundation models:
| Model | Organization, year | Architectural highlights | Open source |
|---|---|---|---|
| RT-2 | Google DeepMind, 2023 | VLM co-fine-tuning; actions discretized as tokens | No |
| Octo | Multi-university, 2024 | Open generalist robot policy; Transformer diffusion head | Yes |
| OpenVLA | Stanford et al., 2024 | 7B open VLA built on Llama 2 + vision encoder | Yes |
| RDT-1B | Tsinghua, 2024 | Bimanual-manipulation diffusion foundation model | Yes |
| π0 / π0.5 | Physical Intelligence, 2024/2025 | VLM backbone + flow-matching action expert; open-world generalization | Partial |
| GR00T N1 | NVIDIA, 2025 | Dual system: VLM slow thinking + diffusion Transformer fast reflexes | Yes |
| Gemini Robotics | Google DeepMind, 2025 | Gemini's multimodal capability extended to the physical world | No |
(Sources: VLA genealogy list, VLA industrial-transfer survey)
On the autonomous-driving side, the 2024–2026 main line is the end-to-end paradigm moving from research consensus to commercial deployment and architectural upgrades. A 2026 industry survey systematically records the transition from modular rule-based pipelines to "large driving models" (LDM): Tesla FSD switched to true end-to-end operation from V12, with V13/V14 adding audio-based environment perception and multi-second temporal reasoning; in June 2025, Waymo and Tesla simultaneously launched commercial robotaxi services in Austin—a head-on collision between the "multi-sensor redundancy" and "pure-vision end-to-end" routes; in early 2026 NVIDIA released an urban autonomous-driving development ecosystem spanning world foundation models, large-scale evaluation datasets, and open-source driving agents (LDM industry survey). On the academic frontier, NeurIPS 2025's AutoVLA brings VLA architecture and test-time compute into driving planning: through chain-of-thought reasoning and physical-action tokenization it directly generates planned trajectories in a unified autoregressive process, and with GRPO reinforcement fine-tuning achieves a 10.6% PDMS improvement on NAVSIM while cutting runtime overhead by 66.8%, scoring highest on the hardest scenario dimension (RFS Spotlight) of the Waymo vision-based end-to-end challenge (AutoVLA, AutoVLA project page). This "VLA + reinforcement fine-tuning" combination is highly isomorphic to robotics' evolution, corroborating Chapter 13's judgment that "the six paradigms are converging."
8. Scheduling and Manufacturing: The Practical Landscape of Deep-Learning Scheduling
8.1 From L2D to the GNN+DRL Standard Paradigm
Job-shop scheduling (JSP) and its flexible variant (FJSP) are the most industrialized learning battleground in combinatorial optimization. The foundational work is NeurIPS 2020's L2D (Learning to Dispatch): modeling JSP as a Markov decision process on disjunctive graphs, extracting state embeddings with GNNs and training dispatching policies with PPO, it demonstrated that "learned dispatching rules can generalize to larger instances and beat classical dispatching rules" (GNN+DRL scheduling survey). Over the following five years the direction settled into a stable technical stack: states represented as disjunctive/heterogeneous graphs, actions as machine–job pair selections, algorithms dominated by PPO/MAPPO, and rewards mostly incremental forms of makespan. Multiple 2024–2025 surveys systematically map this landscape: graph representations evolved from single disjunctive graphs to heterogeneous graphs containing machine and job nodes (HGIN); training evolved from single-agent PPO to multi-agent MAPPO; objectives expanded from makespan alone to multiple objectives including energy consumption and tardiness (Springer survey 2024, KBS survey 2025, arXiv 2406.14096).
Notably, most engineering improvements in this area come from training strategies rather than network architectures: curriculum learning (RASCL, training on easy instances first and gradually increasing difficulty), end-to-end multi-agent approaches (E2E-MAPPO uses a shared attention policy network to jointly learn job sequencing and machine assignment for flexible job shops, with a complete open-source implementation), and sim-to-real transfer (training in digital-twin simulators, deploying to real MES systems) are the three most frequently cited boosters (E2E-MAPPO, arXiv 2406.14096).
8.2 Adoption Status and a Sober Assessment
Scheduling is one of the areas where the gap between "learned optimization" hype and reality most needs honest assessment. On one hand, learned dispatching policies do outperform any single hand-designed rule (SPT, MWKR, etc.) on specific distributions, and with millisecond-level inference they suit dynamic rescheduling scenarios; on the other hand, multiple surveys and benchmark studies point out that when instance distributions shift or constraint types exceed the training set (new bottleneck machines, batching constraints, setup times), learned policies degrade noticeably, while mature metaheuristics (genetic algorithms, tabu search) and constraint-programming solvers often produce more robust solutions within the same time budget (KBS survey 2025). This is consistent with Chapter 2.3's overall critique of end-to-end NCO and is a scheduling-domain replay of the phenomenon confirmed by RL4CO's unified evaluation.
The pragmatic engineering conclusion: learned scheduling fits two scenarios best—high-frequency dynamic rescheduling (second-level re-planning after rush orders or equipment failures) and very-large-scale instances (thousands of jobs, where metaheuristics' time budget falls short); for medium-to-large-scale scheduling with stable constraints and minute-level solving-time allowances, OR-Tools CP-SAT and professional APS software remain the safer default. Hybrid strategies—learned policies generate initial solutions/dispatch sequences, then local search or CP solvers refine them—have proven in multiple industrial papers to be the route with the best risk–return ratio (Springer survey 2024).
8.3 Frontier Progress (2024–2026): LLMs Enter Shop-Floor Scheduling
Since 2024, scheduling has gained a second technical line beyond "GNN+DRL"—LLMs directly participating in scheduling decisions. Early path-finding work LLMs can Schedule (2024) probed the capability boundary of LLM end-to-end JSP solving; the work that truly demonstrates practical potential is ReflecSched (2025): instead of letting the LLM schedule directly, it has the LLM analyze multi-planning-horizon simulation results driven by heuristic rules, distill natural-language "strategic experience," and use that experience to guide the final decision module—thereby solving dynamic flexible job-shop scheduling (DFJSP) zero-shot, achieving a 71.35% win rate over direct LLM use, reducing RPD by 2.755%, and surpassing every single heuristic rule evaluated (ReflecSched). The paper's diagnosis is equally valuable: baseline LLMs scheduling directly suffer three traps—the "long-context paradox" (key data diluted), underuse of expert heuristics, and myopic decisions—which precisely explains why the layered architecture of "LLM does strategic analysis; rules/algorithms do tactical execution" is currently the most effective form.
Multi-agent architectures are another active thread. The MASC framework (published 2025 in Advanced Engineering Informatics) builds a four-agent collaboration chain—ObsAgent (observation), SchedAgent (scheduling), PlanAgent (planning), CtrlAgent (control)—where SchedAgent, based on an improved ReAct method, dynamically selects scheduling algorithms from an algorithm library according to indicators such as job-time dispersion and available machine counts, and the LLM is fine-tuned with the DialBag dialogue-distillation method to retain domain knowledge; the system has been validated on both simulation and real robotic-arm platforms (MASC). Fusion directions also include: LUCA, which fuses GNNs, LLM semantic understanding, and DRL policy networks for the first carbon-aware FJSP scheduling with dual objectives of carbon emissions and makespan; Gu et al., who use pre-trained LLMs to coordinate multi-agent DRL across production stages of hybrid flow shops; and 2026's DSevolve, which uses LLMs to evolve heuristic portfolios for real-time adaptive DFJSP scheduling (MARL×LLM smart-manufacturing reference-architecture survey, DSevolve). The 2026 smart-manufacturing MARL×LLM reference-architecture survey organizes these works into four LLM roles—state/knowledge augmentation, decision guidance, reflection analysis, and cross-stage coordination—which can serve as a classification framework for scheduling teams' selection decisions.
A sober assessment remains necessary: LLM scheduling today mostly stays at the benchmark and prototype-validation stage; inference latency and hallucination risk make it unsuitable for millisecond online-rescheduling loops; its relationship with §8.1's GNN+DRL route is closer to "complementary layering" than replacement—LLMs handle semantic understanding, anomaly explanation, and policy selection, while numerical policy networks handle high-frequency execution. The pragmatic advice for manufacturers: on top of existing APS/MES, first let LLM agents take on low-risk auxiliary functions such as "schedule explanation, rush-order impact analysis, and rule-parameter recommendation" (corresponding to upstream positions in Chapter 11's decision-chain framework), then evaluate introducing DRL policy networks as data accumulates.
9. Industrial Adoption Panorama: A Global Practice Map
9.1 Overview: From "Point Demonstrations" to "Global Rollout"
Industrial adoption of learning-based optimization and planning has crossed both geographic and industry boundaries. Building on the landmark cases, this chapter systematically maps global practice by industry: North America's tech giants and parcel carriers (Google, Amazon, UPS, Tesla), Europe's power grids and transport (France's RTE, the UK's Ocado), Japan and Korea's process industries and robotics (Yokogawa, ENEOS, Panasonic-owned Blue Yonder), Middle Eastern energy facilities (Saudi Aramco's Fadhili gas plant), and China's mobility, delivery, and urban governance (DiDi, Alibaba City Brain, Huawei). Figure 3b summarizes early landmark gains; Figure 4 further presents the expanded global panorama of quantified gains—spanning relative improvements on the order of percentage points to absolute economic gains on the order of hundreds of millions of dollars.
Two methodological caveats apply when reading this chapter's numbers. First, evidence grades differ: DeepMind cooling and SayCan success rates are backed by peer-reviewed papers, UPS ORION's benefits are documented in INFORMS literature, while figures from vendor press releases (such as EDA tools' PPA improvements) are self-reported and should be discounted accordingly; citations in this chapter note source nature wherever possible. Second, cross-case horizontal patterns matter more than any single number: virtually every successful scaled deployment adopts a conservative hybrid architecture of "learned model + classical solver/safety layer/rule constraints," and not a single case lets a learned component control a production system without constraints or fallbacks—this architectural fingerprint is this chapter's most important conclusion and mutually corroborates the technical analyses of Chapters 3 and 7.
Figure 4. Quantified gains from representative global industrial deployments. (a) Relative improvements (ranges plotted at midpoints, e.g., Yokogawa × Aramco at the midpoint of 10–15%); (b) absolute economic gains (different bases: UPS is annual savings, Tesla Autobidder is cumulative trading profit, WFP is cumulative program savings). Data sources are cited throughout this chapter
9.2 Semiconductors and EDA: The Most Commercialized Battleground for Learning Optimization
Electronic design automation (EDA) is—without rival—the most commercialized domain of learning-based optimization. Synopsys's DSO.ai, released in 2020, was the industry's first autonomous chip-design AI application, using reinforcement learning to automatically explore process-parameter combinations in the vast design spaces of Fusion Compiler and IC Compiler II; per company disclosures, users have achieved double-digit-percentage PPA (power, performance, area) improvements on real production designs with substantially shortened design cycles, and industry media report cumulative production tape-outs in the hundreds (ad-hoc-news, bitsilica technical overview). Competitor Cadence Cerebrus's full-flow RL engine has likewise accumulated a dense set of production cases: Samsung Semiconductor India Research (SSIR) achieved 8–11% PPA improvement on SoC subsystems, and Samsung's Austin R&D Center (SARC) saw a 4× productivity gain (Cadence community blog); Phison Electronics automatically reduced power by 35% and shrank area by 3% on a 12nm NAND controller within one week (design-reuse); Himax reported up to 30× single-design productivity improvement and 70% fewer DRC violations (Cadence community blog); and after its floor-plan optimization shrank chip area by 5% and cut power by over 6%, MediaTek moved Cerebrus into full production flows (iconnect007).
Why EDA became the perfect battleground for learning optimization is worth borrowing by every industry: the evaluator is programmatic and authoritative (timing/power analysis from sign-off tools is ground truth, requiring no human labeling); trial-and-error costs nothing (a failed exploration is just one simulation, and rollback is free); data generates itself (RL agents explore the design space and produce their own training data, without relying on historical accumulation). Google's AlphaChip (used in mass production of multiple TPU generations and open-sourced) and NVIDIA ChipNeMo (a domain LLM generating Verilog and EDA scripts) represent the two complementary routes of RL placement and LLM-assisted design respectively (internet-pros industry overview). Architecturally they share the same fingerprint: the learning engine handles large-scale search and proposals; deterministic sign-off tools handle final verification—exactly the hybrid philosophy of Chapter 3.
9.3 Energy and Power: From Data Centers and Power Markets to Oil & Gas Plants
The energy sector contributes both the earliest and the latest milestones of learning optimization. The earliest is the DeepMind data-center cooling case detailed earlier (2016); the newest heavyweight player is Tesla Autobidder: its machine-learning engine Opticaster predicts electricity prices, load, and generation output, and automatically executes power-market bidding and battery charge/discharge scheduling; per Tesla job postings, the platform manages over 7 GWh of storage assets worldwide and has generated over $420 million in cumulative trading profit (Tesla job posting); benchmark projects such as Australia's Hornsdale Power Reserve report double-digit ROI improvements (LinkedIn industry analysis). On the grid side, French transmission operator RTE's L2RPN (Learning to Run a Power Network) competition series (running since 2019) and its open-source simulator Grid2Op turned grid topology control into an "ImageNet moment" for RL—the standardized benchmark has drawn the global research community into competing to improve line-overload remediation agents, with 2025 frontier work covering multi-objective RL, multi-agent zonal coordination, and graph-augmented agents (howtostoreelectricity).
Autonomous control in process industries is the most underrated breakthrough of 2022–2025. The FKDPP reinforcement-learning algorithm, co-developed by Yokogawa and the Nara Institute of Science and Technology, achieved 35 consecutive days of AI-autonomous operation on a butadiene distillation column at ENEOS's Yokkaichi plant in 2022—stably producing on-spec product, eliminating off-spec batches, and reducing steam consumption by 40%—before formally transitioning to normal production operation in 2023, which the vendor claims as the world's first AI-autonomous control of a chemical plant (ARC Advisory case record). In October 2025, Yokogawa and Saudi Aramco commissioned multiple coordinated FKDPP autonomous-control agents at the Fadhili gas plant, directly controlling the acid gas removal (AGR) unit; preliminary results show 10–15% lower amine and steam consumption, about 5% lower electricity use, and significantly reduced manual intervention; deployment strictly followed a three-stage path of "simulator training → reliability verification → integration with the safety functions of the CENTUM VP control system" (Yokogawa official press release, Business Wire). US-based Imubit and others have also launched RL closed-loop optimization products for process industries (survey of industrial NN-control deployments). These cases are direct realizations of §7.1's "learned policy + safety layer" architecture in process industries; their staged deployment paths are elaborated in §11.3.
9.4 Logistics, Parcel, and Warehouse Robotics: The Largest-Scale Online Optimization Systems
The parcel-transport benchmark is UPS ORION (On-Road Integrated Optimization and Navigation): deployed starting 2012 and fully completed in 2022, the system generates optimized routes daily for more than 55,000 US drivers, eliminating about 100 million miles of driving per year, saving 10 million gallons of fuel, cutting roughly 100,000 tonnes of CO₂ emissions, and delivering estimated annual economic benefits of $300–400 million (arXiv 2604.25847 citing INFORMS literature, Articsledge case roundup); the 2020 Dynamic ORION upgrade added real-time intra-shift rerouting, saving another 2–4 miles per driver per day on top of existing gains (NextBillion.ai technical analysis). ORION's technical essence is a textbook hybrid of "OR engine + ML prediction layer"—deterministic optimization handles hard constraints such as time windows and working hours, while ML supplies predictive inputs for traffic, weather, and delivery patterns. FedEx (SenseAware cutting spoilage of temperature-controlled goods by up to 40%; AI rerouting reducing delays by 25% on average) and DHL (AI delay prediction cutting freight delays by up to 30%) demonstrate the same paradigm spreading across the industry (AI Business Weekly, Apptunix). The public sector benefits too: the UN World Food Programme (WFP) used analytics and optimization to restructure its humanitarian supply chain during COVID-19, saving over $150 million while serving about 100 million people across 80+ countries (arXiv 2604.25847 citing Peters et al. 2022).
In warehouse robotics, Amazon deployed its 1-millionth warehouse robot in 2025 and released DeepFleet—the first foundation model for multi-robot coordination: using a Transformer architecture to predict interactions and congestion evolution among robots on fulfillment-center floors, it guides task assignment and path rerouting, improving robot-fleet travel efficiency by 10% (Amazon Science). This is the first time the foundation-model paradigm (Chapter 13's FM4CO trend) has entered ultra-large-scale industrial logistics. The UK's Ocado uses swarm intelligence to coordinate thousands of robots for high-speed order fulfillment in its automated warehouses, embedding machine learning directly into robots' self-diagnosis and anomaly recovery (Encord, Cloudfresh). A capital-market signal is also worth noting: InstaDeep, which specializes in RL decision optimization (products covering container-loading optimization DeepPack, railway scheduling, PCB routing, and more, with customers including Deutsche Bahn), was acquired by BioNTech in 2023 for €636 million—evidence that "RL solving industrial combinatorial optimization" has itself become a validated business model (StartupIntros).
9.5 Urban Traffic Signals and Mobility Platforms
Urban traffic-signal control is the most successful domain of public-sector learning-optimization adoption. CMU's Surtrac (Scalable Urban Traffic Control) was piloted in 2012 at nine intersections in Pittsburgh's East Liberty district: each intersection runs a local "schedule-driven" real-time optimization algorithm, recomputing signal timing at 1Hz and exchanging traffic-flow predictions with neighboring intersections; measured results included 25% lower travel times, over 40% lower waiting times, 31% fewer stops, and about 21% lower emissions; the system later expanded to more than 50 intersections and was commercialized to multiple US cities including Atlanta via Rapid Flow Technologies (later acquired by Miovision) (CMU technical paper, ICAPS application report). Google Green Light takes an asset-light route: without replacing any hardware, it uses Maps traffic data and ML models to recommend signal-timing adjustments to city traffic engineers, achieving 10–20% fewer stops and about 10% lower intersection emissions in cities including Jakarta, Rio de Janeiro, and Seattle (aibuzz industry overview).
China's practice is equally substantial in scale: Alibaba City Brain achieved roughly 15% lower travel times in central Hangzhou and up to 50% shorter passage times for emergency vehicles (AICerts, citing CGTN coverage); DiDi's and Meituan's dispatch and scheduling systems were detailed earlier. The success factors of traffic-signal control carry general lessons: short evaluation loops (effects observable same-day), safety constraints naturally embedded in engineering boundaries (timing plans have physical and regulatory bounds), and benefits accruing simultaneously on efficiency and emissions dimensions, easing public support. Together with data-center cooling, it proves a siting principle—the best entry points for learning optimization are closed-loop physical systems where "constraints are naturally clear, gains are immediately visible, and trial-and-error is cheap."
9.6 Financial Trade Execution: Reinforcement Learning's Invisible Large-Scale Deployment
Finance is a domain where reinforcement learning has quietly achieved large-scale production deployment. JPMorgan's LOXM has used deep reinforcement learning to execute large equity orders since 2017: trained on billions of real and simulated trades, the system learns how to choose the timing, size, and venue of order slicing in fragmented markets to minimize market impact; in pilots on the European equities business it outperformed both humans and traditional execution algorithms, and was subsequently rolled out to global equities (Endroid relaying Financial Times coverage, Appinventiv industry analysis). Especially noteworthy is its governance architecture: LOXM's learning and trading behavior is strictly bounded within the firm's electronic-trading risk framework, supervised by an internal control group and validated by regulators—a financial-sector version of §7.1's "safety filter" idea.
Among peers, BlackRock's Aladdin platform embeds production-grade AI agents into risk-management and portfolio-decision processes covering trillions of dollars in assets, and Citadel Securities has supported its market-making strategies with machine learning for over two decades (Appinventiv). One principle from finance holds for every industry: "narrow problems first"—RL proved production value on trade execution (a narrow problem with a clear objective—minimizing impact cost—and immediate feedback), while open problems such as price prediction still have no reproducible success; when choosing an entry point for learning optimization, a problem's "evaluability" is more decisive than its "importance" (TradeAlgo technical analysis).
9.7 Commercial Platforms and Solver Vendors Go All-In on Learning
Beyond NVIDIA cuOpt and Huawei OptVerse (detailed earlier), the traditional supply-chain planning software (APS) industry is also going all-in on AI. Blue Yonder (owned by Panasonic, a global APS leader) integrates ML demand sensing, multi-echelon inventory optimization, and constraint-aware planning into a unified platform, officially claiming up to 74% forecast-accuracy improvement, 47% planning-efficiency gains, and up to 24% lower inventory costs (Blue Yonder website); third-party firm Nucleus Research's customer interviews show post-deployment delivery rates of 95–98%, with one global semiconductor manufacturer raising priority-customer fulfillment from 45% to 88% (Nucleus Research). In 2026 Blue Yonder went further, partnering with NVIDIA to build a "model training factory" using the NeMo toolchain to mass-produce specialized AI agents that autonomously execute supply-chain processes (Read Magazine).
At the lowest solver layer, learning's penetration is more invisible but equally thorough: Gurobi's built-in automatic parameter-tuning tool searches for better parameter combinations over a corpus of thousands of customer models, and its default parameters are themselves the product of large-scale experimental tuning (Gurobi official documentation); Gurobi also publicly recommends machine learning for automatic selection of model structures and solving strategies. This corroborates Chapter 3's core thesis: the first place learning components get commercialized is the "invisible interior" of solvers—users may not even realize they are using learning optimization. From DeepMind cooling's bespoke 2016 project to 2025's platformized products (cuOpt, Cerebrus, Blue Yonder), learning optimization is completing its commoditization along the maturity curve of "custom project → replicable product → platform ecosystem."
9.8 Consolidated Comparison of Global Deployments
The table below consolidates the global deployments covered in this chapter and earlier, organized by "region × industry × paradigm," to facilitate horizontal comparison of each paradigm's maturity and evidence strength:
| Case | Region | Industry | Paradigm | Quantified gains | Evidence source |
|---|---|---|---|---|---|
| DeepMind cooling optimization | US / global | Data centers | Learning-based control | Cooling energy −40%, PUE −15% | DeepMind blog |
| AlphaChip | US | Chip design | End-to-end RL | Multiple TPU generations in production; placement weeks → hours | DeepMind |
| AlphaDev | US | Foundational software | RL algorithm discovery | Sorting +70% (small), hashing +30%; merged into LLVM libc++ | Nature/PMC |
| Synopsys DSO.ai | US / global | EDA | RL design-space search | Double-digit PPA gains on production designs (vendor-disclosed) | ad-hoc-news |
| Cadence Cerebrus × Samsung SSIR/SARC | Korea / India / US | EDA | RL full-flow optimization | PPA +8–11%; productivity 4× | Cadence blog |
| Cerebrus × Phison | Taiwan, China | EDA | RL full-flow optimization | Power −35%, area −3% (one week) | design-reuse |
| Cerebrus × MediaTek | Taiwan, China | EDA | RL floor-planning | Area −5%, power −6%; full production adoption | iconnect007 |
| Tesla Autobidder | US / Australia / Europe | Energy trading | Predict + optimize | Manages 7+ GWh storage; $420M cumulative trading profit | Tesla job posting |
| Yokogawa × ENEOS column | Japan | Chemicals | FKDPP RL control | Steam −40%; 35-day autonomy then normal operation | ARC/CB Insights |
| Yokogawa × Saudi Aramco Fadhili | Saudi Arabia | Natural gas | FKDPP multi-agent control | Amine/steam −10–15%, electricity −5% | Yokogawa press release |
| RTE L2RPN / Grid2Op | France | Power grids | RL benchmark ecosystem | Became the global standard competition & simulator for grid RL | howtostoreelectricity |
| UPS ORION | US | Parcel | OR engine + ML prediction | 100M miles, $300–400M, 100k tonnes CO₂ saved annually | arXiv 2604.25847 |
| Amazon DeepFleet | US / global | Warehouse robotics | Multi-robot foundation model | Fleet travel efficiency +10%; million-robot scale | Amazon Science |
| Ocado smart warehouses | UK | Warehouse robotics | Swarm intelligence + ML | Thousands of robots in coordinated fulfillment | Encord |
| InstaDeep | UK / Tunisia | Logistics / rail | RL combinatorial optimization | Acquired by BioNTech for €636M | StartupIntros |
| UN WFP supply chain | Global, 80+ countries | Humanitarian logistics | Analytics + optimization | $150M+ cumulative savings | arXiv 2604.25847 |
| Surtrac (Pittsburgh) | US | Traffic signals | Distributed adaptive optimization | Travel −25%, waiting −40%, emissions −21% | CMU paper |
| Google Green Light | Multiple cities worldwide | Traffic signals | ML timing recommendations | Stops −10–20%, emissions −10% | aibuzz |
| Alibaba City Brain | China | Urban transport | Learning + optimization | Central Hangzhou travel −15%; emergency vehicles −50% | AICerts |
| DiDi smart dispatch | China | Mobility platform | RL + combinatorial optimization | 20+ cities; GMV +0.5%–2% | DiDi technical sharing |
| JPMorgan LOXM | US / Europe | Financial execution | Deep reinforcement learning | Outperformed humans & traditional execution algorithms (pilot) | Endroid/FT |
| Blue Yonder platform | Japan / US | Supply-chain APS | ML demand sensing + optimization | Forecast accuracy +74%; delivery rate 95–98% | Blue Yonder, Nucleus |
| NVIDIA cuOpt | US | Solver platform | GPU heuristics + LLM skills | Lyric case 240×; COIN-OR Cup 2025 | COIN-OR, Lyric |
| Huawei OptVerse | China | Commercial solver | Learning-augmented components | Ports, manufacturing, supply chain scenarios | Huawei Cloud |
Surveying this global map yields four cross-case regularities. First, gain magnitude correlates positively with industry digital maturity: "fully digital closed-loop" industries such as semiconductor EDA and data centers see the largest gains (double-digit percentages), because evaluation and rollback both happen inside software; physical-world industries (transport, logistics) cluster in the 10–25% range but with enormous absolute amounts. Second, the hybrid architecture is the only repeatedly validated form: from ORION's "OR engine + ML prediction" to Yokogawa's "RL agent + DCS safety system" to LOXM's "RL policy + risk framework," no scaled deployment uses bare end-to-end learning. Third, deployment cycles are measured in years: ORION took 11 years (a J-curve), and ENEOS took a year from 35-day pilot to normal operation—building organizational trust takes longer than training algorithms. Fourth, platformization is compressing costs for latecomers: cuOpt, Cerebrus, and Blue Yonder let 2026 adopters avoid repeating the self-development path of 2016 pioneers.
10. Open-Source Toolchain Panorama and Selection
10.1 A Tool Map by Paradigm
The first step of engineering adoption is choosing the right tools. The table below summarizes current mainstream open-source tools and libraries by paradigm, covering positioning, underlying dependencies, and applicable stages:
| Paradigm | Tool / library | Positioning and characteristics | Underlying dependencies | Source |
|---|---|---|---|---|
| End-to-end NCO | RL4CO | Unified RL framework for neural CO; 20+ models, 20+ environments; standardized evaluation | PyTorch Lightning | GitHub, KDD 2025 |
| End-to-end NCO | Unify ML4TSP / ML4CO-Bench-101 | Unified implementations of TSP methods and a large-scale benchmark suite | PyTorch | awesome-ml4co |
| Learning-augmented solvers | Ecole | "In-solver RL environment" library deeply integrated with SCIP; standard interfaces for learnable components such as branching/cut selection | SCIP, Python | Ecole docs |
| Learning-augmented solvers | Huawei OptVerse, NVIDIA cuOpt | Learning components / GPU acceleration in commercial solvers | Commercial / cloud services | Huawei Cloud, NVIDIA |
| L2O | JMLR 2022 benchmark, learn2optimize | Standardized L2O benchmark and reference implementations | JAX/PyTorch | JMLR 2022 |
| Decision-focused learning | PyEPO | End-to-end predict-then-optimize library; SPO+ / perturbation / contrastive losses; autograd | PyTorch + Gurobi | PyEPO |
| LLM optimization | OpenEvolve | Open-source reproduction of AlphaEvolve; LLM code-evolution framework | Any LLM API | awesome-llm-evolution |
| LLM optimization | OptiMUS / ORLM | Natural language → MILP modeling and solving | GPT-4 / fine-tuned open models | ICML 2024, arXiv |
| Robot planning | Motion Planning Diffusion, MπNets, etc. | Open-source diffusion / neural motion-planning implementations | PyTorch + MuJoCo/simulators | TAMP survey |
| Classical baselines | OR-Tools (CP-SAT), SCIP, LKH-3, HGS | The mandatory control group for every learning method | C++/Python | OR-Tools |
(Compiled from awesome-ml4co, awesome-fm4co, and each tool's official documentation)
10.2 Key Dimensions of Selection Decisions
Tool selection is essentially a trade-off across five dimensions. Problem scale and latency budget determine architecture: millisecond inference and very-large-scale instances favor end-to-end NCO or learned dispatching rules; minute-level budgets at medium scale should default to classical solvers or learning-augmented solvers. Data availability determines paradigm feasibility: DFL needs historical (features, realizations) pairs; NCO needs large volumes of in-distribution instances for training; LLM modeling has an almost-zero data threshold. Guarantee requirements determine risk structure: safety-critical scenarios must keep classical solvers or safety filters as the backstop layer, with learned components providing only acceleration and suggestions. Team capability determines build-vs-buy: organizations without a dedicated optimization team should realistically start with cuOpt/OptVerse-class platforms and OR-Tools; only teams with research capability should invest in RL4CO/Ecole self-development. Maintenance cost is often overlooked: learned models need retraining pipelines as business distributions drift, while pure-solver solutions have near-zero operations overhead—over a system lifecycle of three-plus years, this difference often exceeds initial development cost.
One practical recommendation runs through this chapter: whichever learning route you choose, first establish a classical baseline with OR-Tools CP-SAT or SCIP. This is both the mandatory exam question for any subsequent learning method (§2.3's critique is essentially "missing rigorous baseline comparisons") and the production fallback if the learning approach fails. RL4CO's unified evaluation shook the community precisely because it revealed that many papers' SOTA claims do not hold under fair baselines (RL4CO, KDD 2025).
11. Engineering Adoption Guide
11.1 A Paradigm-Selection Decision Framework
Synthesizing the evidence across this report yields a paradigm-selection flow for engineering decision-makers. Question 1: Does the optimization problem have a mature mathematical-programming formulation and an acceptable solving time? If yes, default to the learning-augmented solver route (Chapter 3) or pure solvers, using learned components only for initial solutions, branching, cut selection, and parameter tuning—the lowest-risk, most certain-payoff path. Question 2: Are there massive volumes of in-distribution instances with extreme latency requirements? If yes (e.g., tens of thousands of routing or scheduling decisions daily), end-to-end NCO or learned dispatching rules are worth the investment, but must be paired with a classical refinement layer. Question 3: Is there a known cost asymmetry between prediction and decision? If yes, DFL (Chapter 5) is the most targeted and theoretically complete choice, and PyEPO can complete a proof of concept within a week. Question 4: Is the bottleneck modeling labor rather than solving? If yes, adopt LLM modeling solutions directly (OptiMUS/ORLM/cuOpt agent skills)—let the LLM do translation and the solver do computation. Question 5: Do you have a programmatically evaluable objective function and an ambition to explore "uncharted" algorithms? If yes, FunSearch/OpenEvolve-style evolutionary frameworks are currently the only validated general method that can produce heuristics surpassing human designs.
The unifying logic behind this framework is one this report has emphasized repeatedly: the value density of a learned component is inversely proportional to its position in the decision chain—the closer to final action output, the higher the risk and verification cost; the further upstream (prediction, modeling, initial solutions, parameter suggestions), the lower the failure cost and the smoother the integration with existing systems. Every successful industrial case (Chapter 9) obeys this law without exception.
11.2 Common Pitfalls and a Deployment Checklist
Six high-frequency pitfalls can be distilled from the literature and industrial cases. First, train/production distribution drift: scheduling and routing models are extremely sensitive to distribution shift; retraining triggers and offline simulation regression tests are mandatory. Second, missing or unfair baselines: many projects' "improvements" are relative to weak baselines (greedy rules) and may vanish against CP-SAT/metaheuristics—lock in strong baselines at project kickoff. Third, ignoring infeasibility: end-to-end methods may output hard-constraint-violating solutions; a repair or constraint-projection layer is mandatory. Fourth, reward hacking: RL optimizing proxy metrics (e.g., makespan proxies) can damage true business metrics; practices such as DiDi's use online A/B business metrics as the final arbiter. Fifth, the sim-to-real gap: after training in simulation, real-system latency, noise, and exceptional events significantly erode learned scheduling and control policies; domain randomization and online adaptation are standard mitigations. Sixth, LLM hallucinations entering the decision chain: LLM-generated model code or heuristics must pass automated unit tests and feasibility checks (OptiMUS's debugging iterations and FunSearch's evaluator filtering are designed precisely for this); no unverified LLM output should ever reach production execution.
Correspondingly, a minimum viable production-deployment checklist includes: a classical baseline solver and its service encapsulation; input/output schemas and a constraint-validation layer for learned components; offline simulation replay and regression benchmark suites; canary releases with automatic rollback (backstopped by classical baseline outputs); decision audit logs (especially for LLM-involved steps); and distribution-drift monitoring with a retraining pipeline. The essence of this checklist is designing the architecture to treat learned components as "replaceable performance enhancers" rather than "the heart of the system"—the heart is always the verifiable constraint-and-rule layer.
11.3 From Shadow Mode to Closed-Loop Autonomy: A Staged Deployment Path
Synthesizing deployment records from Yokogawa, DeepMind, UPS, and other global cases yields a repeatedly validated four-stage deployment path, applicable to almost any safety-critical or high-value learning-optimization system. Stage 1: simulator training and offline replay—build a digital twin of the physical system or business process, train the learned policy inside it, and validate with historical-data replay; Yokogawa built plant-level simulators for both the ENEOS and Aramco projects and touched real equipment only after simulation validation passed (Yokogawa press release). Stage 2: shadow mode—the learning system runs in parallel with the existing system, recording only "what would happen if its suggestions were followed" without actually executing, exposing distribution shift and long-tail failures. Stage 3: human-in-the-loop—the AI outputs suggestions and operators review them before manual execution; the ENEOS project stayed in this stage for a considerable time, with operators reviewing each AI-suggested valve setting before entering it into the DCS—"this extended review period reduced risk and helped operators understand and trust the model" (Control Global coverage). Stage 4: bounded closed-loop autonomy—the AI executes directly but is wrapped layer upon layer by rule-based bounds, existing safety instrumented systems, and one-click fallback mechanisms; the ENEOS project's principle was summarized by its engineers as "the AI model is never the only safety barrier" (Control Global).
The most underestimated aspect of this path is the organizational and change-management dimension. UPS ORION's benefit curve follows a classic J shape: early deployment in 2013–2014 produced almost no gains because drivers distrusted routes that violated their years of experience; only after the ML models absorbed driver feedback and training programs caught up did benefits accelerate—the full journey took 11 years (LinkedIn ROI analysis). DeepMind's cooling system likewise ran in "recommendation mode" for months, with on-site engineers reviewing each suggestion, before gradually transitioning to autonomous control. The pragmatic lessons for engineering teams: budget more time for Stage 3 (human-in-the-loop) than for algorithm development in project plans; design operator feedback as part of the training data rather than as noise outside the system; and set explicit "promotion criteria" for each stage (e.g., shadow-mode regret below threshold for 30 consecutive days before advancing), making the trust-building process itself engineered and measurable.
12. Challenges, Controversies, and Open Problems
12.1 Fundamental Questions on Generalization and Scaling
The sharpest challenge facing end-to-end NCO comes from critical research in the ACM computing-surveys lineage in 2024: learned constructive/improvement solvers degrade far more on out-of-distribution instances than advertised, and generally lag specialized classical solvers such as LKH-3, HGS, and Concorde in solution quality, holding an advantage only in inference latency (Applicability critique, ACM 2024). Work such as RsGCN further points out that many NCO papers' "generalization" conclusions stem from the sampling artifact of training and test sets drawn from the same distribution (RsGCN). The controversy has not subsided in 2025–2026 but has instead converted into a stricter evaluation culture: ML4CO-Bench-101, RL4CO's unified protocol, and COExpander's cross-scale generalization tests are all products of the community's self-correction (RL4CO).
Deeper open problems are theoretical: why can deep models approach or even locally surpass heuristics polished for decades on some combinatorial problems—what is the essence of their inductive bias; after learned components are embedded in solvers, how can classical optimality/convergence guarantees be formally preserved or their degradation quantified (the "guarantee-free acceleration" of learned MIP branching is currently empirical); and how should reproducibility and novelty criteria be established for the outputs of LLM-evolved algorithms (AlphaEvolve-type)—when "algorithm invention" itself is automated, peer review and intellectual-property frameworks face new questions (awesome-llm-evolution).
12.2 Data, Evaluation, and Trustworthiness
Data and evaluation infrastructure are bottlenecks constraining the entire field. Combinatorial optimization lacks ImageNet-style public datasets and accepted splits, and papers' self-built instances make horizontal comparison difficult; scheduling simulators are mutually incompatible; in L2O, despite the JMLR 2022 benchmarking effort, systematic characterization of "how learned optimizers fail on unseen task families" is still missing (JMLR 2022). On trustworthiness, safety-critical scenarios demand not average performance but worst-case guarantees—precisely why industry insists on architectures such as learning-augmented MPC's safety filters and solvers' exact backstops (Reiter et al. 2025).
Interpretability likewise remains unresolved: what structural features do GNN branching policies actually learn; why do diffusion planners' generated trajectories avoid certain configurations; why are LLM-evolved heuristics effective—answers to these questions currently remain mostly case-by-case analyses. For engineering teams, the practical implication of this status quo: learned components should be designed as black boxes that are "performance-monitorable, behavior-auditable, and failure-isolatable," with architectural redundancy reserved for their uninterpretability—rather than waiting for theory to mature.
13. Frontier Trends (2025–2026) and Outlook
13.1 The Rise of Foundation Models for Combinatorial Optimization (FM4CO)
The clearest academic trend since 2025 is foundation models for combinatorial optimization (FM4CO): emulating language models' pretrain–finetune paradigm by pre-training unified models on large-scale, multi-type CO instances and then adapting them to specific problems. The awesome-fm4co list shows the direction already spans three routes: unified solvers across problem types, LLM end-to-end CO solving (NeurIPS 2025), and MILP foundation models (the MILP-Evolve lineage) (awesome-fm4co). Its motivation directly answers Chapter 12's generalization critique: if a single model is pre-trained on sufficiently diverse instance distributions, out-of-distribution degradation should in theory be significantly mitigated. If this direction delivers, it will reshape the technical landscape of Chapters 2–3—the end-to-end vs. hybrid divide may be replaced by a new architecture of "pre-trained backbone + solver decoding/refinement."
In parallel, evaluation and data infrastructure is maturing: large-scale benchmarks such as ML4CO-Bench-101, RL4CO's standard protocol, and new benchmarks targeting "algorithm-engineering capability"—HeuriGym (ICLR 2026) and ALE-Bench (NeurIPS 2025)—are pushing the field from "leaderboard-point racing" toward "capability characterization" (awesome-fm4co). The signal for engineering teams: when selecting tools, prefer methods and tools with public, reproducible results on unified benchmarks over claims in individual papers.
13.2 Deep Coupling of LLMs and Solvers
The second trend is LLMs' continued convergence toward—and consolidation in—the "semantic layer" of the optimization stack: four positions now each have mature representatives—modeling (OptiMUS/ORLM), explanation (OptiGuide/OptiChat), diagnosis (infeasibility analysis), and heuristic invention (FunSearch/AlphaEvolve/OpenEvolve), while the numerical-solving layer firmly remains with classical algorithms. NVIDIA's agent skills for cuOpt and Huawei OptVerse's integrated learning components show that commercial platforms have adopted "LLM frontend + strong solver backend" as the standard product form (NVIDIA cuOpt). This division of labor will not change in the short term: numerical solving's requirements for precision, worst-case complexity, and certificates (optimality proofs, infeasibility proofs) are fundamentally incompatible with LLMs' probabilistic generation mechanism, whereas semantic translation, result explanation, and code generation sit squarely in the sweet spot of the LLM capability curve.
The variable worth watching is the migration of the test-time-compute paradigm into optimization: MCTS-guided LLM reasoning search and long-chain-of-thought models' progress on mathematical-programming modeling may gradually raise the scale ceiling of problems LLMs can directly handle over the next two to three years (tree-search survey). Supporting evaluation infrastructure is also falling into place—OPT-BENCH measures agents' optimization ability in large search spaces, ALE-Bench examines long-horizon algorithm engineering, and HeuriGym specifically evaluates LLMs' level at designing combinatorial-optimization heuristics (awesome-fm4co). For engineering teams, the pragmatic approach is to design system interfaces now around the architecture "LLMs own semantics, solvers own numerics," while abstracting the solving layer as a replaceable module—so that however the LLM capability boundary moves in the future, the system can absorb new capabilities with minimal change.
13.3 A Converging Unified Picture
Looking across 2026, the six paradigms are converging into one unified engineering picture: classical solvers and simulators provide the skeleton of correctness and guarantees; learned components supply acceleration, generalization, and semantic interfaces at every seam of that skeleton. End-to-end methods hold their niche in specific high-throughput scenarios; hybrid methods become the default architecture; LLMs take over human-machine interaction and heuristic design; and safety filters and audit layers guard the last mile of all learned outputs. For engineers and researchers entering this field, this report's final advice condenses to four points: start from strong classical baselines, and never evaluate a learning method without one; place learned components upstream in the decision chain and manage risk with architecture rather than hope; prefer toolchains endorsed by unified benchmarks (RL4CO, Ecole, PyEPO, OpenEvolve, OR-Tools/cuOpt); and track, at quarterly cadence, the two variables most likely to redraw the landscape—FM4CO and LLM-as-solver.
Disclaimer: This report is a technical research survey. All cited data comes from public literature and official releases, and is provided for learning and technology-selection reference only; it does not constitute any commercial decision-making, investment, or legal advice. When deploying to specific production systems, please conduct independent verification and evaluation against your organization's actual business scenarios.
Top comments (0)