Test-Time Scaling for CAD Generation via Verifier-Free Consensus Selection

Test-Time Scaling for CAD Generation via Verifier-Free Consensus Selection Aaron Haag aaron.haag@siemens.com

Altay Kaçan altay.kacan@siemens.com

Bertram Fuchs bertram.fuchs@siemens.com

Oliver Lohse oliver.lohse@siemens.com

arXiv:2608.09706v1 [cs.CE] 10 Aug 2026

Siemens AG, Foundational Technologies, Munich, Germany

Abstract Large language models can write parametric CAD programs from a naturallanguage description (text-to-CAD generation), but a single sample is often wrong. Increasing test-time compute by sampling multiple candidates only helps if a good candidate can be identified, yet no ground-truth model is available at generation time. Existing systems often require a separate verifier, such as a vision-language judge, to select among candidates. We investigate whether the candidate pool itself provides enough signal for effective selection and a verifier-free alternative. We introduce 3D CAD consensus selection, hereafter consensus selection: sample N parametric CAD programs, compile them to 3D models, and return the candidate that agrees most with the rest of the pool. The method is training-free and compatible with existing CAD agents. We investigate geometric and topological notions of agreement, each of which improves its corresponding evaluation metric. On the exact candidate pools of a state-of-the-art CAD generation method, geometric consensus improves all three geometric metrics over the method’s verifier, while topological consensus matches it on topology. Across every tested LLM and prompt variant, geometric consensus also improves geometric accuracy over random selection from the same pool, reducing Chamfer distance by 1–10%.

1

Introduction

Large language models can write parametric CAD programs from a natural-language description [Khan et al., 2024, Alrashedy et al., 2025, Guan et al., 2025], for example as executable parametric CAD code [CadQuery contributors]. A single sample, however, is often wrong: dimensions are inaccurate, features are missing, or the compiled shape does not match the prompt. A common mitigation strategy is to sample multiple candidates and select the most viable one. The open question is how to pick when there is no ground-truth model, no learned reward model, and no feedback loop that judges each candidate. Recent CAD systems use vision-language or reasoning models to evaluate and select generated candidates [Alrashedy et al., 2025, Preintner et al., 2025]. This introduces an additional modeldependent judgment whose decisions can be ambiguous or inconsistent. We therefore test whether agreement among generated 3D CAD models is sufficient for selection. Our method is based on consensus selection: we sample N programs from an LLM, compile them to 3D models, and select the candidate that agrees most with the rest of the pool. The idea that agreement between samples is a useful signal is well established for text and code [Kumar and Byrne, 2004, Wang et al., 2023, Shi et al., 2022]. CAD provides a natural domain for consensus because

each program compiles into an explicit 3D model. We define agreement using properties of these models, focusing on geometry and topology. We evaluate consensus selection in three steps. First, we apply it to the exact candidate pools of a state-of-the-art verifier-based CAD agent, so that any difference comes from selection alone. We then vary the pool size to measure its effect on selection quality. Finally, we evaluate the method using few-shot LLM sampling across several models and prompt variants. The method outperforms random selection for every tested model and prompt variant, with gains depending on the model. In all settings, an oracle over the same candidates is still clearly better, mirroring the gap between coverage and selection observed for repeated sampling in other domains [Brown et al., 2024]. Our contributions are: • We introduce consensus selection, a verifier-free inference-time selection method for LLMbased parametric 3D CAD generation. It defines consensus over properties of compiled 3D CAD models, specifically geometry and topology. It is training-free, requires no feedback loop, and can be integrated into existing CAD generation pipelines. • Using the exact candidate pools of a state-of-the-art verifier-based CAD agent, consensus selection improves all evaluated geometric metrics over the agent’s verifier, while matching it on topology. • We study test-time scaling with candidate-pool size and show how selection gains vary across LLMs and prompt variants.

2

Related work

