Zero-to-CAD: Agentic Synthesis of Interpretable CAD Programs at Million-Scale Without Real Data

Mohammadmehdi Ataei; Farzaneh Askari; Kamal Rahimi Malekshan; Pradeep Kumar Jayaraman

Source-linked AI summary

Zero-to-CAD: Agentic Synthesis of Interpretable CAD Programs at Million-Scale Without Real Data

Mohammadmehdi Ataei, Farzaneh Askari, Kamal Rahimi Malekshan, Pradeep Kumar Jayaraman

arXiv:2604.24479v1Apr 27, 2026cs.CV

TL;DR

Existing CAD datasets largely omit editable construction histories or cover only simple operations, limiting sequence-centric CAD data. Zero-to-CAD synthesizes executable sequences with agentic LLM feedback and enables image-to-sequence reconstruction, reaching 82.1% success and 0.747 mean IoU.

Problem
Large-scale CAD datasets mainly provide B-Reps or meshes, while sequence datasets are small and limited to simple sketch-and-extrude operations.
Method
Zero-to-CAD embeds an LLM in a tool-equipped CAD environment to generate, execute, validate, and diversify readable, editable construction sequences.
Results
82.1% success with 0.747 mean IoU outperforms GPT-5.2 High’s 72.2% success and 0.485 mean IoU for image-to-sequence reconstruction.
Takeaways & Limitations
A 2B model trained only on synthetic data meaningfully reconstructs human-designed B-ReP geometries without real construction-history data.
Takeaways & Limitations
The framework guarantees executable, geometrically valid solids but does not enforce process-dependent design-for-manufacturability rules.

Abstract

from arXiv · show

Computer-Aided Design (CAD) models are defined by their construction history: a parametric recipe that encodes design intent. However, existing large-scale 3D datasets predominantly consist of boundary representations (B-Reps) or meshes, stripping away this critical procedural information. To address this scarcity, we introduce Zero-to-CAD, a scalable framework for synthesizing executable CAD construction sequences. We frame synthesis as an agentic search problem: by embedding a large language model (LLM) within a feedback-driven CAD environment, our system iteratively generates, executes, and validates code using tools and documentation lookup to promote geometric validity and operation diversity. This agentic approach enables the synthesis of approximately one million executable, readable, editable CAD sequences, covering a rich vocabulary of operations beyond sketch-and-extrude workflows. We also release a curated subset of 100,000 high-quality models selected for geometric diversity. To demonstrate the dataset's utility, we fine-tune a vision-language model on our synthetic data to reconstruct editable CAD programs from multi-view images, outperforming strong baselines, including GPT-5.2, and effectively bootstrapping sequence generation capabilities without real construction-history training data. Zero-to-CAD bridges the gap between geometric scale and parametric interpretability, offering a vital resource for the next generation of CAD AI.

1 Introduction

Zero-to-CAD addresses the lack of large-scale parametric CAD data by embedding an LLM in a feedback-driven CAD environment to synthesize readable, executable construction sequences. The resulting dataset contains approximately one million sequences, a curated 100,000-model subset, and supports image-to-sequence modeling.

Motivation: CAD models encode design intent through parametric, editable operation sequences, unlike meshes or point clouds that primarily represent geometry.These sequences allow engineers to modify dimensions, replay histories, and integrate constraints.
Data gap: Millions of models in ABC and Objaverse provide B-Reps or meshes without parametric histories, while sequence datasets remain limited and simple.DeepCAD and Fusion 360 Gallery are cited as examples of datasets with construction sequences.
Approach: Zero-to-CAD embeds an LLM in a CAD environment to propose, execute, and check candidate sequences while broadening operation coverage and part diversity.The pipeline uses tools, documentation access, prompt variability, and API-aware checks, targeting readable and editable sequences with named parameters, constraints, and references.
Dataset: Approximately one million executable construction sequences with complete histories are generated, alongside a curated subset of 100,000 models selected for diversity.The dataset is presented as sequence-centric, with broad operation coverage and replayable timelines aligned with design intent.
Applications: The dataset supports training and evaluation of sequence models and demonstrates image-to-sequence modeling from multi-view inputs without real construction-history data.This complements geometry-first datasets by providing replayable construction timelines.

