Modeling Copilots: Large Language Models for Text-to-Model Translation

Modern solvers for combinatorial satisfaction and optimization problems have become extraordinarily capable. Still, adopting them requires a difficult translation: someone must turn an informal real-world problem into variables, objectives, constraints, and data definitions. Even when high-level modeling languages and powerful solver technologies are available, this modeling step remains a major bottleneck.

Large language models (LLMs) offer a new interface between informal problem descriptions and the algorithmic machinery used to solve combinatorial problems. The ambition is to move beyond solver-centered tools, which expect users to work directly in a mathematical or programming formalism, toward human-centered copilots that mediate among domain knowledge, formal models, algorithms, and computational feedback.

This article develops the modeling-copilots portion of the IJCAI 2026 tutorial “LLM-Con: Large Language Models for Constraint Modelling.”¹ The complete tutorial also introduces the broader field, connects model generation with LLMs for algorithm design, and examines datasets, benchmarks, evaluation techniques and common methodological pitfalls. Here, we focus on text-to-model translation and six themes that are shaping the emerging architecture of modeling copilots.

Vision and Position Papers

Early position papers frame LLM-based modeling as a shift from solver-centric tools toward human-centric interfaces that mediate between domain knowledge and mathematical formalism. The Decision Optimization Copilot manifesto of Wasserkrug et al.² articulates this vision in terms of problem understanding, formal translation, tuning, solving, and validation. Lawless et al.³ complement this system-level view with evidence from optimization practitioners, showing that real modeling workflows depend not only on algorithms, but also on iterative elicitation, data work, stakeholder dialogue, and trust.

From an enterprise perspective, Simchi-Levi et al.⁴ argue that generative and agentic AI can substantially broaden access to optimization, shortening modeling cycles while simultaneously increasing the need for formal guardrails. Tsouros et al.⁵ revisit the classical “Holy Grail” vision for constraint programming and outline an early LLM-enabled pipeline that moves from entity extraction and relation identification to formal specification, executable code, and iterative debugging. Together, these works motivate modeling copilots as interactive systems that support the full formulation lifecycle rather than as one-shot code generators.

Text-to-Model Translation

Text-to-model translation has received the most direct attention in work on LLMs for combinatorial modelling. A formal definition of the text-to-model translation task is provided in Kadıoğlu et al.⁶ Existing approaches address complementary parts of the translation pipeline, including structural extraction and evaluation, domain-specific adaptation, workflow decomposition, verification-guided generation, and interaction with users.

Foundations and Performance Baselines

A first technical challenge is constructing faithful intermediate representations from language specifications. LATEX2SOLVER⁷ uses hierarchical parsing to preserve relationships among document sections, prose, symbols, and mathematical expressions before generating solver code. 

Alternatively, NER4OPT⁸ introduces an optimization-specific named-entity recognition schema for identifying parameters, decision variables, objectives, constraints, and bounds. Both approaches suggest that explicit structural extraction can reduce errors, omissions, and symbol ambiguity during synthesis.

A parallel line of research establishes empirical baselines for LLM modeling ability. 

DCP-BENCH-OPEN⁹ evaluates generated constraint models across multiple modeling systems and exposes a substantial gap between executable output and correct formulations. Michailidis et al.¹⁰ study in-context learning as a training-free alternative, showing how demonstrations and modeling-system documentation can improve constraint-model generation. 

TEXT2ZINC¹¹ broadens evaluation across satisfaction and optimization problems using MINIZINC as a solver-independent target language and explicitly separates abstract problem logic from instance data. 

TEXT2MODEL¹² introduces a suite of modeling copilots spanning prompting, intermediate representation, grammar guided, and agentic strategies for translating natural-language specifications into paradigm- and solver-agnostic MINIZINC models, with TEXT2ZINC serving as its principal evaluation benchmark.

Figure 1. Text2Model copilots leveraging the Text2Zinc dataset (Kadıoğlu et al., 2026).