Text-to-parametric-CAD generation. Early systems encode construction histories as specialized command sequences [Wu et al., 2021]; Text2CAD made them text-conditioned [Khan et al., 2024], followed by more controllable or language-driven variants [Zhang et al., 2025, Li et al., 2025, Wang et al., 2025]. Code-based methods instead exploit pretrained LLMs by emitting executable parametric CAD code [CadQuery contributors]. CadCodeVerify introduced the CADPrompt benchmark [Alrashedy et al., 2025]; Text-to-CadQuery [Xie and Ju, 2025] and CAD-Coder [Guan et al., 2025] fine-tune for this representation, and FutureCAD grounds textual references to B-Rep primitives [Li et al., 2026a]. Newer benchmarks test geometric complexity [Wang et al., 2026], engineering criteria [Dong et al., 2026], and drawing-conditioned generation and editing [Hugging Face, 2026]. We use CADPrompt throughout. Reconstruction methods can rank candidates against an input point cloud, mesh, or drawing [Rukhovich et al., 2025, Kolodiazhnyi et al., 2025], and vision-language models can emit CadQuery programs directly from images [Doris et al., 2026]; our text-only setting has no such reference. Verifier-based refinement and ranking. Feedback enters CAD generation either during training [Wang et al., 2025, Giannone et al., 2026] or at inference time. Most inference pipelines iteratively refine one program using rendered views [Yuan et al., 2024, Li et al., 2026b], reviewer or tool-using agents [Panta et al., 2025, Shui et al., 2026, Barkley et al., 2026, Mallis et al., 2025], or compiler, geometric, and simulation feedback [Badagabettu et al., 2024, Zhou et al., 2026a, Son et al., 2026, Berger et al., 2026, Liu et al., 2026]. CadCodeVerify, a baseline in Section 4.2, has a VLM generate and answer validation questions about a render. Closer to our setting, EvoCAD [Preintner et al., 2025] evolves a population using VLM descriptions and a reasoning-model ranker, motivated by evidence that VLMs can assess 3D assets well [Wu et al., 2024]. Such judges add model calls and can exhibit self-preference [Zheng et al., 2023, Panickssery et al., 2024], weak discrimination [West et al., 2024], over-optimization [Gao et al., 2023], or gaming [Zhou et al., 2026b]. CAD-Judge [Zhou et al., 2026b] instead uses the compiler to score Chamfer distance to a ground-truth solid, but therefore requires a reference unavailable at generation time. We use only agreement among the candidates. Minimum Bayes risk decoding over parallel samples. Our selection rule is an instance of minimum Bayes risk (MBR) decoding [Kumar and Byrne, 2004]: instead of the most probable output, MBR returns the candidate with the lowest expected loss against the output distribution, here approximated by the empirical distribution over the drawn samples [Eikema and Aziz, 2022, Bertsch et al., 2023]. The loss determines which kind of agreement is rewarded: a 0-1 loss over an equivalence relation reduces MBR to majority voting, as in self-consistency [Wang et al., 2023], 2

while a continuous metric returns the medoid of the pool. In program synthesis, program text is a poor equivalence class, since many distinct programs implement the same function. MBR-EXEC [Shi et al., 2022] resolves this by executing each sample and voting on execution results, and AlphaCode [Li et al., 2022] clusters candidates by execution behavior; universal self-consistency [Chen et al., 2023] instead delegates the grouping to an LLM, reintroducing a language-model judge. Search-based test-time compute [Yao et al., 2023] is orthogonal: consensus selection applies to whatever pool it produces. We take the same step as MBR-EXEC, with the CAD compiler as the interpreter: executing a program yields a 3D model, and agreement is measured over properties of that model rather than over program text or a VLM’s description of it. Compiled CAD models support both continuous geometric and discrete topological comparisons. We therefore instantiate both regimes, namely a continuous Chamfer loss giving a geometric medoid, and a 0-1 loss over Euler-characteristic classes giving a coarse topology-derived majority vote. Empirically, each performs best on the evaluation metric most closely aligned with its loss, consistent with the objective dependence of MBR. This mirrors MBR-EXEC’s use of execution semantics for code. The gap between our selection and an oracle over the same pool is analogous to the coverage-versus-selection gap in repeated sampling [Brown et al., 2024]: candidate pools often contain better solutions than an agreement-based rule recovers.

3

Method

In this section, we formally define the task of generating parametric 3D-CAD models from naturallanguage prompts and introduce 3D CAD consensus selection, a verifier-free method for selecting a final model from a set of LLM-generated candidates. Figure 1 gives an overview: given a prompt, we sample N candidate CAD programs from an LLM, compile them into 3D models, and select the candidate that agrees most with the rest of the pool. Natural language

N parametric CAD programs

3D CAD model pool

Consensus selection dij

Final CAD model

d¯i

“L-shaped bracket with a centered slotted hole. . . ” arg mini d¯i