2 Motivation

Zero-to-CAD addresses the scarcity of editable, intent-preserving CAD construction histories by synthesizing them rather than collecting more real-world data. It uses agentic, feedback-driven search to ground LLM design knowledge in geometric validity and scale compute into a validated, diverse dataset.

Motivation: The paper proposes synthesizing editable construction histories because real-world CAD timelines are often unavailable or inconsistent, while LLMs encode knowledge about object structure and manufacturing processes.The motivation is to preserve design intent without relying on additional real-world CAD collection.
Motivation: CAD generation is framed as agentic search: the LLM writes code, executes it, observes errors, consults documentation, inspects geometry, and self-corrects.The feedback loop grounds semantic priors in geometric validity and enables designs that open-loop generation could not produce.
Motivation: Generation breadth is encouraged by varying prompt structures and injecting randomness, while execution-based filtering prioritizes validity and diversity over exact prompt adherence.This regime uses the LLM to sample plausible mechanical designs rather than collapse into repetitive patterns.
Motivation: Compute is converted into data by producing fully executable, readable, editable CAD sequences from scratch without relying on real-world CAD files.The resulting synthetic dataset is intended to support smaller, faster, specialized downstream models.

3 Related Work

Prior CAD datasets and generative methods mainly emphasize B-Reps, meshes, sketches, or limited construction sequences, while newer work explores multimodal and code-based interfaces. Zero-to-CAD is distinguished from CAD-Recode by integrating agentic generation, tool use, repair, sampling, and validation into a closed-loop synthesis pipeline.

Geometric and construction-history datasets: Large repositories primarily provide B-Reps or meshes, discarding construction history, while SketchGraphs supplies sketch-and-constraint graphs without 3D solid-modeling operations.The ABC dataset contains one million B-Reps but explicitly retains only final geometry.
Sketch-based sequence generation: Sketch-and-extrude sequence models build on DeepCAD and Fusion 360 Gallery, with later methods refining this paradigm through hierarchical codebooks.The supplied passage identifies SkexGen and HNC-CAD as follow-up approaches.
Direct B-Rep generation: A parallel research line generates B-Reps directly, including autoregressive, diffusion-based, and holistic latent representations.The passage names SolidGen, BRepGen, and HoLa as representative methods.
Conditioned and code-based generation: Recent systems condition CAD generation on text or images and use structured parametric code, but existing interfaces remain limited by operation coverage and sequence-dataset scale.The passage cites Text2CAD, CAD-Llama, FlexCAD, CAD-MLLM, CAD-GPT, and CAD-Coder.
Closest precursor and distinction: CAD-Recode generates executable CadQuery code, but its scripts often lack human-like semantic parameters and constraints, instead using generic identifiers and hard-coded values.Zero-to-CAD is presented as generating designs ab initio using LLM semantic knowledge.
Closest precursor and distinction: Zero-to-CAD integrates agentic loops, tool use, two-stage generation, category-conditioned sampling, documentation-grounded repair, and multi-stage validation into a closed-loop synthesis pipeline.The integration is framed as enabling million-scale dataset creation and testing whether LLM priors yield executable, readable CAD programs.

4 Method

Zero-to-CAD uses a two-stage, feedback-driven agentic pipeline to synthesize diverse executable CadQuery programs and retain only geometrically valid, exportable solids. Structured categories, semantic operation selection, elastic compute, and diversity-based curation support million-scale generation and a 100,000-model release.

Tooling: Three tools ground generation in executable reality: isolated validation, TF-IDF documentation retrieval, and regex-based syntax lookup.Execution returns errors, topology metrics, and export status; documentation retrieval avoids complex RAG overhead at scale.
Two-Stage Generation: The pipeline separates catalog generation from code generation, enabling controlled part-category diversity while maintaining geometric validity.Stage 1 produces dimension-free part descriptions; Stage 2 converts each description into executable CadQuery code.
Agentic Refinement: An agentic repair loop executes candidate code, uses runtime feedback to diagnose failures, and consults documentation when needed.The system employs gpt-oss-120b locally with tools for execution, validation, and documentation lookup.
Validation: Only programs passing code execution, geometric, and STL/STEP export validation enter the dataset.Geometric checks include topological validity, single-solid connectivity, at least 7 B-Rep faces, and positive volume; DFM rules are not enforced.
Diversity Control: Structured categorization across 65 predefined part categories and description-driven operation selection promote balanced coverage and coherent operation diversity.Descriptions semantically prompt suitable operations, such as extrusions for reinforcing ribs and fillets for rounded edges.
Scale and Release: Approximately one million designs were generated with elastic compute, while a 100,000-model subset was selected using clustered multi-view visual embeddings for geometric diversity.Inference used 2–80 GPUs and execution workers scaled to 3,000 CPU cores; the subset selects nearest-to-centroid exemplars from k-means clusters.

