25 recent papers · updated 2026-09-03 · sources deduplicated from arXiv, OpenAlex and Semantic Scholar
2026-09-01 | National University of Singapore, Sun Yat-sen University Method: Multi-agent framework (RLEA) with a neural Planner trained with Soft Q-learning, an LLM-based Executor and an evolutionary memory module with retrieval-augmented generation | LLM role: code_writer, decomposition_guide, evaluator, evolutionary_search
This paper proposes RLEA, a multi-agent framework that uses a lightweight neural planner trained via Soft Q-learning to orchestrate LLM actions (refinement, RAG and memory retrieval) for automatically generating solver-ready code for complex VRP variants. The results are backed by strong empirical evidence, achieving a 62.5% success rate on 48 VRP variants using OR-Tools, outperforming the state-of-the-art DRoC by 16.67% while reducing runtime errors. The key insight is that instead of using expensive LLM calls for step-by-step decision making, training a small language model with RL to act as a policy network for selecting agent actions significantly reduces latency and improves exploration. This is highly relevant for LLM evolutionary search and multi-agent optimization, as the architecture of an RL-trained planner combined with an evolving memory pool directly addresses sample efficiency and continuous learning in automated algorithm design.
2026-08-29 | Tencent, University of Southern California Method: Benchmark construction and evaluation framework for LLM tool use in global optimization | LLM role: evaluated_agent
Xu et al. introduce AlgoWorlds, a benchmark of 240 environments across 10 combinatorial optimization families designed to evaluate whether LLM agents can use tools to gather hidden instance data and output globally optimal decisions. The results are backed by extensive evaluations across 7 frontier models, demonstrating that while models like Claude Opus 4.8 achieve high feasibility (over 96%), they fail to reach exact global optimality (only 38.6% success). The key insight is that the primary bottleneck for LLMs in optimization is not information acquisition or constraint satisfaction, but the joint reasoning required to integrate information into a globally optimal configuration.
2026-08-25 | Stanford University Method: LLM-based agent combined with Lean proof assistant for autoformalization and automated theorem proving (ATP) | LLM role: autoformalization, theorem_proving_agent
Robbins et al. introduce FLARE, an automated framework that uses an LLM agent and the Lean proof assistant to formally verify whether one MILP formulation is a valid reformulation of another. The authors demonstrate 100% accuracy on a new benchmark of 54 NP-hard formulation pairs, backed by machine-checkable proofs rather than heuristic execution checks. The key insight is that instance-level validation—commonly used to evaluate LLM-generated models—is fundamentally flawed and can accept invalid transformations; the authors prove this by identifying mathematically invalid cutting planes generated by recent LLM evolutionary search frameworks.
2026-08-19 | UC Berkeley, Independent Researcher Method: Neuro-symbolic framework (SDDL) for natural-language to solver-aligned representation translation | LLM role: formalization_translator
Sharma et al. introduce SDDL, a 7-primitive domain-specific language that allows resource-constrained LLMs to translate natural-language scheduling problems into formal representations, which are then deterministically compiled to CP-SAT. The results are backed by rigorous evaluation, showing that Qwen3.5-27B improves from 21.7% feasibility when generating raw solver code to 55.3% when using SDDL on a 300-instance benchmark. The key insight is that bounding the LLM's generation space to a closed vocabulary of domain constructs removes error-prone variable declarations and API syntax, shifting the burden of correct solver encoding to a deterministic compiler.
2026-08-14 | Independent Researcher Method: Minimal-core-guided repair for Answer Set Programming (ASP) formalizations | LLM role: code_writer
This paper replaces generic solver error messages with minimal unsatisfiable cores (MUCs) to guide LLM self-repair when translating natural language constraint problems into Answer Set Programming. The results are backed by a 77-instance benchmark, showing that MUC feedback reduces fabricated solutions on infeasible problems from 79% to 7% for weaker models, though strong models perform well even with generic chain-of-thought. The key insight is that raw solver errors (e.g., 'unsatisfiable') often cause LLMs to blindly delete valid constraints until a problem becomes solvable, whereas structural proof artifacts localize the conflict and allow the LLM to correctly identify genuine infeasibility. This is highly relevant for symbolic OR modeling and LLM-in-the-loop optimization; the community could adapt this by using Irreducible Infeasible Subsystems (IIS) from MIP solvers as a high-quality, leakage-free feedback signal for LLM evolutionary search or autoformalization pipelines.
2026-07-31 | University of the Chinese Academy of Sciences Method: Certifying multi-relational evaluation system (E0-E6 semantic profile) using exact-rational certificates | LLM role: none
This paper introduces ModelEquivBench, a certifying evaluation system that assesses LLM-generated optimization models across a seven-dimensional semantic profile (E0-E6) using exact-rational mathematical certificates rather than simple execution or structural matching. The results are rigorously backed by numbers on 173 Bench4Opt problems, demonstrating that standard execution-success metrics overestimate correctness by up to 49 cases per model, while structural baselines falsely reject mathematically equivalent models. The key insight is that the evaluation of generated OR models cannot be reduced to a single scalar or structural graph match; instead, using exact-rational certificates (e.g., Farkas lemma for feasible set containment) provides a mathematically sound, multi-relational profile of model correctness.
2026-07-31 | University of the Chinese Academy of Sciences Method: Intermediate representation-first autoformulation pipeline with deterministic verification and compilation | LLM role: structured_representation_generator
IR2Solve translates natural language optimization problems into solver-ready code using a single LLM call to generate a structured JSON intermediate representation (ModelIR), followed by deterministic verification and compilation. The results are rigorously backed by numbers across six cleaned benchmarks, demonstrating that the system matches the accuracy of complex multi-agent and iterative systems while using up to 22x fewer tokens and only one API call. The key insight is that constraining the LLM to output a strict mathematical IR—thereby separating semantic modeling from solver API syntax—eliminates the need for expensive LLM-based iterative repair.
2026-07-30 | Shanghai University, Sun Yat-sen University, Guangxi University Method: Graph Retrieval-Augmented Generation (GraphRAG) based agentic workflow | LLM role: modeling_pattern_generator, formulation_generator, code_synthesizer, verification_feedback_interpreter, repair_agent
OptGraph introduces a GraphRAG-based multi-agent workflow for automated operations research modeling, translating natural language problem descriptions into executable solver code. Backed by strong empirical results, it achieves an average exact accuracy of 75.4% across six benchmarks (including NL4Opt and OptMATH), outperforming recent baselines like OptiTree and Lean-LLM-OPT by approximately 9%. The key insight is the use of a dynamic, heterogeneous graph memory that links problem variants, math models, code snippets and typical errors, which is adaptively updated with execution traces and validation feedback without requiring LLM fine-tuning.
2026-07-28 | JD.com Method: Solver-guided Large Language Model (LLM) framework for OR formulation selection, progressively post-trained with Supervised Fine-Tuning (SFT), Identity Preference Optimization (IPO) and Group Relative Policy Optimization (GRPO) | LLM role: selector
Xu et al. propose an LLM-based selector trained via SFT, IPO and GRPO to route multi-warehouse inventory allocation instances to the most suitable mixed-integer programming (MIP) formulation. Backed by real-world data from JD.com, the GRPO-trained selector improves top-1 expert selection accuracy by 29 percentage points over an SFT+IPO baseline, translating to a 12.5% allocation accuracy gain over the incumbent system. The key insight is the offline GRPO metadata construction: pre-computing and caching solver evaluations (scores, rankings, best expert) for historical instances to serve as fast, reliable reward signals during iterative RL post-training, which avoids expensive solver calls in the RL loop.
2026-07-23 | Xidian University, Victoria University of Wellington Method: LLM-based problem formulation with search hardness-aware evolutionary refinement | LLM role: formulation_generator, formulation_repairer, state_judge, evolutionary_operator
This paper proposes an LLM-based evolutionary framework to automatically generate and refine optimization problem formulations (objectives and constraints) for expensive simulation-driven design. The authors empirically demonstrate on a hydrology task and five antenna design benchmarks that their evolved formulations require significantly fewer expensive simulator evaluations to reach feasible designs compared to expert-designed or zero-shot LLM formulations. The key insight is using initial random simulation data to identify 'hard but promising' (rare and non-dominated) states and then using a candidate formulation's ability to prioritize these anchor states as the fitness signal for the evolutionary search. This is highly relevant for research in LLM evolutionary search and automated OR modeling, as it provides a concrete method for constructing proxy rewards that improve sample efficiency when evaluating generated code is computationally expensive.
2026-07-18 | Central University of Finance and Economics Method: Falsification-based verification using optimization theory (duality, comparative statics, polyhedral limits, symmetry) | LLM role: assertion_extractor
This paper introduces a falsification-based, oracle-free verification framework for LLM-generated optimization models using metamorphic tests derived from optimization theory. The results are rigorously backed by empirical evidence, achieving a 0.0% false-positive rate on faithful models compared to 54.9% for threshold-based baselines, while successfully detecting execution-blind errors across multiple benchmarks. The key insight is that classical optimization theory, such as value function convexity and shadow-price consistency, provides provably valid metamorphic relations that can verify generated models without requiring ground-truth labels.
2026-07-19 | ShanghaiTech University Method: Constrained Path Reasoning (CPR) framework with stage-level accounting and source-aware path hypothesis | LLM role: heuristic_generator, code_writer, decomposition_guide
This paper introduces Constrained Path Reasoning (CPR), a framework to quantify the utility versus computational cost of intermediate LLM reasoning stages (e.g., formalization, convexification) when solving non-convex optimization problems. Backed by rigorous experiments on over 1,100 QCQPs, the authors demonstrate that while formal transcription with a deterministic solver achieves 90% yield, adding an LLM-proposed convex surrogate drops yield to 20% due to relaxation leakage and over-contraction. The key insight is the use of classical error bounds to map constraint residuals into a continuous feedback signal for triage and local repair, which successfully recovers 63% of feasible yield using only 17% of the computational attempts.
2026-05-04 | Beihang University, JIUTIAN Research Method: Supervised Fine-Tuning followed by Segment-Weighted Group Relative Policy Optimization (GRPO) | LLM role: reasoning_guide
SAGE is a framework for automated optimization modeling that explicitly separates high-level modeling strategy from concrete formulation, training an LLM via supervised fine-tuning and Segment-Weighted GRPO with solver feedback. The results are backed by strong empirical evidence, improving average pass@1 from 72.7% to 80.3% over the strongest open-source baseline across eight OR benchmarks, while also producing more compact, solver-efficient constraint systems. The key insight is the use of Segment-Weighted GRPO, which assigns higher optimization weights to early, high-level strategic reasoning tokens than to later surface-level tokens, effectively mitigating the credit assignment problem in long-horizon reasoning.
2026-05-04 | Nanyang Technological University, The Chinese University of Hong Kong, Shenzhen, The University of Sydney, INSAIT Sofia University “St. Kliment Ohridski”, AIRS Method: Multi-agent system with a fully connected coordinator for iterative problem analysis, modeling, verification, solving and solution evaluation | LLM role: multi-role agent coordination
EngiAgent is a multi-agent LLM framework that uses a fully connected coordinator to dynamically route debugging feedback across specialized agents (Analyzer, Modeler, Verifier, Solver) to generate feasible Pyomo models for open-ended engineering problems. The results are strongly backed by empirical data on a new 53-problem benchmark, achieving up to 75.4% feasibility with DeepSeek-V3—a massive improvement over fixed-pipeline baselines like DS-Agent. The key insight is that rigid multi-agent pipelines fail on complex OR tasks because errors can stem from semantic extraction, mathematical formulation, or solver execution; dynamically routing specific error traces to the responsible agent significantly improves the rate of physically and mathematically feasible solutions.
2026-04-30 | Shanghai Institute of AI for Education, East China Normal University Method: Reinforcement-trained Qwen2.5 LLM with GRPO for relation-based surrogate modeling, using anchor-based iterative context construction and voting-based aggregation | LLM role: surrogate_model
This paper proposes R2SAEA, an evolutionary algorithm that uses a compact LLM (Qwen2.5) fine-tuned via GRPO as a zero-shot, relation-based surrogate model to rank offspring in expensive optimization problems. The results are rigorously backed by numerical experiments on standard continuous benchmarks (LZG, DTLZ), demonstrating that the fine-tuned model outperforms both traditional surrogate models and prompted frontier LLMs (GPT-4o) while running efficiently via quantization. The key insight is to cast surrogate evaluation as an in-context pairwise relation reasoning task, utilizing an anchor-based iterative prompt strategy to reduce $O(N^2)$ comparisons to $O(N)$ before aggregating them via voting. This is highly relevant for LLM evolutionary search; the team can adapt the GRPO relation-training pipeline and anchor-based voting mechanism to improve candidate evaluation and sample efficiency when evolving algorithms or heuristics.
2026-04-28 | Tsinghua University, University of Chicago Booth School of Business, Shanghai Jiao Tong University, The Chinese University of Hong Kong, Shenzhen (CUHK-Shenzhen) Method: Modular agentic framework combining decentralized debate with a read-write memory bank | LLM role: Formulator, Programmer and Debugger agents for generating and refining optimization models and solver code
This paper introduces Agora-Opt, a multi-agent framework for optimization modeling that combines decentralized debate across heterogeneous LLMs with a read-write memory bank. The results are backed by strong empirical evidence, achieving state-of-the-art Pass@1 accuracy (84.6%) across 7 OR benchmarks and outperforming both frontier zero-shot models and fine-tuned OR models. The key insight is that decentralized debate, where consensus is driven by solver-verified endpoints rather than a centralized LLM judge, can synthesize correct formulations even when all initial agent proposals are flawed. Furthermore, storing the trajectories of how these disagreements are resolved in a dedicated 'debate memory' allows the system to continuously improve its collaborative reasoning without parameter updates.
2026-04-23 | Xi'an Jiaotong University, Lenovo Research Method: Dual-View Auditor Agent (DVA-Agent) with Semantic Triangulation | LLM role: adversarial_evaluator
This paper introduces OptiVerse, a 1,000-problem benchmark spanning six optimization domains (including stochastic and dynamic optimization) to evaluate LLM reasoning, alongside a Dual-View Auditor Agent that detects semantic modeling errors. Extensive evaluation of 22 LLMs shows severe performance degradation on hard problems (under 27% accuracy even for frontier models), while the proposed agent improves accuracy by 1.3-6.3% over baselines like OptiMUS. The key insight is the 'blind code abstraction' technique: forcing the LLM to reverse-engineer mathematical logic solely from its generated code without seeing the original prompt, which effectively mitigates the confirmation bias that plagues standard LLM self-correction.
2026-04-22 | Xi’an Jiaotong University, Ministry of Education Key Laboratory of Intelligent Networks and Network Security, Shaanxi Province Key Laboratory of Big Data Knowledge Engineering Method: Dual-Cluster Memory Agent (DCM-Agent) with Dual-Cluster Memory Construction and Memory-Augmented Inference | LLM role: knowledge_synthesizer_code_generator_verifier
This paper introduces a training-free Dual-Cluster Memory Agent that resolves multi-paradigm ambiguity in optimization modeling by decoupling abstract mathematical modeling from concrete coding implementation into separate memory clusters linked by a bipartite graph. The results are backed by strong empirical evidence, showing 11-21% average accuracy improvements across 7 OR benchmarks (including OptiBench and NLP4LP) over baselines like OptiMUS and OptiTree, while reducing inference time compared to heavy tree-search methods. The key insight is the structured extraction of 'Pitfalls' from persistent failures and the resulting 'knowledge inheritance'—using a large model to build a high-quality bipartite memory graph allows smaller, cheaper models to achieve SOTA performance during inference.
2026-04-20 | Harbin Institute of Technology, Nanjing University of Information Science and Technology Method: Co-evolutionary framework using Activity-on-Edge (AOE) networks for agent architecture and reasoning trajectory evolution | LLM role: problem_interpreter, heuristic_generator, code_writer, decomposition_guide, evolutionary_search_operator, evaluator
Huang et al. propose EvoOR-Agent, a co-evolutionary framework that represents LLM agent workflows as Activity-on-Edge (AOE) networks to simultaneously evolve the agent's architectural topology and its reasoning trajectories for operations research tasks. The results are backed by strong empirical evidence, showing up to 17% improvement over fixed-pipeline OR agents and 15% over general evolutionary agents on complex benchmarks like IndustryOR and BWOR. The key insight is that abstracting agent workflows into an explicit, evolvable AOE graph allows for path-conditioned recombination and structural pruning, enabling the evolutionary search to optimize the problem-solving process (e.g., formulation decomposition, solver routing, debugging loops) rather than just the prompt text or final code.
2026-04-20 | The Chinese University of Hong Kong, Hong Kong University of Science and Technology, City University of Hong Kong, Peking University, Tsinghua University, University of California, Los Angeles, Shanghai Jiao Tong University Method: Pipeline-Adapted Reward Model (PARM) training with Direct Preference Optimization (DPO) for stage-wise candidate selection | LLM role: generator, evaluator
Fan et al. introduce a Pipeline-Adapted Reward Model (PARM) that trains stage-specific reward models for LLM optimization pipelines using Direct Preference Optimization on automatically collected execution feedback. The results are backed by strong empirical numbers, demonstrating that a 7B model pipeline can outperform GPT-4o on operations research benchmarks like NL4Opt (0.52 vs 0.15 solving accuracy). The key insight is that intermediate pipeline stages, such as problem formulation, can be effectively scored by training a reward model via DPO where preference pairs are automatically labeled based on whether any downstream execution succeeds.
2026-04-18 | X, University of Oxford Method: Reinforcement learning (GRPO) with scalable synthetic data generation and LoRA adapters | LLM role: code_writer
AutoOR trains an 8B LLM to autoformalize linear, mixed-integer and non-linear optimization problems using a scalable backtranslation data generation pipeline and GRPO with solver-execution rewards. The results are strongly backed by empirical evidence, showing the 8B model outperforming Gemini 2.5 Pro and matching Gemini 3 Pro across 9 benchmarks, including a leap from near 0% to 48.98% on a hard non-linear pump network task. The key insight is the backtranslation pipeline: by instantiating standard OR forms to guarantee ground-truth code and then generating natural language descriptions, the authors bypass the hard problem of verifying code generated from ambiguous text. Furthermore, their curriculum RL strategy—temporarily providing solver syntax as privileged information—successfully breaks the cold-start barrier in hard non-linear domains. This is a for work in OR benchmarking and LLM reasoning evaluation, as the data generation and solver-in-the-loop RL techniques directly address the scalability and verification bottlenecks in symbolic OR modeling.
2026-04-14 | Brown University, Fidelity Investments Method: LLM-based prompting strategies for MiniZinc model generation | LLM role: code_writer
This paper introduces Text2Zinc, a solver-agnostic benchmark of 1,775 natural language combinatorial problems and evaluates various LLM copilot strategies (CoT, knowledge graphs, grammar validation) for generating formal MiniZinc models. The results are backed by extensive empirical evaluation, demonstrating that even advanced models like GPT-4o struggle, achieving only ~40-50% solution accuracy despite much higher execution (compilation) accuracy. The key insight is that decoupling syntax enforcement from generation via post-hoc grammar validation significantly improves execution accuracy without requiring constrained decoding, though capturing the underlying optimization logic remains a major bottleneck.
2026-04-01 | Chinese Academy of Sciences, Nanjing University, Nanjing University of Science and Technology Method: Execution-Verified Reinforcement Learning (EVOM) with GRPO and DAPO for solver-conditioned code generation | LLM role: code_writer
EVOM trains LLMs for operations research modeling using execution-verified reinforcement learning (GRPO/DAPO) based solely on solver outcomes, bypassing expensive process-level supervision. The results are backed by solid empirical evaluations on OptiBench, NL4OPT and IndustryOR, demonstrating that it matches or beats process-supervised SFT (ORLM) and enables zero-shot transfer to new solvers (e.g., Gurobi to OR-Tools). The key takeaway is that outcome-only RL prevents the model from overfitting to solver-specific syntax (a major flaw in SFT), forcing it to learn invariant mathematical structures; additionally, their two-stage cold-start trick (LLM-translate 100 samples -> SFT -> RL) is a highly stealable technique for adapting to new environments.
2026-02-23 | Massachusetts Institute of Technology, Alibaba Group Method: Two-phase closed-loop LLM agent with IIS-guided diagnosis, domain-specific rationality oracle, iterative STaR and GRPO refinement | LLM role: diagnosis_and_repair
Ao et al. introduce OptiRepair, a closed-loop framework that repairs infeasible LPs using solver IIS feedback (Phase 1) and validates them with a 'Rationality Oracle' based on domain theory (Phase 2). Results are exceptionally strong: fine-tuned 8B models trained via iterative STaR and GRPO achieve 81.7% success, outperforming GPT-5.2 (42.2%) by a massive margin.
2026-02-17 | National University of Singapore, Northwestern University, City University of Hong Kong, Wenzhou University, Wenzhou Buyi Pharmacy Chain Co., Ltd. Method: Structured generation (underst and formalize, synthesize, verify) with two-layer behavioral verification (L1 execution recovery, L2 solver-based perturbation testing) and diagnosis-guided repair. | LLM role: code_writer
ReLoop proposes a verification pipeline for LLM-generated optimization models that detects 'silent failures' (code that runs but solves the wrong problem) by perturbing input parameters and checking for expected solver objective shifts. They demonstrate that standard execution feasibility is a poor proxy for correctness (90% gap) on their new RetailOpt-190 benchmark and that this perturbation testing significantly improves reliability.
Same pipeline, pointed at whatever you're working on — with relevance scored to how you read.
Request access →