Figure 1: Consensus selection for 3D CAD generation. We compile N sampled parametric CAD programs into 3D models and select one based on agreement in their 3D CAD model properties. Problem setting. The task is to generate a parametric CAD program c from a natural-language prompt p; a compiler ϕ converts the program into a 3D model ϕ(c) [Preintner et al., 2025] facilitating a direct comparison of properties of 3D models. The ground-truth object is not available at generation time, and the only input is the prompt. Instead of generating a single program, we sample N candidate programs c1 , . . . , cN independently from an LLM conditioned on p (Section 4 details our setup). Candidates that fail to compile are discarded, leaving a set of valid 3D models {Si = ϕ(ci ) | i ∈ V } with V ⊆ {1, . . . , N }. The goal is to select one model from this pool. Consensus selection. This method is based on the principle that correct features appear in many candidates, while individual mistakes are random. We therefore select the candidate that best agrees with the group. Specifically, for a distance function d, we choose the model with the lowest average distance to all others, X 1 i∗ = arg min d(Si , Sj ) . (1) i∈V |V | − 1 j∈V \{i}

We define this decision rule as consensus selection yielding the respective consensus candidate. Mathematically, this is minimum Bayes risk decoding with d as the loss function and a uniform distribution over the sampled candidates [Kumar and Byrne, 2004, Eikema and Aziz, 2022]. We apply this principle to continuous 3D geometry, where exact-match voting [Shi et al., 2022] is not possible. The choice of d determines what kind of agreement is rewarded, we use both geometric and topological distances. 3

Geometric consensus. For each model Si we sample a point cloud Pi ⊂ R3 uniformly from its surface; each pair of models is normalized and aligned with ICP beforehand. Geometric agreement between two models is measured by the symmetric Chamfer distance between their point clouds,   1 X 1 1 X dCD (Si , Sj ) = min ∥x − y∥2 + min ∥x − y∥2  , (2) y∈Pj x∈Pi 2 |Pi | |Pj | x∈Pi

y∈Pj

where x and y are points of Pi and Pj . With d = dCD , Equation (1) picks the candidate with the lowest average Chamfer distance to all other candidates, i.e., the geometrically most central model of the pool. Topological consensus. We also compare candidates by their topology, using the Euler characteristic χ(S) of the mesh (vertices minus edges plus faces; defined for watertight meshes), following EvoCAD [Preintner et al., 2025], who used it to evaluate the topology of generated CAD models. The topological distance between two models is  0 if χ(Si ) = χ(Sj ), dχ (Si , Sj ) = (3) 1 otherwise. With d = dχ , Equation (1) (computed over the watertight candidates) selects the candidate from the largest group of models with identical topology. Ties within this group are broken by the geometric consensus score, i.e., by Equation (1) with dCD . Properties. Consensus selection is training-free and model-agnostic, it requires only a compiler and O(|V |2 ) pairwise distance evaluations, and it makes no assumption about how the candidate pool was generated. It can therefore be applied on top of any existing generation pipeline; in Section 4 we apply it directly to the candidate populations of a verifier-based method.

4

Experiments

We evaluate consensus selection in three steps: a comparison with verifier-based selection on the original data of Preintner et al. [2025] (Section 4.2), the effect of the number of sampled candidates N (Section 4.3), and the behavior across different LLMs and prompt variants (Section 4.4). 4.1

Experimental setup

Benchmark. All experiments are based on the CADPrompt benchmark [Alrashedy et al., 2025], which contains 200 natural-language descriptions of CAD objects together with ground-truth models. Each description exists in two variants: with and without explicit measurements. Candidate generation. For the scaling and model-comparison experiments we generate candidate pools with the few-shot setup of EvoCAD [Preintner et al., 2025]: the LLM receives a short CadQuery introduction, five example programs drawn at random from EvoCAD’s pool of 40 few-shot examples, and the object description; sampling uses temperature 0.5, and the few-shot examples are re-drawn for every candidate. Generated programs are compiled to meshes, and candidates that fail to compile are discarded without any repair or self-debugging attempt. We generate 30 candidates per prompt for the models listed in Table 2. Verifier-based comparison data. For the comparison with verifier-based methods, we apply consensus selection directly to the original run data of Preintner et al. [2025]. The initial populations in this dataset contain six candidates per prompt; our consensus variants and the random baseline select from exactly this population. This ensures that any difference in results stems only from the selection strategy, as the underlying candidate pool remains identical. Metrics. We evaluate using Chamfer distance (CD, Equation 2), the 95th-percentile Hausdorff distance (HDD), and voxel IoU. For voxel IoU, we sample 10,000 points from each aligned mesh and convert them into a solid voxel grid with voxel size 0.1. We also report the absolute error in Euler characteristic (Terr ) and the percentage of correct topologies (Tcorr ). These topology metrics are 4