Figure 1 presents the TEXT2MODEL architecture for creating copilots to address the text-to-model translation problem. This blueprint is partially inspired by the Holy Grail 2.0¹³ approach. In the literature there exist various strategies that leverage the strengths of LLMs and intermediate representations. The pipeline described by Kadıoğlu et al.¹⁴ leverages the TEXT2ZINC dataset.

At a high level, given the input, data pair, and an LLM, potentially with external information (e.g., provided by a knowledge graph or NER4OPT), modeling copilots generate a constraint model, which is then checked for executability and evaluated for solution accuracy. The output is evaluated for execution and solution accuracy. The feedback loop enables multi-call strategies, where potential errors are resurfaced back to the LLM in subsequent cycles.

Fine-Tuning and Synthetic Data

Because declarative modeling languages are sparsely represented in general-purpose pretraining corpora, several works investigate domain-specific adaptation. ORLM¹⁵ introduces the OR-INSTRUCT data-synthesis framework and fine-tunes open models for automated optimization modeling. Lima et al.¹⁶ begin instead with structured symbolic representations and generate verifiable natural-language, formulation, and code tuples. Their OPTITRUST agent uses this data in a modular, solver-checked modeling workflow.

LEARN2ZINC¹⁷ examines whether small open-weight models can learn MINIZINC despite negligible prior exposure to the language. Cross-model error bootstrapping and compiler-error correction produce large improvements in execution accuracy, but the remaining solution-accuracy gap indicates that learning syntax does not by itself provide constraint reasoning. 

OPTIMIND¹⁸ incorporates operations-research expertise through problem-class identification, class-specific error analysis, data cleaning, supervised fine-tuning, and error-aware inference. These results highlight both the value of domain-specific adaptation and the need to preserve capabilities across modeling languages and solver interfaces.

Structured Workflows and Multi-Agent Systems

As specifications become longer and more complex, one-shot generation becomes increasingly prone to dropped constraints, inconsistent indexing, and parameter-scope errors. Liang et al.¹⁹ address industrial-scale auto-formulation through a structured workflow that separates schema extraction, atomic rule translation, constraint assembly, and validation. Their approach illustrates the value of treating entity and data-schema design as distinct from logical formulation.

OPTIMUS-0.3²⁰ replaces monolithic prompting with a modular architecture and persistent connection graph, allowing formulation, code generation, evaluation, and correction to proceed over long descriptions without placing the full workflow in a single prompt. CHAIN-OF-EXPERTS21 similarly decomposes auto-formulation across role-specific experts coordinated by an orchestrator. GALA22 adopts a decomposition grounded more directly in constraint-programming structure: individual agents detect and encode particular global constraints, while an assembler integrates their outputs into a complete MINIZINC model. Whereas broader multi-agent systems divide work by modeling stage or the role of an expert, GALA divides it by formal global constraint type.

Search, Verification, and Ensembling

Another line of work treats formulation as an iterative search process in which execution supplies an external correctness signal. CP-AGENT²³ uses a ReAct-style agent with persistent execution state to formulate, test, debug, and verify constraint models without a fixed modeling pipeline. Astorga et al.²⁴ formulate auto-formulation as Monte Carlo tree search over alternative modeling decisions, permitting explicit exploration and backtracking instead of committing to one autoregressive trajectory.

LLMOPT²⁵ combines a five-element intermediate representation, as in NER4OPT,²⁶ with instruction tuning, preference-based alignment, automated testing, and self-correction. These systems demonstrate the value of coupling probabilistic generation with exact computational feedback, although successful execution alone does not establish that a generated model faithfully captures its source specification.

Human-in-the-Loop Modeling and Post-Solution Interaction

Reliable modeling copilots must also account for preferences and constraints that are incomplete at the beginning of a modeling process. Lawless et al.²⁷ combine an LLM with constraint programming to translate free-form feedback on candidate meeting schedules into iteratively refined preferences and constraints. Their studies show how interaction can support preference construction rather than merely collect a fixed set of requirements.

