Vehicle Routing Problem Meets Large Language Models: An Overview and Perspectives

Abstract: The vehicle routing problem (VRP) is a central optimization problem in artificial intelligence, logistics automation, transportation scheduling, and industrial decision-making. VRP and its variants are NP-hard, and practical routing tasks often combine time windows, vehicle capacities, pickup-and-delivery relations, dynamic requests, and other operational constraints, making both modeling and solving difficult. LLMs provide a flexible interface for routing optimization by processing natural-language requirements, generating code, reasoning over constraints, and interacting with external tools. This survey reviews LLM-driven research on VRP, covering the basic definition, main variants, major solver families, and LLM concepts needed for this topic. Existing studies are organized into three roles: modelers translate natural-language requirements into constraints and modeling code; designers generate heuristics, operators, or route plans; and coordinators organize tool calls, multi-agent collaboration, and connections with neural solvers. The survey also reviews standard benchmarks, real or near-real operational datasets, LLM-oriented evaluation frameworks, and two comparative experiments. The goal is to clarify current progress in LLM-assisted routing optimization and provide a structured reference for intelligent decision-making, advanced manufacturing, and industrial automation.

• The paper introduces a taxonomy of LLM roles—modeler, designer, and coordinator—for tackling complex VRPs.
• It demonstrates that LLM-driven methods can improve constraint translation and heuristic generation, balancing solution quality with computational cost.
• Experimental evaluations and benchmarking highlight the need for transparent, human-in-the-loop frameworks for robust LLM integration.

LLMs and the Vehicle Routing Problem: Roles, Frameworks, and Experimental Insights

Introduction

This survey provides a comprehensive synthesis of the rapid developments at the intersection of the Vehicle Routing Problem (VRP) and LLMs, structuring the analysis along the distinct functional roles LLMs play in combinatorial optimization pipelines. It delineates the landscape of LLM-driven VRP research by separating the roles into modeler (formalization and modeling), designer (heuristic and route generation), and coordinator (workflow orchestration and solver integration). The paper also systematizes benchmarking resources and presents comparative experiments that empirically characterize the performance of LLM-driven methodologies vis-à-vis traditional and neural combinatorial optimization (NCO) solvers.

Figure 1: A timeline capturing the evolution of LLM-driven VRP research, from initial agentic tool invocation to recent advances in modeling automation and multi-agent system integration.

Technical Background: VRP, Solution Taxonomy, and LLM Capabilities

The VRP encapsulates a spectrum of NP-hard combinatorial optimization problems, including core variants such as CVRP, VRPTW, SDVRP, EVRP, MDVRP, and others, each embedding constraints such as heterogeneous resources, spatiotemporal limits, and compound objectives. The solution landscape historically spans three families: exact optimization (e.g., branch-and-cut/price), heuristic/metaheuristic schemes (e.g., LNS, HGS, ALNS), and learning-based solvers leveraging GNNs and RL for policy learning and schedule construction.

Transformer-based LLMs provide a natural interface at the boundary between unstructured business logic and formal combinatorial solvers due to their capabilities in language understanding, code synthesis, and multi-modal data conditioning. The paper systematizes the modes of LLM intervention into three roles, visualized and operationalized in subsequent sections.

LLMs as Modelers: Natural Language to Optimization Model

In the modeler role, LLMs automate the translation of natural language business constraints into solver-ready formalizations (MIP/CP code, variable/constraint definitions, objective construction), followed by execution validation and repair.

Figure 2: Schematic of the modeler workflow from requirement parsing to closed-loop model refinement through LLM-assisted code generation and validation.

Key methodologies leverage structured prompting, program synthesis with feedback, tree decomposition, retrieval-augmented generation, and multi-agent formulation/critique architectures. Tools such as OptiMUS, ORMind, and AlphaOPT operationalize staged workflows, with distinct modules for problem parsing, code production, and iterative debugging. For VRP, advanced mechanisms address constraint decomposition, template retrieval for compound requirements, and dual-agent separation of mathematical abstraction and implementation.

Despite progress, the modeler role remains bottlenecked by spontaneous error accumulation (variable scope, index mismatch, constraint semantics), rendering robustness contingent on explicit interface checks and multi-round repair, rather than reliably LLM-autonomous.

LLMs as Designers: Heuristic Generation and Direct Route Reasoning

The designer role divides into two paradigms: LLM-mediated heuristic/program generation (often in closed-loop, evolution-inspired frameworks), and direct, end-to-end route output from natural-language VRP descriptions.

Figure 3: Structure of the designer workflow, contrasting automated heuristic generation with end-to-end VRP route reasoning by LLMs.

LLMs formulate or evolve constructive/improvement operators, guided by external fitness evaluation or program execution results (AEL, FunSearch, EoH, ReEvo, MEoH, etc.), and increasingly support population-based, diversity-aware, reflective, or hierarchical search. In the VRP context, frameworks such as G-LNS, HeuriGym, and VRPAgent situate LLMs to automatically produce specialized operators (e.g., destroy/repair for LNS), or to fine-tune local components in metaheuristic solvers (HGS in PyVRP+).