Table 1: Comparison with verifier-based methods on the CADPrompt benchmark [Alrashedy et al., 2025]. Bold denotes the best result among methods selecting from the same initial candidate pools. CadCodeVerify and full evolution are shown as references. Geometry (n = 197) CD ↓

Method

Reference methods CadCodeVerify [Alrashedy et al., 2025] 0.0657 EvoCAD (full evolution) [Preintner et al., 2025] 0.0634

Topology (n = 175)

HDD ↓ IoU ↑ Terr ↓ Tcorr (%) ↑ 0.191 0.180

Selection from shared watertight subsets of the initial pools Random selection 0.0631 0.183 EvoCAD verifier [Preintner et al., 2025] 0.0627 0.181 Ours (geometric consensus) 0.0610 0.176 Ours (topological consensus) 0.0611 0.177

0.684 0.629 0.688 0.350

80.6 88.3

0.693 0.695 0.703 0.700

82.1 84.8 83.5 84.9

0.542 0.484 0.518 0.465

only defined when both the ground truth and the selected candidate are watertight. Finally, we define coverage, defined as the percentage of prompts yielding at least one successfully compiled candidate. In the verifier comparison, geometric metrics cover all 200 prompts. The n column in Table 1 gives the number of prompts for which the topology metrics are defined. 4.2

Comparison with verifier-based selection

Table 1 compares consensus selection with the verifier of Preintner et al. [2025]. The controlled comparison uses the exact same initial EvoCAD populations. We also report the result after full evolution as a reference. Protocol. Random selection, the verifier, and both consensus variants select from the same watertight subset of each initial EvoCAD population. For the verifier, we select the highest-ranked watertight candidate. This differs from the original EvoCAD protocol, which did not restrict verifier selection to watertight candidates. All same-pool methods select from the same watertight candidates, as topological consensus would otherwise have an advantage by inherently selecting only watertight meshes. The published full-evolution output is included only as a reference. As evolution had already taken place in the authors’ data, full evolution did not benefit from watertight filtering at selection time. It also generates and evaluates additional candidates over multiple evolutionary generations, whereas the controlled methods select only from the initial candidate pools. Topology metrics require both the ground truth and the selected candidate to be watertight. Geometry is evaluated on the common output subset (n = 197) and topology on the common watertight subset (n = 175). Geometry. Both consensus variants improve all geometry metrics over verifier selection from the same candidate pool. Geometric consensus improves CD, HDD, and IoU over the verifier (all p ≤ 0.022). Topological consensus significantly improves CD and IoU over verifier-based selection (p = 0.003 and p = 0.035). Both consensus variants also obtain lower CD and higher IoU than full evolution. Topology. Topological consensus improves over random selection (Terr 0.542 to 0.465; Tcorr 82.1% to 84.9%). We detect no significant topology difference between topological consensus and verifier-based selection (p = 0.82 for Terr and p = 1.00 for Tcorr ). Full evolution is shown as a reference and obtains numerically better topology scores after generating additional candidates over multiple evolutionary generations. 4.3

Scaling with the number of sampled candidates

We next study how the benefit of consensus selection depends on the number of sampled candidates N . For this experiment we use the gpt-oss-20b pools on the prompts without explicit measurements (182 prompts for geometry metrics and 180 with a watertight ground truth for Tcorr ). For each N , we 5

sample 1000 candidate subsets of size N , resampling subsets without any watertight candidate. Every method is restricted to the watertight candidates within each sampled subset, as topological consensus would otherwise have an advantage by inherently selecting only watertight meshes. Random selects uniformly, whereas the oracle selects the best candidate for the considered metric. Figure 2 shows the result. Both consensus variants improve over random selection already at N =3 and saturate quickly, with little additional gain beyond N ≈ 9. The oracle keeps improving as the candidate pools contain better models than any agreement-based selection recovers. We observe that the choice of the selection criteria determines which metric improves: geometric consensus performs best in Chamfer distance for every N , while topological consensus achieves the highest Tcorr . This shows that consensus selection can be targeted to specific metrics by choosing the corresponding dissimilarity.

6.5 Tcorr (%) ↑

Mean Chamfer distance ↓

·10−2

6 5.5

90

80

5 1 3 5 7 9 11 13 15 17 Number of sampled candidates N

1 3 5 7 9 11 13 15 17 Number of sampled candidates N

Oracle (upper bound) Topological consensus (ours)

Geometric consensus (ours) Random selection