5 Dataset Statistics and Analysis

Zero-to-CAD contains 999,633 executable CAD sequences with full construction histories, organized as readable, logically ordered operations. The analysis highlights synthesis failure modes and contrasts Zero-to-CAD’s parametric readability with prior sketch-and-extrude datasets.

Dataset Scale and Structure: 999,633 executable CAD sequences comprise the dataset, each retaining a full construction history.Table 2 aggregates token counts and tool calls across accepted generations and repair loops.
Dataset Scale and Structure: Sequences follow logical operation progressions such as sketch, extrude, and modify, enabling sequential execution and reflecting human design intent.
Generation Failure Modes: Synthesis failures include broken connectivity in thin-wall features, self-intersections, and misplaced holes caused by insufficient spatial grounding.Textual reasoning can produce locally plausible operations while missing global geometric relationships and feature intersections.
Comparison with CAD-Recode: DeepCAD and CAD-Recode cannot express fillets, chamfers, shells, lofts, sweeps, or patterns, so direct operation-diversity comparison is not meaningful.The comparison instead evaluates geometric quality and distributional alignment with ABC using DINOv2 embeddings, Fréchet distance, and k-ball coverage.
Readability: Zero-to-CAD programs use named parameters and logical construction order, making design intent explicit and modifications straightforward.CAD-Recode’s transpiled coordinate-chain code lacks parametric structure and is difficult for human engineers to edit manually.

6 Bootstrapping Experiment

The bootstrapping experiment trains a vision-language model to reconstruct executable CadQuery programs from eight rendered views, showing strong in-distribution performance and meaningful transfer to human-designed CAD despite synthetic-only supervision.

Task Formulation: Given eight 256×256 rendered views, the model generates executable CadQuery code reproducing the CAD geometry in one forward pass.The views include four front-facing and four rear-facing angles, requiring 3D understanding from 2D projections and translation into parametric code.
Training Data and Model: The model is fully fine-tuned Qwen3-VL-2B-Instruct on 979,633 training samples paired with eight rendered images and CadQuery source code.The dataset also includes 10,000 validation and 10,000 test samples.
In-Distribution Performance: 82.1% success and 0.747 mean IoU are achieved on Zero-to-CAD test data, outperforming GPT-5.2 High at 72.2% success and 0.485 mean IoU.The fine-tuned model’s median IoU is 0.847 and its P90 is 0.999, while the base Qwen model reaches only 6.6% success.
Out-of-Distribution Generalization: 61.0% success and 0.377 mean IoU on ABC show meaningful generalization to human-designed CAD after training exclusively on synthetic sequences.ABC is an out-of-distribution benchmark of real-world human-designed CAD models with different stylistic conventions.
Out-of-Distribution Generalization: On ABC, the fine-tuned model has higher IoU metrics than GPT-5.2 variants, while GPT-5.2 High attains a higher 66.2% success rate at lower geometric fidelity.The results indicate that synthetic-to-real transfer remains challenging despite strong in-distribution reconstruction.

7 Conclusion · Appendix

Zero-to-CAD is an agentic pipeline for synthesizing executable CAD construction sequences without relying on real-world design histories. It combines LLM generation with execution feedback, documentation lookup, and multi-stage validation to produce valid, readable programs with broad operation coverage.