Finally, OPTICHAT²⁸ extends the role of an LLM beyond formulation to model interpretation, infeasibility diagnosis, sensitivity analysis, and counterfactual explanation. Such post-solution capabilities make optimization models more inspectable to non-specialists and address the concerns about transparency and stakeholder trust raised by the early vision papers.

Looking Ahead

Overall, robust text-to-model translation requires more than direct natural-language-to-code generation. Structural representations, domain adaptation, task decomposition, solver-grounded verification, and iterative user interaction address different sources of failure and together define the emerging architecture of modeling copilots.

References

1. Guns, T., Tsouros, D., and Kadıoğlu, S., 2026, “LLMs for Constraint Modeling,” IJCAI26 tutorial, https://doi.org/10.5281/zenodo.21998210.
2. Wasserkrug, S., Boussioux, L., den Hertog, D., Mirzazadeh, F., Birbil, I., Kurtz, J., and Maragno, D., 2024, “From Large Language Models and Optimization to Decision Optimization CoPilot: A Research Manifesto,” https://arxiv.org/abs/2402.16269.
3. Lawless, C., Schoeffer, J., and Udell, M., 2025, “‘It Was a Magical Box’: Understanding Practitioner Workflows and Needs in Optimization,” https://arxiv.org/abs/2509.16402.
4. Simchi-Levi, D., Dai, T., Menache, I., and Wu, M. X., 2025, “Democratizing Optimization with Generative AI,” Johns Hopkins Carey Business School Research Paper Forthcoming
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5511218.
5. Tsouros, D., Verhaeghe, H., Kadıoğlu, S., and Guns, T., 2023, “Holy Grail 2.0: From Natural Language to Constraint Models,” https://arxiv.org/abs/2308.01589.
6. Kadıoğlu, S., Uppuluri, K., and Singirikonda, A., 2025, “Text2Model: Modeling Copilots for Text-to-Model Translation,” https://arxiv.org/abs/2604.12955.
7. Ramamonjison, R., Yu, T., Xing, L., Mostajabdaveh, M., Li, X., Fu, X., Han, X., Chen, Y., Li, R., Mao, K., and Zhang, Y., 2023, “LaTeX2Solver: a Hierarchical Semantic Parsing of LaTeX Document into Code for an Assistive Optimization Modeling Application,” in Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics,” Volume 3: System Demonstrations, pp. 471–478, Association for Computational Linguistics, https://aclanthology.org/2023.acl-demo.45/.
8. Kadıoğlu, S., Dakle, P. P., Uppuluri, K., Politi, R., Raghavan, P., Rallabandi, S., and Srinivasamurthy, R., 2024, “Ner4Opt: Named Entity Recognition for Optimization Modelling from Natural Language,” Constraints, Vol. 29, Issue 3, pp. 261–299, https://dl.acm.org/doi/abs/10.1007/s10601-024-09376-5. 
9. Michailidis, K, Tsouros, D., and Guns, T., 2026, “DCP-Bench-Open: Evaluating LLMs for Constraint Modelling of Discrete Combinatorial Problems,” https://arxiv.org/abs/2506.06052.
10. Michailidis, K., Tsouros, D, and Guns, T., 2024, “Constraint Modelling with LLMs Using In-Context Learning,” in 30th International Conference on Principles and Practice of Constraint Programming, Leibniz International Proceedings in Informatics (LIPIcs), Vol, 307, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024).
11. Singirikonda, A., Kadıoğlu, S., and Uppuluri, K., 2025, “Text2Zinc: A Cross-Domain Dataset for Modeling Optimization and Satisfaction Problems in MiniZinc,” https://arxiv.org/abs/2503.10642.
12. See note 6.
13. See note 5.
14. See note 6.
15. Huang, C., Tang, Z., Hu, S., Jiang, R., Zheng, X., Ge, D. D., Wang, B., and Wang, Z., 2025, “ORLM: A Customizable Framework in Training Large Models for Automated Optimization Modeling,” INFORMS Operations Research, Vol. 73, No. 6, pp. 2986–3009, https://ideas.repec.org/a/inm/oropre/v73y2025i6p2986-3009.html. 
16. Lima, V., Phan, D. T., Kalagnanam, J., Patel, D., and Zhou, N., 2025, “Toward a Trustworthy Optimization Modeling Agent via Verifiable Synthetic Data Generation,” https://arxiv.org/abs/2508.03117.
17. Kadıoğlu, S., Uppuluri, K., 2026, “Learn2Zinc: Fine-tuning Small Language Models for Text-to-Model Translation in MiniZinc,” https://arxiv.org/abs/2607.20456.
18. Zhang, X., Chen, Z., Zope, H., Barbalho, H., Mellou, K., Molinaro, M., Kulkarni, Ishai Menache, J., and Li, S., 2026, “OptiMind: Teaching LLMs to Think Like Optimization Experts,” https://arxiv.org/abs/2509.22979.
19. Liang, K., Lu, Y., Mao, J., Sun, S., Yang, C., Zeng, C., Jin, X., Qin, H., Zhu, R., and Teo, C., 2026, “Large-Scale Optimization Model Auto-Formulation: Harnessing LLM Flexibility via Structured Workflow,” https://arxiv.org/abs/2601.09635.
20. AhmadiTeshnizi, A., Gao, W., Brunborg, H., Talaei, S., Lawless, C., and Udell, M., 2026, “OptiMUS-0.3: Using Large Language Models to Model and Solve Optimization Problems at Scale, https://arxiv.org/abs/2407.19633.
21. Xiao, Z., Zhang, D., Wu, Y., Xu, L., Wang, Y., J., Han, X., Fu, X., Zhong, T., Zeng, J., Song, M., and Chen, G., 2024, “Chain-of-Experts: When LLMs Meet Complex Operations Research Problems,” in The Twelfth International Conference on Learning Representations,” https://openreview.net/forum?id=HobyL1B9CZ.
22. Cai, J., Kadıoğlu, S., and Dilkina, B., 2025, “Gala: Global LLM Agents for Text-to-Model Translation,” https://arxiv.org/abs/2509.08970.
23. Szeider, S., 2026, “CP-Agent: Agentic Constraint Programming,” Association for Computing Machinery, https://arxiv.org/abs/2508.07468.
24. Astorga, N., Liu, T., Xiao, Y., and van der Schaar, M., 2025, “Autoformulation of Mathematical Optimization Models Using LLMs,” https://arxiv.org/abs/2411.01679.
25. Jiang, C., Shu, X., Qian, H., Lu, X., Zhou, J., Zhou, A., and Yu, Y., 2025, “LLMOPT: Learning to Define and Solve General Optimization Problems from Scratch,” International Conference on Learning Representations, https://arxiv.org/abs/2410.13213.
26. See note 8. 
27. Lawless, C., Schoeffer, J., Le, L., Rowan, K., Sen, S.., St. Hill, C., Suh, J., and Sarrafzadeh, B., 2024, “‘I Want It That Way’: Enabling Interactive Decision Support Using Large Language Models and Constraint Programming,” ACM Transactions on Interactive Intelligent Systems, Vol. 14, No. 3, https://arxiv.org/abs/2312.06908.
28. Chen, H., Constante-Flores, G. E., Mantri, K. S. I., Kompalli, S. M., Ahluwalia, A. S., and Li, C., 2025, “OptiChat: Bridging Optimization Models and Practitioners with Large Language Models,” INFORMS Journal on Data Science, Vol. 5, No. 3, https://arxiv.org/abs/2501.08406. 

Resources

• IJCAI 2026 LLM-Con tutorial and slides: https://sites.google.com/view/ijcai26-llm-con
• Text2Model suite and supporting material: https://skadio.github.io/text2model/