Figure 2: Scaling with the number of sampled candidates N (gpt-oss-20b, prompts without explicit measurements; 182 prompts for CD, 180 with watertight ground truth for Tcorr ). Left: mean Chamfer distance of the selected candidate (lower is better). Right: topology correctness Tcorr of the selected candidate (higher is better). All methods select from the watertight candidates of each subset. Shaded bands show ±1 standard deviation over the random subset draws. 4.4

Consensus selection across models

Finally, we apply the geometric consensus to the candidate pools of four models, each with both CADPrompt prompt variants (Table 2). We generate 30 candidates per prompt and evaluate selection at N =15 with 1000 random subsets per prompt. To keep the rows directly comparable, the CD columns are averaged over the common subset of n=125 prompts on which every model has at least three compiling candidates. Coverage and the number of compiling candidates are counted per model over all prompts. Consensus selection improves over random selection for every model and both prompt variants, but the size of the gain varies: the relative CD improvement is 8–10% for Gemma 3 12B and gpt-oss-20b, and only 1–3% for Gemini 3 Flash and Gemma 4. The stronger models produce better random picks, and prompts with explicit measurements generally lead to better geometry, albeit at slightly lower coverage. In all settings the oracle remains clearly better than the consensus candidate as it cannot exceed the best sampled candidate by construction.

6

Table 2: Consensus selection across models and prompt variants at N =15. Cov. and Cand. denote compilation coverage and mean candidate count.

5

Cov. (%)

Cand.

Random ↓

Ours ↓

Oracle ↓

w/ measurements w/o measurements

87.5 94.5

13.3 13.6

0.0650 0.0658

0.0596 0.0590

0.0423 0.0446

gpt-oss-20b gpt-oss-20b

w/ measurements w/o measurements

89.5 97.0

15.2 16.1

0.0562 0.0624

0.0515 0.0572

0.0409 0.0456

Gemma 4 Gemma 4

w/ measurements w/o measurements

98.5 100.0

22.3 23.5

0.0574 0.0616

0.0557 0.0608

0.0395 0.0458

Gemini 3 Flash Gemini 3 Flash

w/ measurements w/o measurements

97.0 99.0

26.1 22.7

0.0550 0.0607

0.0546 0.0592

0.0408 0.0479

Model

Prompt

Gemma 3 12B Gemma 3 12B

Discussion and limitations

In Section 4.2, consensus selection and the verifier select from identical candidate pools. Differences in performance therefore come only from the selection rule. Consensus selection performs better on all geometry metrics without using a vision or reasoning model for selection. On topology, we find no significant difference between topological consensus and the verifier. On our data, the Euler characteristic may be too coarse to provide a strong consensus signal. Across all tested models and prompt variants, consensus selection improves over random selection, but the gains vary. Consensus cannot help when all candidates are identical. It can also fail when the same error appears in most candidates because that error becomes part of the consensus. Moreover, consensus favors candidates near the center of the pool and may miss a high-quality outlier. This helps explain the gap to the oracle in Figure 2. Future work could preserve or further evaluate outliers alongside the consensus candidate. Our criteria compare candidates at the level of the complete 3D model. Geometric consensus normalizes and aligns the models before comparison. Absolute dimensions therefore do not affect selection, even when they are specified in the prompt. Small local features may also be hard to distinguish with a global distance. To better capture such features, future work could compare candidates at the feature or region level. Consensus selection could also extend beyond geometry and topology. Other criteria could use dimensions, manufacturability, or results from engineering simulations. Another possibility is to create a new CAD model from features shared by several candidates. This would combine candidates instead of selecting only one. Another direction concerns how candidates are generated. We currently sample all candidates in parallel. Whether consensus can also be formed across sequential refinements of a single parametric CAD program remains open.

6

Conclusion

In this work, we introduced and comprehensively evaluated 3D CAD consensus selection for parametric CAD generation. The method samples N programs from an LLM, compiles them into 3D CAD models, and selects the candidate that agrees most with the rest of the pool. Selection by agreement is well established for text and code. In CAD, consensus can be measured directly over properties of the compiled models. We use geometry and topology, however, alternative CAD model properties, such as outcomes from engineering simulations, could be analogously integrated. On the exact candidate pools of a state-of-the-art verifier-based agent, geometric consensus improves all evaluated geometry metrics over the verifier. Regarding topology, we found no significant difference between topological consensus and the verifier. Across all tested models and prompt variant, geometric consensus also improves over random selection. Our results show that the gains depend on the property used to define consensus. The method is training-free and can be integrated into existing CAD generation pipelines. CAD verifiers used for candidate selection should therefore be compared against consensus selection on the same candidate pool.