7 Conclusion: Zero-to-CAD synthesizes executable CAD construction sequences without relying on real-world design histories.The pipeline frames CAD-program creation as an agentic synthesis process.
7 Conclusion: The pipeline combines LLM generation with execution feedback to guide CAD sequence synthesis.Execution feedback is one component of the pipeline’s iterative mechanism.
7 Conclusion: Documentation lookup is integrated into the synthesis pipeline to support CAD program generation.The passage identifies documentation lookup alongside generation and validation.
7 Conclusion: Multi-stage validation helps the pipeline produce geometrically valid CAD programs.Geometric validity is explicitly listed as an outcome of the combined pipeline.
7 Conclusion: The synthesized programs are human-readable and use named parameters.These properties support interpretation of the generated construction sequences.
7 Conclusion: The released programs provide broad operation coverage beyond basic CAD workflows.The passage specifically names Booleans, fillets, chamfers, shells, lofts, sweeps, and patterns.

A Dataset Samples

Figure 6 visually compares dataset samples from Zero-to-CAD, ABC, DeepCAD, and CAD-Recode.

Figure 6 presents a visual comparison of dataset samples from Zero-to-CAD, ABC, DeepCAD, and CAD-Recode.

B Generation Statistics Distributions

Figure 7 characterizes the dataset generation process through distributions of validation attempts, function calls, token counts, face counts, and CAD operation coverage.

The generation-process distributions include validation attempts before successful outputs, function calls per conversation, and generated tokens per design.
Geometric complexity is represented through distributions of face counts across generated designs.
The statistics also report coverage of CAD operations in the generated dataset.

C Training Details · D System Prompts

The paper specifies the fine-tuning configuration for Qwen3-VL-2B-Instruct and documents system prompts for catalog generation, CAD code synthesis, and Image-to-Sequence inference. These prompts regulate structured outputs, geometric validity, tool use, and task-specific inference behavior.

C Training Details: Table 5 summarizes the hyperparameters used to fine-tune Qwen3-VL-2B-Instruct on Zero-to-CAD data.The supplied passage identifies the configuration table but does not provide its individual hyperparameter values.
D System Prompts: The paper provides system prompts for both dataset generation and downstream fine-tuning experiments.These materials cover the catalog, CAD code-generation, and Image-to-Sequence stages.
D.1 Catalog Generation Prompt: The catalog-generation prompt casts the LLM as an expert mechanical parts librarian producing concise, plausible descriptions without dimensions.It targets semantically meaningful part specifications while avoiding dimensional details.
D.1 Catalog Generation Prompt: Catalog descriptions must be unique within each batch and returned as a JSON array for programmatic processing.Batch generation is intended to provide diverse yet semantically meaningful specifications.
D.2 Code Generation Prompt: The CAD code-generation prompt encodes 19 design principles spanning parametric design, CadQuery practices, scale conventions, manufacturability, and error handling.The full prompt also includes CadQuery API signatures and guidance on sketch construction and revolve operations.
D.2 Code Generation Prompt: During debugging, the CAD prompt preserves geometric sophistication by requiring syntax lookup instead of simplifying code.It also guides tool usage for validation and documentation lookup and specifies error-recovery protocols.
D.3 Inference System Prompts: Image-to-Sequence inference uses different system prompts for fine-tuned and zero-shot models.The fine-tuned Qwen model uses a minimal prompt, whereas base Qwen and GPT-5.2 receive longer output-format instructions.
D.3 Inference System Prompts: Zero-shot models are instructed to store results in a specific variable and avoid export commands because they require explicit output-format guidance.This contrasts with the fine-tuned model, which internalizes task requirements during training.

E Example Generated Code

The example mounting-plate output is complete CadQuery code with named parameters, logical construction order, and diverse modeling operations. Its interpretable structure supports modifying dimensions and adapting the design to new requirements.

Example Generated Code: The mounting-plate example provides complete CadQuery code corresponding to the depicted design.Figure 11 presents the full implementation for the mounting plate shown in Figure 2.
Example Generated Code: Named parameters and logical construction order make the generated code interpretable.Examples include descriptive variables such as plate_thickness and fillet_radius, with the base plate constructed before the rib and subtractive features.
Example Generated Code: The code combines extrusion, Boolean union and cut, fillet, and chamfer operations.This operation mix extends beyond a single sketch-and-extrude pattern in the illustrated construction sequence.
Example Generated Code: The interpretable structure allows engineers to modify dimensions or adapt the design for new requirements.Named dimensions and readable sequencing expose editable construction intent.