DEV Community: Johnny is piggy

Learning-Based Optimization and Planning Algorithms: A Comprehensive Technical Survey and Engineering Adoption Guide

Johnny is piggy — Sat, 19 Sep 2026 13:10:35 +0000

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.

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 $F$ , learn a parameterized update map $x_{t + 1} = x_{t} - g_{θ} (I_{t})$ (where $I_{t}$ 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, $x^{⋆} (c) - x^{⋆} (2 c^- c)$ (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.

GPU-Accelerated Optimization Algorithms: A Complete Survey and Selection Guide (2026)

Johnny is piggy — Fri, 18 Sep 2026 18:28:29 +0000

Executive Summary

GPU-accelerated optimization algorithms have expanded far beyond their traditional home of deep learning training into virtually every branch of optimization: mathematical programming, combinatorial optimization, evolutionary computation, Bayesian optimization, robot motion planning, and even quantum-inspired annealing. The underlying logic is consistent everywhere: restructure the most time-consuming operators of an iterative optimizer (sparse matrix–vector products, batched candidate evaluation, matrix factorization, Monte Carlo sampling) into a massively parallel, memory-bandwidth-friendly form, compressing "overnight" problems into minutes or even milliseconds. This report systematically surveys the mainstream GPU-accelerated optimization algorithms and representative tools across five domains, presenting publicly reported performance figures (e.g., NVIDIA cuOpt delivering up to 5,000× speedup on a large multicommodity-flow LP instance; cuLoRADS achieving 100×+ over CPU solvers on hundred-million-scale SDPs; cuRobo motion planning at 60× over CPU planners), and concludes with a scenario-by-scenario engineering selection table. It must be stressed that reported speedups come from very different measurement setups, and GPUs do not win on every problem — small instances, high-accuracy requirements, and branch-and-bound-style search remain CPU territory. Selection should always be validated by benchmarking on your own problem sizes and accuracy needs.

1. Overview: The Landscape of GPU-Accelerated Optimization

"GPU-accelerated optimization algorithms" form a large family spanning multiple disciplines. Broadly speaking, they follow two lines of thinking. The first is algorithms that are naturally parallel: in evolutionary algorithms every individual in the population can be evaluated independently; in Bayesian optimization thousands of candidate points can be scored in a batch; in motion planning hundreds of trajectories can be rolled out simultaneously. Such algorithms routinely gain one to several orders of magnitude on GPUs. The second line is algorithms redesigned for GPUs: the most typical example is the shift in linear programming from the simplex method and interior-point methods (which depend on hard-to-parallelize sparse matrix factorization) toward the first-order PDHG/PDLP family (whose iteration core is just sparse matrix–vector products), which finally unlocks the bandwidth advantage of GPUs (NVIDIA). Representatives of the first line include EvoX, evosax, BoTorch, and cuRobo; representatives of the second include cuPDLP, cuOpt, ClarabelGPU, and cuLoRADS.

From an engineering perspective, the first step in selection is identifying which class of problem you face. For continuous differentiable problems (deep learning training, nonlinear least squares), look first at optimizers inside deep learning frameworks and differentiable optimization libraries. For constrained continuous problems of enormous scale (LP/QP/SDP), look at GPU first-order solvers. For discrete/combinatorial problems (MILP, VRP, scheduling), GPUs currently play the role of heuristics and relaxation solvers, working best in hybrid combination with CPU branch-and-bound. For black-box, gradient-free problems (hyperparameters, structural design, expensive-simulation optimization), look at GPU implementations of evolutionary computation and Bayesian optimization. Each of the following sections expands on these in turn.

2. Mathematical Programming and Operations Research Solvers

Mathematical programming is the domain where GPU-ification has advanced fastest over the past two years and had the greatest industrial impact. The turning point came from Google's PDLP, proposed in 2021: LP is reformulated as a minimax saddle-point problem and solved with the primal-dual hybrid gradient method (PDHG) augmented by restarts, diagonal preconditioning, and adaptive step sizes, so the iteration core reduces to sparse matrix–vector products that are naturally suited to GPUs and distributed hardware (Google Research). The work received the 2024 Beale–Orchard-Hays Prize, and its C++ implementation is open-sourced as part of OR-Tools (Kavour).

2.1 Linear Programming (LP): The PDHG/PDLP Family and cuOpt

The academic pathbreaker for GPU-ified LP is cuPDLP.jl (a Julia implementation) from Haihao Lu's group at MIT: on the LP relaxations of MIPLIB 2017, at medium accuracy (1e-4) it solves more instances than all CPU versions of PDLP and is comparable to Gurobi; on large instances with over ten million nonzeros it is 3.7× faster than Gurobi's best barrier method, and up to 20× faster than its own Julia CPU version (arXiv:2311.12180). It was followed by a C implementation, cuPDLP-C (roughly another 50% faster), and by cuPDLP+, which adopts restarted Halpern PDHG (rHPDHG) with reflection updates and PID-controlled primal-weight updates — a further 2–4× speedup over cuPDLP on MIPLIB LP relaxations (2.9× at high accuracy with presolve, 4.63× on hard instances) (arXiv:2507.14051). This line of work directly influenced the design of commercial and open-source solvers including Gurobi, COPT, FICO Xpress, and NVIDIA cuOpt (EmergentMind).

The industry benchmark is NVIDIA cuOpt: open sourcing was announced in March 2025 in collaboration with the COIN-OR Foundation, and from June 2025 the complete LP/MIP/VRP solver source code has been released under the Apache 2.0 license (NVIDIA Developer). On the Mittelmann LP benchmark (1e-4 tolerance), cuOpt's PDLP solver is faster than a top CPU LP solver on 60% of the instances where both converge, more than 10× faster on 20% of instances, and up to 5,000× on a single large multicommodity-flow instance; against CPU PDLP implementations it is consistently 10×–3,000× faster (NVIDIA Developer). In October 2025 cuOpt added a GPU-accelerated barrier (interior-point) method, which internal benchmarks show averaging more than 8× faster than a leading open-source CPU solver and more than 2× faster than a popular commercial CPU solver, filling the high-accuracy gap (NVIDIA Developer).

Among commercial solvers, Gurobi has landed GPU support along two routes: its barrier method uses NVIDIA cuDSS for sparse linear-system solves, and its PDHG method uses cuSPARSE for sparse matrix–vector products with data resident in GPU memory throughout; Gurobi also cautions that GPU PDLP's advantage depends strongly on problem characteristics, and in its internal test set CPU solvers still win on the majority of instances (Gurobi). The Chinese solver COPT (Shanshu Technology) open-sourced cuPDLP-C, and its GPU version COPTG performs strongly on third-party leaderboards (arXiv:2506.02174). Nothing illustrates the shifting landscape better than Hans Mittelmann's LPfeas leaderboard (data of 12 June 2026): the top three — COPTG (1.00), cuOpt 26.06 (1.07), HPRLP (1.36) — are all GPU solvers, ahead of CPU COPT (1.67), MOSEK (5.28), HiGHS (17.24), and PDLP (27.85); three of the top four entries are GPU-accelerated (Mittelmann Plots, ASU).

Boundary conditions that should be stated honestly: PDLP-type methods scale linearly with memory bandwidth, so reproducing the paper numbers requires relatively recent server-grade GPUs; on small LPs the GPU advantage is limited (which is why cuOpt offers a batch mode that solves hundreds of small LPs in parallel); and on the 49 public instances, 8 timed out due to slow convergence (NVIDIA Developer). Gurobi's engineering advice is therefore "pick the algorithm by model characteristics" rather than blanket GPU-ification (arXiv:2506.02174).

2.2 Quadratic Programming (QP) and Conic Programming (SOCP)

GPU-ification of QP advances along two routes. One is first-order methods: restarted accelerated PDHG (rAPDHG) targets large-scale convex QP, and its successor PDHCG (PDHG combined with conjugate gradients) is about 5× faster again than rAPDHG on specific large-scale tests and nearly two orders of magnitude faster than other solvers (Front. Eng. Mgmt.). The other route is moving the linear-system solves of interior-point methods onto the GPU: ClarabelGPU, the GPU version of the open-source conic solver Clarabel, factorizes the KKT system with the NVIDIA cuDSS library, and on large QP benchmarks it is the fastest of all solvers tested — more than 2× faster than Gurobi, about 4× faster than MOSEK, and about 10× faster than its own multithreaded Rust CPU implementation (arXiv:2412.19027).

These two routes correspond to the "factorization-free, bandwidth-hungry" and "GPU-accelerated factorization" paradigms respectively, and they also foreshadow the GPU-ification path for more general conic programs such as SOCP and SDP. cuOpt has listed QCQP and SOCP support in beta (GitHub). For engineering users, if you already model with CVXPY, both cuOpt and ClarabelGPU can be swapped in as backends at very low migration cost (NVIDIA).

2.3 Semidefinite Programming (SDP): cuLoRADS

SDP has long been bottlenecked by the factorization of huge matrix variables inside interior-point methods. cuLoRADS (open-sourced by the COPT team at Shanshu Technology) ports a two-stage algorithm — Burer–Monteiro low-rank factorization with an augmented-Lagrangian warm start followed by ADMM splitting — wholesale onto the GPU, using custom kernels and compressed storage exploiting the column sparsity of the constraint matrices to cut quadratic memory overhead down to something proportional to the number of nonzeros (arXiv:2407.15049). Its reported numbers are striking: on an H100 it solves MaxCut instances with 10⁷×10⁷ matrix variables in just 10–60 seconds each, whereas previous CPU solvers needed at least tens of hours for the same scale; a MaxCut with a 170M×170M matrix variable and 170 million constraints is solved in 160 seconds; on matrix-completion problems it is over 100× faster than the CPU version of LoRADS, and can solve a problem with an 8-million×8-million matrix variable and 320 million constraints in about 89 seconds — in the same time the CPU version can only handle 20,000×20,000 (arXiv:2407.15049).

On Mittelmann's sparse SDP leaderboard, cuLoRADS 1.0.0 already ranks second (score 3.01, behind only CPU COPT at 1.00, ahead of MOSEK at 3.67), making it the only GPU SDP solver currently in the leaderboard's top tier (Mittelmann Plots). Its limitations are that it does not yet support mixed problems containing linear variables, and robustness on general SDPs is still being improved (GitHub).

2.4 Mixed-Integer Programming (MILP), Combinatorial Optimization, and Vehicle Routing (VRP)

MILP is the hardest nut for GPU-ification: in branch-and-bound trees the LP subproblems at different nodes vary enormously in size and structure, and the highly irregular workload is a poor fit for the GPU's SIMT model (Front. Eng. Mgmt.). The currently viable paradigm is a hybrid architecture: the GPU runs massively parallel heuristics (to find high-quality feasible solutions quickly), while CPU branch-and-bound uses those solutions to prune the tree. This is exactly the idea behind NVIDIA cuOpt's MIP beta — GPU-accelerated primal heuristics (including three evolutionary algorithms, stagnation detection, subMIP evolution, and diving threads with branch-and-bound) rapidly produce feasible solutions, and it has even found new solutions for four open instances in MIPLIB (AlphaSignal). In a commercial case study, SimpleRose combined its parallel MIP solver with cuOpt (cuOpt provides heuristic solutions, Rose prunes in parallel), accelerating overall MILP solve time by up to 61.7× and the root LP by up to 50.2× (SimpleRose); combining HiGHS with cuOpt cut the MIP gap from 28% to 21% on one problem class (AlphaSignal).

VRP and routing optimization is cuOpt's most mature commercial module. By combining GPU-accelerated heuristics with evolutionary strategies, as of March 2024 it had broken world records on 15 instances of the Gehring & Homberger benchmark and 8 instances of the Li & Lim benchmark, and it has held all records in the CVRPTW and PDPTW categories for three consecutive years; NVIDIA claims routing solutions up to 100× faster (NVIDIA Developer). Practical deployments include: a 10,000-node VRP with real-world constraints solved on a single GPU in about 30 seconds; large-scale power unit commitment accelerated by up to 20×; and o9 Solutions achieving more than 10× planning speedup on production supply-chain data, turning "overnight batch processing" into "minute-level on-demand solving" (SimpleRose, AP News).

3. Deep Learning Training Optimizers

Deep learning is the most mature market for GPU optimization algorithms. "GPU acceleration" here operates at three levels: the implementation layer (fusing optimizer updates into CUDA kernels), the memory layer (low-bit/low-rank optimizer states so larger models fit in GPU memory), and the algorithm layer (new optimizers designed for GPU matrix compute).

3.1 Implementation Layer: Fused and Multi-Tensor Kernels

PyTorch provides foreach (horizontal fusion across multiple tensors) and fused (vertical fusion into a single CUDA kernel) implementations for Adam/AdamW/SGD and others. The principle is that multi-tensor-apply combines pointer management, memory alignment, vectorization, and the Adam math into one kernel, significantly reducing kernel-launch overhead and memory round-trips; this is the de facto default for large-scale training (GPU MODE). There is also the more advanced trick of "fusing the optimizer into backpropagation": using register_post_accumulate_grad_hook to apply the update as soon as each parameter's gradient is ready, eliminating the persistent gradient tensor — an official PyTorch tutorial claims this can be done in 10 lines of code (PyTorch).

These tricks do not change the optimizer's mathematical behavior, only constant factors, typically delivering single-digit to two-digit percentage speedups — but they are risk-free and tuning-free, and should be the baseline configuration for any GPU training task. In the JAX ecosystem the equivalents are Optax combinators and jax.jit XLA fusion, with similar effects.

3.2 Memory Layer: Low-Bit and Low-Rank Optimizers

Adam maintains two 32-bit states (first and second moments) per parameter, so optimizer memory often dominates training memory. bitsandbytes' 8-bit optimizers (the full family: Adam8bit/AdamW8bit/Lion8bit and more) use block-wise dynamic quantization to store states in 8 bits, dequantizing to FP32 for the update and re-quantizing each step, saving roughly 75% of optimizer memory with negligible accuracy loss; this is the quantization backend for Hugging Face Transformers/PEFT/Diffusers (bitsandbytes, Leeroopedia). Paged variants can additionally swap states out to CPU automatically when GPU memory runs low.

Another route is structural rank reduction: GaLore projects gradients onto a low-rank subspace before feeding them to Adam; GaLore 2 further combines low-bit projection matrices with deep FSDP sharding integration, substantially reducing per-GPU memory for Llama-3-class models on 2 GPUs (arXiv:2504.20437). Adafactor (row/column factorization of second moments) and DeepSpeed ZeRO's optimizer-state sharding with CPU offload are system-level approaches: ZeRO-Offload moves optimizer computation to the CPU (using AVX instructions) in exchange for memory (arXiv:2209.00099). The engineering rule of thumb: if memory is tight, start with 8-bit Adam (almost lossless); if still insufficient, add GaLore/FSDP sharding; ZeRO-Offload is the last resort (with obvious throughput loss).

3.3 Algorithm Layer: A New Generation of GPU-Born Optimizers

Over the past two years a batch of "matrix-aware" methods has emerged in LLM pretraining optimizers, sharing a common idea: trade GPU-friendly dense matrix operations for fewer training steps. Muon (proposed by Keller Jordan) orthogonalizes the momentum of hidden-layer 2D weight matrices via Newton–Schulz iteration; it maintains only momentum (no second moments, halving state memory), and achieves roughly 30–50% wall-clock advantage over AdamW in the NanoGPT speedrun and Karpathy's nanochat, i.e. about 2× compute efficiency (Grokipedia). Muon has been integrated into NVIDIA Megatron Core, and through layered distributed optimization and distributed Newton–Schulz iteration achieves throughput on GB300 nearly on par with AdamW (NVIDIA Developer); Turbo-Muon further accelerates the orthogonalization subroutine itself by 2.8× (Triton fused kernels + AOL preconditioning), cutting per-step time on a 1.3B model by about 8–10% (EmergentMind).

In the second-order and full-matrix preconditioning direction, Sophia (a lightweight second-order optimizer using diagonal Hessian estimates with element-wise clipping) reports roughly 2× speedup over Adam in steps, compute, and wall-clock; however, independent reproductions by Fraunhofer IIS show that although Sophia achieves the lowest training and validation loss, Lion is fastest in GPU-hours and AdamW scores best on downstream evaluation — demonstrating that "new optimizers are faster" depends heavily on the evaluation protocol (Facebook/DeepNet, arXiv:2507.08472). The Shampoo/SOAP family trades full-matrix preconditioning for stronger per-step progress: distributed Shampoo's per-step overhead, amortized across multiple GPUs, is typically only about 10% higher than Adam (EmergentMind); NVIDIA's large-scale pretraining study shows both SOAP and Muon consistently beat AdamW and scale to larger batch sizes, recommending KL-SOAP when memory is not tight (arXiv:2607.20548). Lion (a sign-momentum optimizer discovered by Google through evolutionary search) needs only one state tensor and suits memory-constrained scenarios where hyperparameter tuning is acceptable (arXiv:2312.03863).

4. Evolutionary Computation and Swarm Intelligence

Evolutionary algorithms (EAs) are naturally GPU-friendly: fitness evaluation of every individual in the population is fully independent, and crossover and mutation can also be vectorized. The bottleneck has historically been software frameworks rather than the algorithms — traditional Python EA libraries (such as DEAP) are CPU-serial. A new generation of GPU frameworks fills this gap: EvoX (EMI Group) is built on PyTorch and ships 50+ algorithms including GA, DE, PSO, CMA-ES, NSGA-II/RVEA/MOEA/D together with 100+ benchmark problems; it officially claims 100×+ acceleration on heterogeneous hardware, supports distributed multi-node execution, and interfaces with the Brax physics engine for evolutionary reinforcement learning (EvoX, GitHub). On the JAX side there is evosax (focused on evolution strategies, a GPU-optimized collection of ES algorithms) and EvoJAX (oriented toward neuroevolution); on the PyTorch side there is also EvoTorch (arXiv:2412.20980).

Academic evaluations highlight an important fact: different EAs gain very differently on GPUs — parallel granularity (individual-level vs gene-level), problem dimension, and the computational intensity of the fitness function determine the speedup, which cannot be summarized by a single number (arXiv:2601.18446). Practical experience says: the heavier the fitness evaluation itself (e.g., neuroevolution, simulation rollouts), the greater the GPU benefit; on pure numerical benchmark functions, GPUs can actually lose to CPUs at small population sizes due to kernel-launch overhead, and populations of thousands or more are needed to saturate the GPU. The non-dominated sorting step of multi-objective algorithms is highly irregular and harder to GPU-ify than single-objective ones; EvoX handles such problems through a unified tensorized programming model (arXiv:2609.02387).

5. Bayesian Optimization and Hyperparameter Search

GPU-ification of Bayesian optimization (BO) shows up in two ways: Gaussian-process (GP) matrix computations on the GPU, and batched parallel evaluation of the acquisition function over tens of thousands of candidate points. Meta's BoTorch (built on GPyTorch) supports batch evaluation in all components; increasing the number of Monte Carlo samples of the acquisition function has little impact on wall-clock time, and the official appendix reports significant GPU speedups; multi-objective acquisition functions (qLogNEHVI and others) can be solved efficiently in practical scenarios thanks to automatic differentiation and GPU acceleration (NeurIPS, BoTorch). Trust-region variants for high-dimensional problems, TuRBO/FuRBO, also run on GPUs and suit expensive-simulation optimization (CFD, chip design).

In hyperparameter optimization (HPO), Optuna's TPE sampler with pruning algorithms is the mainstream choice for single machines and small clusters, scalable to thousands of workers through a shared database backend (LabOak); Ray Tune targets parallel trial scheduling on GPU clusters, integrating search algorithms such as Optuna/HyperOpt with early-stopping schedulers such as ASHA/HyperBand/PBT. Industry practice shows that ASHA early stopping can cut total GPU compute cost of HPO by 70–80% without accuracy loss, roughly a 5–10× compute saving over grid/random search (Swfte, ML Journey). Selection advice: for a single machine with flexibility as priority, use Optuna; for multi-machine multi-GPU setups with fault tolerance and productionization as priorities, use Ray Tune (ML Journey).

6. Robot Motion Planning and Differentiable Nonlinear Optimization

The flagship in robotics is NVIDIA cuRobo: collision-free minimum-jerk trajectory generation for robot arms is formulated as a global optimization problem, solved by a combination of particle-sampling exploration, L-BFGS gradient refinement, and parallel noisy line search, optimizing hundreds of trajectories simultaneously on the GPU. The official paper reports solving hard motion-generation problems within an average of 50 ms — 60× faster than SOTA trajectory-optimization methods — with collision-free IK solved over 7,000 times per second (80× faster than common libraries), and on the embedded Jetson Orin NX platform it processes 512 trajectories × 64 steps in parallel at 500 Hz (Hugging Face, arXiv:2508.04146).

The more general tool is Meta's Theseus: a differentiable nonlinear least-squares library built on PyTorch, providing second-order optimizers such as Gauss–Newton, Levenberg–Marquardt, and Dogleg, with built-in batching, automatic vectorization, GPU sparse solvers (including its self-developed batched sparse Cholesky solver Baspacho), and support for implicit differentiation that embeds the entire optimization process into a neural network for end-to-end learning (NeurIPS 2022). The two represent "domain-specific parallel global optimization" and "general-purpose differentiable optimization infrastructure" respectively: the former is ready out of the box for motion planning, the latter suits scenarios like SLAM, pose-graph optimization, and inverse dynamics where optimization must be a layer inside a network.

7. Quantum-Inspired and Annealing Optimization

Combinatorial optimization in QUBO/Ising form has spawned a family of "physics-inspired" solvers, several offering GPU implementations: Fujitsu's Digital Annealer (improved simulated annealing with parallel trial moves and dynamic escape, on digital CMOS hardware, with CPU/GPU software modes; about two orders of magnitude faster than single-core SA on fully connected spin glasses, though with no advantage on sparse graphs) (Frontiers); Toshiba's Simulated Bifurcation Machine (CPU/GPU/FPGA supported); and the pure-GPU route of Compal's Quantix GPUA (multi-body adaptive search) (arXiv:2509.09862). Cross-annealer benchmark studies show: on classic problems like Max-Cut, TSP, and job-shop scheduling, GPU annealers match Fujitsu's DA in solution quality with wins on both sides, but on many small and medium instances well-tuned classical algorithms (such as OR-Tools) actually have the shortest solve times — the annealers' advantage lies mainly in extremely large, fully connected QUBOs (IEEE/InspireHEP, arXiv:2507.22117).

The lesson for engineering users: if your problem maps cleanly onto a large-scale QUBO and classical solvers are already struggling, GPU annealing/bifurcation methods are worth trying as a complement; otherwise the mature mathematical-programming route (GPU LP relaxations + heuristics + CPU branch-and-bound) is usually more controllable and easier to integrate.

8. Speedup Overview and Boundary Conditions

Placing the public figures of each domain on one chart makes the "order-of-magnitude distribution" of GPU acceleration immediately visible: in any domain whose bottleneck can be restructured as massively parallel regular computation (first-order LP methods, low-rank ADMM for SDP, evolutionary evaluation, trajectory sampling), speedups reach the 10²–10³ range; in domains where algorithms are already highly optimized and the GPU only contributes a constant-factor improvement (deep learning optimizers, QP interior points), typical gains are 2–10×. Note that the bars in the figure below come from mutually incomparable measurement setups (different hardware, different accuracy tolerances, different baselines); they are for perceiving magnitudes only, not for direct cross-comparison (NVIDIA Developer, arXiv:2407.15049, EvoX).

Typical situations where GPU acceleration fails or its benefit shrinks include: problems that are too small (kernel-launch and PCIe transfer overheads outweigh parallel gains — this is why cuOpt provides a small-LP batch mode); requirements for 1e-8-level high accuracy (first-order methods converge slowly, and GPU barrier/interior-point methods are more appropriate here); irregular tree search like branch-and-bound (hard for GPUs to schedule efficiently); and problems that do not fit in GPU memory (in the PDLP paper, some very large instances exceed single-GPU memory and can only be handled by large-memory CPU machines) (NVIDIA Developer, arXiv:2501.07018). Before selecting, it is advisable to run a small-scale benchmark on your own 3–5 most representative instances rather than taking vendor numbers at face value.

9. Engineering Selection Table

The table below aggregates the main GPU optimization tools covered in this report by problem type, together with their key attributes, for quick reference. Licenses and feature status are as of mid-2026; please check each project's latest documentation before deployment.

Problem Type	Representative Tools	Core Algorithm	Hardware/Ecosystem	Representative Public Performance	License
Large-scale LP	NVIDIA cuOpt (GitHub)	PDLP (PDHG) + GPU barrier	CUDA; Python/C/Server APIs; plugs into CVXPY/PuLP/AMPL	#2 on Mittelmann LPfeas (1.07); up to 5,000× on a single instance (NVIDIA)	Apache 2.0
Large-scale LP	cuPDLP.jl / cuPDLP-C / cuPDLP+ (arXiv)	Restarted (Halpern) PDHG	Julia/C + CUDA; research-friendly	3.7× vs Gurobi barrier on large LP; cuPDLP+ another 2–4× (arXiv)	Open source
LP (commercial)	COPT GPU / Gurobi GPU (Gurobi)	GPU PDHG / cuDSS barrier	Commercial solver + CUDA	COPTG tops LPfeas (1.00) (Mittelmann)	Commercial
QP / SOCP	ClarabelGPU (arXiv); cuOpt QP (beta)	Interior point + cuDSS / PDHG family	Rust/CUDA; CVXPY backend	2×+ faster than Gurobi, ~4× faster than MOSEK on large QP	MIT / Apache 2.0
SDP	cuLoRADS (GitHub)	Low-rank Burer–Monteiro + ALM/ADMM	Julia/CUDA	10⁷-scale MaxCut in 10–60 s; 100×+ vs CPU	Open source
MILP	cuOpt MIP (beta); Rose+cuOpt (SimpleRose)	GPU primal heuristics + CPU B&B hybrid	CUDA; composable with HiGHS etc.	Up to 61.7× overall MILP (hybrid scheme)	Apache 2.0 / Commercial
VRP / Routing	cuOpt Routing (NVIDIA)	GPU heuristics + evolutionary strategy	CUDA; Python/REST	23 world records; 10k-node VRP in ~30 s	Apache 2.0
DL training (general)	fused AdamW / torch.compile (GPU MODE)	Fused kernels	Built into PyTorch/JAX	Constant-factor speedup; risk-free baseline	Open source
DL training (memory-saving)	bitsandbytes 8-bit; GaLore 2 (arXiv)	Block-wise quantization / low-rank gradient projection	PyTorch; HF ecosystem default	−75% optimizer memory	MIT
DL training (new algorithms)	Muon / KL-SOAP / Sophia / Lion (NVIDIA)	Matrix orthogonalization / full-matrix preconditioning / diagonal second-order	Megatron Core, pytorch-optimizer	~1.5–2× compute efficiency vs AdamW (protocol-dependent)	Open source
Evolutionary / Swarm	EvoX (GitHub); evosax	GA/DE/PSO/CMA-ES/NSGA-II fully tensorized	PyTorch / JAX + GPU	Officially claimed 100×+; 50+ algorithms	Open source
Bayesian optimization	BoTorch + GPyTorch (BoTorch)	GP + batched MC acquisition evaluation	PyTorch GPU	Significant batched/multi-objective acceleration	MIT
Hyperparameter search	Optuna / Ray Tune (ML Journey)	TPE + ASHA/PBT early stopping	Single machine → GPU cluster	Early stopping saves 70–80% GPU compute	MIT / Apache 2.0
Robot planning	cuRobo (arXiv)	Particle optimization + parallel L-BFGS	CUDA; ROS2 interface	60× vs CPU planners; IK at 7,000 queries/s	Apache 2.0
Differentiable NLS	Theseus (NeurIPS)	Gauss–Newton / LM / Dogleg + batched sparse Cholesky	PyTorch GPU	Significant batched-vectorization speedup	MIT
QUBO / Annealing	Fujitsu DA / Toshiba SBM / Quantix GPUA (arXiv)	Parallel simulated annealing / simulated bifurcation	Dedicated hardware / GPU	~100× vs single-core SA on fully connected spin glass	Mostly commercial

10. Conclusion

The landscape of GPU-accelerated optimization algorithms can be summed up in one sentence: rewriting an optimization problem into a "massively parallel + bandwidth-friendly" form usually pays far more than simply porting an existing algorithm. In mathematical programming, the paradigm replacement of simplex/interior-point methods by PDHG first-order methods is the most profound change, and cuOpt, COPT GPU, and cuLoRADS have already surpassed traditional CPU commercial solvers on authoritative leaderboards. In deep learning, fused kernels and 8-bit states are "free lunches" that must be taken, while matrix-aware optimizers like Muon/SOAP represent the next wave of algorithm-level dividends. Evolutionary computation, Bayesian optimization, and robot planning gain order-of-magnitude improvements from their naturally batched parallel structure. For engineering deployment, three principles apply: first, use the selection table to lock in one or two candidate tools by problem type; second, benchmark on your own instances under real accuracy requirements; third, keep CPU options as a fallback for small-scale, high-precision, or branch-heavy problems — the hybrid architecture (GPU for speed, CPU for accuracy and global certificates) will remain the most robust deployment form for the foreseeable few years.

Note: This report is a general technical survey. All cited speedups come from public tests conducted by their respective sources, with varying measurement setups and hardware environments, and do not constitute a guarantee of product selection or commercial advice.

DEV Community: Johnny is piggy

Learning-Based Optimization and Planning Algorithms: A Comprehensive Technical Survey and Engineering Adoption Guide

Table of Contents

Executive Summary

1. Scope and Taxonomy

1.1 What Is "Learning-Based Optimization and Planning"

1.2 A Six-Paradigm Taxonomy

1.3 Historical Arc: Three Eras

1.4 Representative Surveys and Community Resources

2. Paradigm 1: End-to-End Neural Combinatorial Optimization (NCO)

2.1 Three Technical Routes

2.2 Comparison of Representative Methods

2.3 The Real Gap with Classical Solvers: A Critical Assessment

2.4 Benchmarks and Evaluation Infrastructure

2.5 Frontier Progress (2024–2026): From Single-Task Specialists to Cross-Problem Generalist Solvers

3. Paradigm 2: Learning-Augmented Classical Solvers

3.1 Learning Components Inside MIP Solvers

3.2 Learning-Guided Neighborhood Search and Hybrid Frameworks

3.3 Why the Hybrid Route Is Today's Industrial Mainstream

3.4 Frontier Progress (2024–2026): LLMs Enter the Solver; the Predict-and-Search Family Grows

4. Paradigm 3: Learning to Optimize (Learned Optimizers)

4.1 Replacing Hand-Designed Optimization Algorithms with Learning

4.2 The Industrialization of HPO and Symbolic Optimizer Discovery

4.3 Frontier Progress (2024–2026): The Muon Event and the Industrialization of Optimizer Discovery

5. Paradigm 4: Decision-Focused Learning and Differentiable Optimization (Predict-then-Optimize)

5.1 Problem Setup: Making Predictions Accountable to Decisions

5.2 Toolchain and Applicable Scenarios

5.3 Frontier Developments: Benchmark Standardization and a Unified View of Contextual Decisions

6. Paradigm 5: LLM-Driven Optimization

6.1 LLMs as Optimizers: OPRO and Prompt-Space Search

6.2 Heuristic Evolution and Algorithm Discovery: The FunSearch–AlphaEvolve Lineage

6.3 LLM Automated Modeling: From Natural Language to Solver Code

6.4 LLM End-to-End Solving and Inference-Time Search

6.5 Frontier Progress (2025–2026): Evaluation Suites Crystallize and Paradigms Fuse

7. Paradigm 6: Learning-Based Planning and Control

7.1 Learning-Augmented MPC and Safety Guarantees

7.2 Robot Motion Planning and Task-and-Motion Planning (TAMP)

7.3 End-to-End Autonomous Driving Planning

7.4 LLM Embodied Task Planning

7.5 Frontier Progress (2024–2026): VLA Robot Foundation Models and Large Driving Models

8. Scheduling and Manufacturing: The Practical Landscape of Deep-Learning Scheduling

8.1 From L2D to the GNN+DRL Standard Paradigm

8.2 Adoption Status and a Sober Assessment

8.3 Frontier Progress (2024–2026): LLMs Enter Shop-Floor Scheduling

9. Industrial Adoption Panorama: A Global Practice Map

9.1 Overview: From "Point Demonstrations" to "Global Rollout"

9.2 Semiconductors and EDA: The Most Commercialized Battleground for Learning Optimization

9.3 Energy and Power: From Data Centers and Power Markets to Oil & Gas Plants

9.4 Logistics, Parcel, and Warehouse Robotics: The Largest-Scale Online Optimization Systems

9.5 Urban Traffic Signals and Mobility Platforms

9.6 Financial Trade Execution: Reinforcement Learning's Invisible Large-Scale Deployment

9.7 Commercial Platforms and Solver Vendors Go All-In on Learning

9.8 Consolidated Comparison of Global Deployments

10. Open-Source Toolchain Panorama and Selection

10.1 A Tool Map by Paradigm

10.2 Key Dimensions of Selection Decisions

11. Engineering Adoption Guide

11.1 A Paradigm-Selection Decision Framework

11.2 Common Pitfalls and a Deployment Checklist

11.3 From Shadow Mode to Closed-Loop Autonomy: A Staged Deployment Path

12. Challenges, Controversies, and Open Problems

12.1 Fundamental Questions on Generalization and Scaling

12.2 Data, Evaluation, and Trustworthiness

13. Frontier Trends (2025–2026) and Outlook

13.1 The Rise of Foundation Models for Combinatorial Optimization (FM4CO)

13.2 Deep Coupling of LLMs and Solvers

13.3 A Converging Unified Picture

GPU-Accelerated Optimization Algorithms: A Complete Survey and Selection Guide (2026)

Executive Summary

1. Overview: The Landscape of GPU-Accelerated Optimization

2. Mathematical Programming and Operations Research Solvers

2.1 Linear Programming (LP): The PDHG/PDLP Family and cuOpt

2.2 Quadratic Programming (QP) and Conic Programming (SOCP)

2.3 Semidefinite Programming (SDP): cuLoRADS

2.4 Mixed-Integer Programming (MILP), Combinatorial Optimization, and Vehicle Routing (VRP)

3. Deep Learning Training Optimizers

3.1 Implementation Layer: Fused and Multi-Tensor Kernels

3.2 Memory Layer: Low-Bit and Low-Rank Optimizers

3.3 Algorithm Layer: A New Generation of GPU-Born Optimizers

4. Evolutionary Computation and Swarm Intelligence