7

References Kamel Alrashedy, Pradyumna Tambwekar, Z. Zaidi, Megan Langwasser, Wei Xu, and Matthew C. Gombolay. Generating CAD code with vision-language models for 3D designs. In International Conference on Learning Representations, pages 52236–52262, 2025. doi: 10.48550/arxiv.2410. 05340. Akshay Badagabettu, Sai Sravan Yarlagadda, and Amir Barati Farimani. Query2CAD: Generating CAD models using natural language queries. arXiv preprint arXiv:2406.00144, 2024. doi: 10.48550/arxiv.2406.00144. Jesse Barkley, Rumi Loghmani, and Amir Barati Farimani. CADSmith: Multi-agent CAD generation with programmatic geometric validation. arXiv preprint arXiv:2603.26512, 2026. doi: 10.48550/ arxiv.2603.26512. Elias Berger, Muhammad Usama, Jan Mehlstäubl, Bernhard Saske, and Kristin Paetzold-Byhain. Physics-in-the-loop: A hybrid agentic architecture for validated CAD engineering design. arXiv preprint arXiv:2605.19717, 2026. doi: 10.48550/arxiv.2605.19717. Amanda Bertsch, Alex Xie, Graham Neubig, and Matthew Gormley. It’s MBR all the way down: Modern generation techniques through the lens of minimum Bayes risk. In Proceedings of the Big Picture Workshop, pages 108–122, 2023. doi: 10.18653/v1/2023.bigpicture-1.9. Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoc V. Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Scaling inference compute with repeated sampling. arXiv preprint arXiv:2407.21787, 2024. doi: 10.48550/arxiv.2407.21787. CadQuery contributors. CadQuery: A Python parametric CAD scripting framework. https: //github.com/CadQuery/cadquery. Xinyun Chen, Renat Aksitov, Uri Alon, Jie Ren, Kefan Xiao, Pengcheng Yin, Sushant Prakash, Charles Sutton, Xuezhi Wang, and Denny Zhou. Universal self-consistency for large language model generation. arXiv preprint arXiv:2311.17311, 2023. doi: 10.48550/arxiv.2311.17311. Xiaoyu Dong, Zhi Li, and Xiao-Ming Wu. MUSE: Benchmarking manufacturable, functional, and assemblable text-to-CAD generation. arXiv preprint arXiv:2605.28579, 2026. doi: 10.48550/arxiv. 2605.28579. Anna C Doris, Md Ferdous Alam, Amin Heyrani Nobari, and Faez Ahmed. CAD-Coder: An opensource vision-language model for computer-aided design code generation. Journal of Mechanical Design, 148(7):071702, 2026. doi: 10.1115/1.4071305. Bryan Eikema and Wilker Aziz. Sampling-based approximations to minimum Bayes risk decoding for neural machine translation. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pages 10978–10993, 2022. doi: 10.18653/v1/2022.emnlp-main.754. Leo Gao, John Schulman, and Jacob Hilton. Scaling laws for reward model overoptimization. In International Conference on Machine Learning, pages 10835–10866, 2023. doi: 10.48550/arxiv. 2210.10760. Giorgio Giannone, Anna C. Doris, Amin Heyrani Nobari, Kai Xu, Akash Srivastava, and Faez Ahmed. GIFT: Bootstrapping image-to-CAD program synthesis via geometric feedback. In International Conference on Machine Learning, 2026. doi: 10.48550/arxiv.2603.27448. Yandong Guan, Xilin Wang, Ximing Xing, Jing Zhang, Dong Xu, and Qian Yu. CAD-Coder: Text-toCAD generation with chain-of-thought and geometric reward. In Neural Information Processing Systems, 2025. doi: 10.48550/arxiv.2505.19713. URL https://openreview.net/forum?id= QoiFdfZUJv. Hugging Face. CADGenBench: A benchmark for AI-driven CAD generation and editing. https: //github.com/huggingface/cadgenbench, 2026. Accessed 2026-08-03.

8