On heuristic generation benchmarks, LLMs augmented with feedback loops (closed-loop code evaluation, iterative refinement) exhibit consistent improvements in cost and feasibility compared to one-shot heuristic generation or direct route output. Notably, larger LLMs are more likely to return high-quality, constraint-respecting heuristics but with a concomitant increase in computational overhead, while smaller models display fast runtime with a significant degradation in solution quality for complex VRP variants.

Figure 4: Normalized cost and runtime score chart for LLM-generated heuristics across six VRP variants and multiple model families.

For direct route generation, empirical results indicate that LLMs achieve moderate-quality solutions for small-scale instances (CVRP with $n\leq 50$), but combinatorial explosion and weak reasoning over hard constraints rapidly degrade solution quality as instance size increases.

LLMs as Coordinators: Workflow Orchestration and Neural Solver Integration

The coordinator role extends LLMs to orchestrate modular solver workflows, manage agentic decomposition, or inject semantic priors into neural solvers.

Figure 5: Taxonomy and schematic of coordinator workflows, encompassing tool orchestration, multi-agent role specialization, and LLM-guided neural solver integration.

Representative mechanisms include agentic LLM controllers that dynamically schedule constraint extraction, normalization, construction, improvement, and feasibility checking via tool invocation (cf. ReAct, Toolformer, AutoGPT-style pipelines). Multi-agent coordination (e.g., AFL, MAEF, HMACE) partitions complex tasks into planner/generator/verifier, sharing persistent memory and cross-verifying outputs to mitigate error accumulation.

Neural solver integration uses LLMs as meta-controllers for feature extraction, policy biasing, mask generation, or strategy correction, integrated with NCO backends (NCO-LLMs, URS, LLMAide, AlignOPT). These approaches empirically demonstrate enhanced generalization, especially in the presence of out-of-distribution constraints or instance parameters, and further improve runtime scalability versus pure LLM algorithms.

Datasets, Benchmarks, and Unified Evaluation Protocols

The survey compiles and categorizes standard VRP benchmarks and operational datasets, with an explicit focus on their suitability for different LLM roles (modeling, heuristic design, workflow evaluation). It underscores the inadequacy of classical synthetic datasets (CVRPLIB, Solomon, etc.) for fully characterizing LLM capabilities, advocating the adoption of datasets with natural-language descriptions, dynamic constraints, and real-world delivery process features (Amazon Last-Mile, Olist-VRP, SVRPBench, etc.).

LLM-oriented benchmarks (HeuriGym, RL4CO, RoutBench) introduce standardized task APIs, programmatic scoring, and feasibility validation for direct and automated heuristic generation, enabling reproducible evaluation and clear model comparison.

Comparative Experiments: Cost, Feasibility, and Scalability

The paper presents two experimental regimes:

• On randomly generated CVRP instances of varying scale ($n=20$ to $n=500$), traditional solvers (PyVRP, LKH3) maintain small or zero optimality gaps but incur high computational cost as $n$ increases; NCO policies (POMO, RouteFinder, Sym-NCO) deliver near-optimal solutions for moderate $n$ but performance deteriorates at larger scales or under unseen constraints; direct LLM heuristic generators without feedback are uncompetitive for large $n$, with the best-performing LLM+NCO hybrids (NCO-LLMs) achieving sub-2% gaps with low runtime for $n=500$.
• In heuristic generation across six VRP variants, high-parameter LLMs (gpt-5.5, deepseek-v4-pro) consistently achieve lower normalized cost at the expense of computational time, while smaller models (qwen3.7-plus, gpt-oss:20b) produce feasible but higher-cost solutions with faster runtime. Variants with temporal, sequential, or split constraints (VRPTW, SVRP, VRPB) amplify performance spread across models, substantiating LLM-induced variability in constraint reasoning.

Implications, Open Problems, and Perspectives

The survey identifies LLMs as valuable interfaces for bridging unstructured VRP constraints with optimization backends, facilitating rapid prototyping, and augmenting classical and NCO approaches (e.g., via hybrid LLM+NCO architectures). However, LLMs currently lack the reliability, interpretability, and scalability necessary for autonomous end-to-end deployment, particularly in large-scale and heavily constrained industrial settings.

Key research directions include:

• Developing verifiable intermediate representations for constraints and reasoning chains to improve transparency and debuggability.
• Advancing human-in-the-loop optimization systems where LLMs translate operator intent and operational incidents into constraint adjustments.
• Constructing multimodal datasets (textual, graphical, visual) and comprehensive evaluation protocols capturing not only numerical solution quality but also process-level execution, constraint satisfaction, and error traceability.
• Deepening theoretical analyses of LLM compositional generalization, feasibility boundaries, and interaction effects with neural policy solvers for robust large-scale deployment.

Conclusion

This survey establishes a rigorous taxonomy of LLM-driven approaches for VRP, critically assesses their empirical efficacy across modeling, heuristic design, and coordination, and charts a research agenda for integrating LLMs as robust, interpretable intermediaries in AI-augmented combinatorial optimization systems. As the field advances, systematic benchmarks, process traceability, and deeper coupling with established optimization theory will be pivotal in maturing LLM-assisted VRP from promising prototypes to widely deployable systems.

---

Reference:

"Vehicle Routing Problem Meets LLMs: An Overview and Perspectives" (2607.00604)