Mohammad Sadil Khan, Sankalp Sinha, T. Sheikh, Didier Stricker, Sk Aziz Ali, and Muhammad Zeshan Afzal. Text2CAD: Generating sequential CAD designs from beginner-to-expert level text prompts. In Neural Information Processing Systems, volume 37, pages 7552–7579, 2024. doi: 10.52202/079017-0242. Maksim Kolodiazhnyi, Denis Tarasov, Dmitrii Zhemchuzhnikov, Alexander Nikulin, Ilya Zisman, Anna Vorontsova, Anton Konushin, Vladislav Kurenkov, and Danila Rukhovich. cadrille: Multimodal CAD reconstruction with reinforcement learning. arXiv preprint arXiv:2505.22914, 2025. doi: 10.48550/arxiv.2505.22914. Shankar Kumar and W. Byrne. Minimum Bayes-risk decoding for statistical machine translation. In North American Chapter of the Association for Computational Linguistics, pages 169–176, 2004. Jiahao Li, Weijian Ma, Xueyang Li, Yunzhong Lou, Guichun Zhou, and Xiangdong Zhou. CADLlama: Leveraging large language models for computer-aided design parametric 3D model generation. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 18563–18573, 2025. doi: 10.1109/cvpr52734.2025.01730. Jiahao Li, Qingwang Zhang, Qiuyu Chen, Guozhan Qiu, Yunzhong Lou, and Xiangdong Zhou. Towards high-fidelity CAD generation via LLM-driven program generation and text-based B-rep primitive grounding. In International Conference on Machine Learning (ICML), 2026a. doi: 10.48550/arxiv.2603.11831. Xueyang Li, Jiahao Li, Yu Song, Yunzhong Lou, and Xiangdong Zhou. Seek-CAD: A self-refined generative modeling for 3D parametric CAD using local inference via DeepSeek. In International Conference on Learning Representations (ICLR), 2026b. doi: 10.48550/arxiv.2505.17702. Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, Thomas Hubert, Peter Choy, Cyprien de Masson d’Autume, Igor Babuschkin, Xinyun Chen, Po-Sen Huang, Johannes Welbl, Sven Gowal, Alexey Cherepanov, James Molloy, Daniel J Mankowitz, Esme Sutherland Robson, Pushmeet Kohli, Nando de Freitas, Koray Kavukcuoglu, and Oriol Vinyals. Competition-level code generation with AlphaCode. Science, 378(6624):1092–1097, 2022. doi: 10.1126/science.abq1158. Fumin Liu, Haoyu Zhou, Fei Hao, and Lin Yang. Embodied CAD: Solver-grounded LLM agents for parametric B-rep assembly modeling. arXiv preprint arXiv:2606.31252, 2026. doi: 10.48550/ arxiv.2606.31252. Dimitrios Mallis, Ahmet Serdar Karadeniz, Sebastian Cavada, D. Rukhovich, N. Foteinopoulou, K. Cherenkova, Anis Kacem, and D. Aouada. CAD-Assistant: Tool-augmented VLLMs as generic CAD task solvers. In IEEE International Conference on Computer Vision, pages 7284–7294, 2025. doi: 10.1109/iccv51701.2025.00684. Arjun Panickssery, Samuel R. Bowman, and Shi Feng. LLM evaluators recognize and favor their own generations. arXiv preprint arXiv:2404.13076, 2024. doi: 10.48550/arxiv.2404.13076. Nirmal Panta, Saugat Kafley, Rujal Acharya, Sashank Parajuli, Dikshya Parajuli, Prince Panta, Saroj Belbase, Sudikshya Pant, Amit Regmi, Akio Tanaka, and Christopher McComb. MEDA: A multi-agent system for parametric CAD model creation. In Volume 3B: 51st Design Automation Conference (DAC), number V03BT03A042, 2025. doi: 10.1115/detc2025-163946. Tobias Preintner, Weixuan Yuan, Adrian König, Thomas Bäck, Elena Raponi, and Niki van Stein. EvoCAD: Evolutionary CAD code generation with vision language models. In 2025 IEEE 37th International Conference on Tools with Artificial Intelligence (ICTAI), pages 504–511, 2025. doi: 10.1109/ictai66417.2025.00075. D. Rukhovich, Elona Dupont, Dimitrios Mallis, K. Cherenkova, Anis Kacem, and D. Aouada. CADRecode: Reverse engineering CAD code from point clouds. In IEEE International Conference on Computer Vision, pages 9801–9811, 2025. doi: 10.1109/iccv51701.2025.00914. Freda Shi, Daniel Fried, Marjan Ghazvininejad, Luke Zettlemoyer, and Sida I. Wang. Natural language to code translation with execution. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pages 3533–3546, 2022. doi: 10.18653/v1/2022. emnlp-main.231. 9

Yuan Shui, Yandong Guan, Zhanwei Zhang, Juncheng Hu, Jing Zhang, Dong Xu, and Qian Yu. ArtiCAD: Articulated CAD assembly design via multi-agent code generation. arXiv preprint arXiv:2604.10992, 2026. doi: 10.48550/arxiv.2604.10992. Guijin Son, Jehyun Park, Seyeon Park, Sunghee Ahn, and Youngjae Yu. Self-improving CAD generation agents with finite element analysis as feedback. arXiv preprint arXiv:2605.17448, 2026. doi: 10.48550/arxiv.2605.17448. Liang Wang, Heng Meng, Zekai Xiang, Jin Liu, Pingyi Zhou, Litao Chen, and Yongqiang Tang. Text2CAD-Bench: A benchmark for LLM-based text-to-parametric CAD generation. arXiv preprint arXiv:2605.18430, 2026. doi: 10.48550/arxiv.2605.18430. Ruiyu Wang, Yu Yuan, Shizhao Sun, and Jiang Bian. Text-to-CAD generation through infusing visual feedback in large language models. In International Conference on Machine Learning, pages 65326–65345, 2025. doi: 10.48550/arxiv.2501.19054. Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In International Conference on Learning Representations, 2023. doi: 10.48550/arxiv. 2203.11171. Peter West, Ximing Lu, Nouha Dziri, Faeze Brahman, Linjie Li, Jena D. Hwang, Liwei Jiang, Jillian R. Fisher, Abhilasha Ravichander, Khyathi Raghavi Chandu, Benjamin Newman, Pang Wei Koh, Allyson Ettinger, and Yejin Choi. The generative AI paradox: “what it can create, it may not understand”. In International Conference on Learning Representations, 2024. doi: 10.48550/arxiv.2311.00059. Rundi Wu, Chang Xiao, and Changxi Zheng. DeepCAD: A deep generative network for computeraided design models. In 2021 IEEE/CVF International Conference on Computer Vision (ICCV), pages 6752–6762, 2021. doi: 10.1109/iccv48922.2021.00670. Tong Wu, Guandao Yang, Zhibing Li, Kai Zhang, Ziwei Liu, Leonidas J. Guibas, Dahua Lin, and Gordon Wetzstein. GPT-4V(ision) is a human-aligned evaluator for text-to-3D generation. In Computer Vision and Pattern Recognition, pages 22227–22238, 2024. doi: 10.1109/cvpr52733. 2024.02098. Haoyang Xie and Feng Ju. Text-to-CadQuery: A new paradigm for CAD generation with scalable large model capabilities. arXiv preprint arXiv:2505.06507, 2025. doi: 10.48550/arxiv.2505.06507. Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, T. Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. In Neural Information Processing Systems, 2023. doi: 10.48550/arxiv.2305.10601. Zeqing Yuan, Haoxuan Lan, Qiang Zou, and Junbo Zhao. 3D-Premise: Can large language models generate 3D shapes with sharp features and parametric control? arXiv preprint arXiv:2401.06437, 2024. doi: 10.48550/arxiv.2401.06437. Zhanwei Zhang, Shizhao Sun, Wenxiao Wang, Deng Cai, and Jiang Bian. FlexCAD: Unified and versatile controllable CAD generation with fine-tuned large language models. In International Conference on Learning Representations, 2025. doi: 10.48550/arxiv.2411.05823. Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, E. Xing, Hao Zhang, Joseph E. Gonzalez, and Ion Stoica. Judging LLM-as-a-judge with MT-bench and chatbot arena. In Neural Information Processing Systems, 2023. doi: 10.52202/075280-2020. Jiwei Zhou, Jorge D. Camba, and Pedro Company. CADialogue: A multimodal LLM-powered conversational assistant for intuitive parametric CAD modeling. Computer-Aided Design, 191 (104006):104006, 2026a. doi: 10.1016/j.cad.2025.104006. Zheyuan Zhou, Jiayi Han, Liang Du, Naiyu Fang, Lemiao Qiu, and Shuyou Zhang. CAD-Judge: Toward efficient morphological grading and verification for text-to-CAD generation. In ICASSP 2026 - 2026 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 1021–1025, 2026b. doi: 10.1109/icassp55912.2026.11461978. 10

Related documents

• X-CAD: Optimizing CAD Models with Extended Finite Elements#254447
• Teaching LLMs to Generate Challenging MILP Instances via Solver Feedback#1141679
• Argonaut: Interactive Visual Exploration for Distributed Optimization#414080
• Auditing and Decomposing Feedback-Driven Evolution in LLM Test Generation under the Oracle Problem#471312
• Accelerating structural optimization via EIFEM: a ROM-based preconditioner#1033832