Agent-Aided Design for Dynamic CAD Models Mitch Adler
arXiv:2604.15184v1 [cs.AI] 16 Apr 2026
Independent Researcher San Francisco, CA, USA [email protected]
Matthew Russo
MIT Cambridge, MA, USA [email protected]
Michael Cafarella
MIT Cambridge, MA, USA [email protected]
Abstract
1
In the past year, researchers have started to create agentic systems that can design real-world CAD-style objects in a training-free setting, a new variety of system that we call Agent-Aided Design. Generally speaking, these systems place an agent in a feedback loop in which it can write code, compile that code to an assembly of CAD model(s), visualize the model, and then iteratively refine its code based on visual and other feedback. Despite rapid progress, a key problem remains: none of these systems can build complex 3D assemblies with moving parts. For example, no existing system can build a piston, a pendulum, or even a pair of scissors. In order for Agent-Aided Design to make a real impact in industrial manufacturing, we need a system that is capable of generating such 3D assemblies. In this paper we present a prototype of AADvark, an agentic system designed for this task. Unlike previous state-ofthe-art systems, AADvark captures the dynamic part interactions with one or more degrees-of-freedom. This design decision allows AADvark to reason directly about assemblies with moving parts and can thereby achieve cross-cutting goals, including but not limited to mechanical movements. Unfortunately, current LLMs are imperfect spatial reasoners, a problem that AADvark addresses by incorporating external constraint solver tools with a specialized visual feedback mechanism. We demonstrate that, by modifying the agent’s tools (FreeCAD and the assembly solver), we are able to create a strong verification signal which enables our system to build 3D assemblies with movable parts.
Industrial manufacturing relies on computer-aided design (CAD) to create products ranging from furniture to Formula 1 cars [13, 42]. Software tools such as OnShape [30], SolidWorks [40], and FreeCAD [10] enable engineers to design 3D objects in a GUI by sequentially applying operations (e.g., sketch, extrude, fillet, etc.) that transform 2D sketches and 3D objects into a final desired form. This series of operations, each parameterized by discrete and/or continuous values representing, for example, the length of an extrusion, defines a CAD model which can be fabricated. While CAD tools have become indispensable for manufacturing— increasing productivity, design precision, and product quality—they can still be tedious to use [12, 33]. As a result, the graphics and AI communities have sought to automate the generation of CAD models by training deep generative models to reverse engineer them from images, text descriptions, 3D point clouds, and more [5, 6, 17, 18, 20, 21, 23, 34, 45, 46, 51–53, 56]. To overcome a lack of training data, more recent work has built agentic systems where an agent can write code, compile the code to a CAD model, visualize the model in e.g. FreeCAD, and use the visual feedback (as well as compiler errors and other signals) to iterate on its design until the CAD model is sufficiently similar to the input [2, 4, 14, 27, 54]. However, in spite of these techniques’ state-of-the-art performance on CAD benchmarks [8, 49, 50], they suffer from a key limitation: the systems are capable of generating static CAD models, but they cannot model complex assemblies with joints and moving parts. Put more simply, these systems cannot create a functional pair of scissors. Prior work can create a 3D model for the scissor blades and handles, but it cannot model the revolute joint which allows the blades to move in a slicing motion. Passing “the scissors test" is crucial if Agent-Aided Design (AAD) is to be taken seriously as a tool for industrial manufacturing. Generating dynamic 3D assemblies with moving parts is more difficult than generating static CAD models. For starters, the agentic system needs to specify the joints that connect each part in the assembly. Unlike prior work, this includes specifying each joint’s degree(s) of freedom to allow for dynamic part interactions. This is made especially challenging, given Vision Language Models’ (VLMs) known limitations in spatial reasoning [39, 43]. Furthermore, in order for the agentic system to compile its design, it must have access to a 3D assembly constraint solver. In our initial experiments, we found that existing open-source solvers had limitations due to the fact that they were designed with a human end-user in mind. For example, these solvers used Euler angles instead of quaternions because they assumed that a human could flip the part in a GUI if the solver oriented a part in an anti-parallel fashion. To
CCS Concepts • Computing methodologies → Artificial intelligence; • Applied computing → Computer-aided design.
Keywords Agent-Aided Design, Agentic Systems, AI Agents, Computer-Aided Design ACM Reference Format: Mitch Adler, Matthew Russo, and Michael Cafarella. 2026. Agent-Aided Design for Dynamic CAD Models. In Proceedings of The 1st ACM Conference on AI and Agentic Systems: Demos (CAIS ’26). ACM, New York, NY, USA, 6 pages. https://doi.org/XXXXXXX.XXXXXXX Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]. CAIS ’26, San Jose, CA © 2026 Copyright held by the owner/author(s). Publication rights licensed to ACM. ACM ISBN 978-1-4503-XXXX-X/2018/06 https://doi.org/XXXXXXX.XXXXXXX
Introduction
1 Demo Video Link: https://youtu.be/z2zsbD3E4Tc
CAIS ’26, May 26–29, 2026, San Jose, CA
Mitch Adler, Matthew Russo, and Michael Cafarella
Multimodal Inputs
Prompt: A pair of scissors with a rectangular handle and slender appearance. As shown in the images, the scissors should consist of two symmetrical blades which open and close in a slicing motion.
AADvark System
Parts JSONs
Assembly JSON
handle.json
{
blade.json pivot.json
}
“parts”: […], “links”: […], “joints”: […],
3D Assembly Constraint Solver
FreeCAD Rendering
Enhanced Compilation Error Messages
Figure 1: An illustration of AADvark generating a pair of scissors. AADvark accepts one or more images and/or textual description as input. AADvark creates JSON definitions for the parts and joints in the 3D assembly and then compiles them using a 3D assembly constraint solver. Compilation errors and intermediate renderings (generated in FreeCAD) are fed back into the agent. We modify FreeCAD and the constraint solver to provide spatial cues and informative error messages, respectively, to the agent. The agent iteratively updates the assembly until it decides the rendered object is sufficiently similar to the input(s). maximize the solver’s utility for an agent, we ultimately had to modify the solver to use quaternions and enhance its error messages to be generally more informative. In this paper, we present a demo of our work on AADvark as a first step towards building an agentic system for Agent-Aided Design of complex 3D assemblies. In addition to generating CAD models for static parts and assemblies, AADvark is capable of generating dynamic CAD models with free joints and moving parts. At a high-level, the system consists of an agent which is instructed on how to write assemblies via an intermediate representation specified in JSON. This representation is then compiled to a 3D assembly, with compilation errors and renderings generated in FreeCAD being fed back into the agent. Given this feedback, the agent iterates on its design and performs a series of checks to assess whether the design is internally consistent (e.g. that each part and joint looks correct in isolation). Finally, once the agent is satisfied that the assembly meets the input specification, the final 3D model is returned. A system diagram for AADvark is shown in Figure 1. In order to overcome deficiencies in VLMs’ spatial reasoning, we modified FreeCAD to render each part in our assembly with a unique edge color and texture. Additionally, we rendered each instance of the same part with a unique text identifier (e.g. “Blade1", “Blade2", etc.). This visual scheme provided the agent with deterministic, stable identifiers which improved its ability to reference specific edges in joint definitions. To improve our agent’s efficiency in generating correct outputs, we modified the OndselSolver [11], an open-source Multibody Dynamics Solver, to improve its utility for the agent by, for example, incorporating quaternions and providing more detailed error messages about inconsistent constraints in the assembly and convergence failures. Our approach was inspired by prior work which demonstrated that having strong verifiers, i.e. functions which provide robust error / feedback signals to an agentic system [1, 7, 15, 19, 22, 36, 48], can improve agentic
system performance (perhaps even more than making changes to the agent itself). We demonstrate a prototype of AADvark and use it to perform two evaluations. First, we show that AADvark is able to go beyond the capabilities of prior work by generating a functional pair of scissors from two input images. Second, we demonstrate that AADvark’s design also supports constructing static 3D assemblies, some of which were generated by prior work and one of which could not be generated without our modifications to FreeCAD and the 3D constraint solver.
2
Related Work
AI for Computer-Aided Design (CAD). Prior work in the graphics and AI communities has focused on fully (or partially) automating the generation of parametric CAD models. Early work trained generative models to transform input 3D point clouds [17, 20], boundary representations (i.e., B-rep) [21, 56], images [6, 53, 55], and text descriptions [18] into a representative parametric CAD model. Generally speaking, these techniques required learning from labeled CAD datasets [28, 49, 50] which were hard to come by and had sparse coverage for many types of objects. This led to limitations in generating more complex and / or out-of-distribution objects [18, 53, 55, 56]. More recent work has focused on leveraging pretrained large language models (LLMs) to generate CAD models. CAD-LLama [23], CAD-GPT [23], and others [34, 51, 52] finetuned (multimodal) LLMs (MLLMs) to produce code that could be compiled to a 3D model of an input point cloud, image, and / or text string. These works benefited from LLMs’ ability to write code matching an input specification, however they still required constructing a training dataset for finetuning. To move towards a training-free paradigm, the latest systems have taken an agentic approach to generating CAD models. CADCodeVerify [2], CAD-Assistant [27], CADDesigner [14], and others
Agent-Aided Design Demo
[4, 54] have placed MLLMs inside of feedback loops in which the MLLM (i.e. agent) (1) writes code to generate a CAD model, (2) gets feedback in the form of compilation errors and object renderings, and (3) reasons about its error(s) to produce a new CAD model or terminates once it believes it has successfully constructed the object. In contrast to prior work, these systems do not require training (beyond the base model’s pretraining) and they take an iterative approach to constructing the final CAD model. CAD-Assistant [27] is most similar to AADvark. It generates CAD code actions which are executed in FreeCAD via its Python API, and then uses a set of tools to produce visual feedback from renderings of the object. (CADDesigner also sounds similar, but it is a preprint with no opensourced code). AADvark differs from CAD-Assistant (and likely CADDesigner) in its additional focus on designing assemblies with moving parts. Verification and Optimization for AI Systems. A new paradigm for agentic systems has sought to improve their performance by providing them with feedback from strong verifiers. Work on AI-driven research for systems (and algorithms) [7, 15, 22, 29] has demonstrated that coding agents can achieve state-of-the-art performance when they are able to iteratively refine the implementation of a system (or algorithm) with feedback in the form of performance metrics on a predefined evaluation. Related work has demonstrated that strong verifiers can help agents solve math and coding problems [9, 16, 26, 47] with autograders and unit-tests providing feedback on intermediate results, respectively. When strong verifiers are not available, labeled data and LLM-based evaluation have also been used to optimize agentic systems. DSPy [19] optimizes declarative language model programs using optimizers [1, 31, 41] which receive signals from a user-defined metrics function (which may use an LLM for e.g. evaluating a summary). In a similar vein, semantic query processing engines such as DocETL [38, 48], LOTUS [32], Palimpzest [25, 36], and others [3, 24, 35, 37, 44] have optimized semantic operator programs with performance measurements (e.g. cost and latency) as well as quality measurements derived from labeled data, LLMs, and proxy methods. While AADvark is similar in its use of a strong verifier for optimization, the domain of 3D CAD model generation differs significantly from these works.
3
System Overview
We discuss each component of the AADvark system in more detail. Agent Execution. AADvark takes one or more images and optionally a text description of the desired object as input. These inputs are fed into an agent (e.g., Gemini 3 Flash in our demonstration) whose goal is to generate a CAD model (i.e., a 3D assembly) which could be fabricated to create this object. The agent creates an assembly by writing JSON files to define the parts and joints that make up a 3D assembly. In our example in Figure 1, the agent is given two photos of a pair of scissors as well as a text description for its input. It then constructs three JSON parts files corresponding to the blade, the handle, and the pivot. To compose these parts into an assembly, the agent writes a JSON assembly file which consists of three sections. First, the agent specifies the parts used in the assembly with pointers
CAIS ’26, May 26–29, 2026, San Jose, CA
to their JSON part file definitions. Second, the agent creates the unique set of part instances in the “links" section. For example, a pair of scissors will have two distinct instances of the handle and blade parts, each of which is defined with its own link. Third, these unique part instances are joined together by a set of “joints". In AADvark, the agent joins two links together by specifying their names, the type of joint, which two faces of the links are being joined, which degrees of freedom are fixed vs. free, and (if free) what limits exist on their freedom. Once the agent creates a complete JSON assembly file, AADvark compiles the file, renders it in FreeCAD, and sends it to the 3D assembly constraint solver. FreeCAD produces a rendering of the assembly while the constraint solver may produce error messages indicating flaws in the design. (We discuss each of these tools in more detail below). Finally, the agent incorporates these feedback signals into its next generation of the JSON parts and assembly files. This iterative process continues until the assembly passes the constraint solver and the agent deems the rendering of the assembly to adequately represent the input(s). Building Strong Verifiers. The agent within AADvark is provided with two primary tools for obtaining a signal on the correctness of its design. First, the agent is provided with a 3D assembly constraint solver which takes the JSON assembly file and returns whether its parts could physically be joined into an assembly. The AADvark prototype uses an augmented version of the open-source OndselSolver [11] for its constraint solver. However, when working with the original OndselSolver, we noticed that some elements of its design hindered the agent’s ability to design correct assemblies. For example, due to its use of Euler angles, the solver could return an assembly which oriented a part in an anti-parallel fashion. For humans, FreeCAD resolved this issue by presenting them with a button to flip any part in the assembly. However, for the agent, this led to confusion about the correctness of its design. To make the solver more useful for the agent, we augmented it to use quaternions instead of Euler angles. Additionally, we modified the solver to update parts’ positions in FreeCAD even when there was a compilation error. By default FreeCAD will not update the design if there is a compilation error (e.g. because two parts would intersect), however visualizing these errors helped the agent understand its mistakes. Finally, we made the solver’s error messages generally more informative and made it more deterministic by eliminating sources of variance which went into an internal invocation of Newton’s Method. The second tool provided to AADvark’s agent is an extended version of FreeCAD. The agent uses this tool to generate renderings of its 3D assembly. This helps to identify flaws in its design which can be corrected in subsequent iterations. One key challenge with providing visual feedback is that VLMs are imperfect spatial reasoners [39, 43]. In our early experiments, we found that the agent struggled to specify joints correctly because different part instances could look identical in FreeCAD’s renderings. To overcome this issue, we modified FreeCAD to compute a unique color and texture (e.g. solid vs. dotted line) for each face and edge of each part instance. Given these unique colors and textures, we could then ask the agent to specify its joints by writing the colors and textures of the part faces to be joined by a given joint. The addition of this
CAIS ’26, May 26–29, 2026, San Jose, CA
Input Images
Mitch Adler, Matthew Russo, and Michael Cafarella
Percent Progress Towards Final Object (Shown at Multiple Joint Angles) 0%
25%
50%
75%
Ex. Image
100%
0%
Percent Progress Towards Final Object 25%
50%
75%
100%
Carport
(9 iterations)
Chair
(15 iterations)
End Table
(4 iterations)
Toddler Bed
(34 iterations) Scissors
(20 iterations)
Whiteboard (6 iterations)
Figure 2: Snapshots from our demonstration of AADvark creating a dynamic 3D assembly for a pair of scissors. Each column corresponds to a single iteration of the object as it was generated. Each row shows the object at a different angle of the revolute joint (0, 20, 40, and 60 degrees). AADvark starts out with a base rectangle and by the end of our demonstration it has created a functional pair of scissors.
enhancement is ultimately what enabled AADvark to produce a correct assembly for the toddler bed in Section 4.
4
Demo Scenario
Generating Dynamic CAD Models. For our demonstration, we tested whether AADvark could generate a dynamic CAD model for a pair of scissors. The input to AADvark was two images. The first image showed a pair of scissors in a closed state and the second image showed them in an open state (left column of Figure 2). AADvark initialized an assembly with a simple base rectangle and then began to iteratively modify the assembly. After four iterations (the 20% progress column in Figure 2) AADvark already had modified the scissors assembly to resemble the input image(s), including by properly constructing the revolute joint to enable a cutting motion. However, the handles did not have holes for fingers. AADvark then spent the majority of its iterations modifying the handles to contain holes for fingers, before finally accomplishing this task in iteration 20. On average, each iteration took 745 seconds, cost $0.79, and processed 914k input tokens and 111k output (and thinking) tokens across 23.4 LLM calls. In total, it took 4.14 hours, cost $15.85, and processed 18.2M input tokens and 2.2M output tokens across 468 LLM calls. Generating Static CAD Models. As a second test, we sought to demonstrate that AADvark could also generate 3D assemblies for a diverse set of static objects, some of which were generated by prior work [53]. We provided the system with images of a toddler bed, chair, end table, carport, and a standing dry erase board. For each object we provided 1-3 input images. To probe AADvark’s ability to handle natural language specifications, we additionally provided
Figure 3: Illustration of AADvark’s ability to create 3D assemblies for various objects in FreeCAD. Each object begins as a single base rectangular prism before AADvark iteratively adds parts and joints to construct the final CAD model.
an LLM-generated design document for how to build a toddler bed. The results from our experiments are shown in Figure 3 Overall, AADvark was able to generate a CAD model for each input object within 4 - 34 iterations. Once again, AADvark initialized each assembly with a base rectangular prism. For the carport, end table, and whiteboard, AADvark was able to generate a 3D assembly which resembled the input within 1-3 iterations. From that point onward, AADvark simply needed to tweak the size of various parts and the joints between them in order to produce a final assembly which satisfied the constraint solver and looked visually similar to the input (as judged by a VLM). For the toddler bed and chair, AADvark required a larger number of iterations to work through the more complicated set of part interactions (especially for the toddler bed). In our experimentation, we found that AADvark was only able to successfully construct the toddler bed after we augmented the assembly renderings to include unique colors for the different faces and edges of each part instance.
5
Limitations
While AADvark represents a promising first step towards AgentAided Design of dynamic CAD models, it does have limitations. For now, the system can only use rectangular prisms for parts and the only dynamic joint which it supports is a revolute joint. In the future, we intend to expand the set of parts and joints that AADvark can create to allow it to design any object that FreeCAD can support. Finally, due to the non-deterministic nature of agentic execution, we observed that AADvark sometimes will get stuck on its assembly design. We found that simply restarting the agent can often times resolve the issue, but in the future we aim to investigate the underlying causes of the agent getting stuck.
Agent-Aided Design Demo
Acknowledgments We are grateful for the support from the DARPA ASKEM Award HR00112220042, the ARPA-H Biomedical Data Fabric project, NSF DBI 2327954, a grant from Liberty Mutual, a Google Research Award, and the Amazon Research Award. Additionally, our work has been supported by contributions from Amazon, Google, and Intel as part of the MIT Data Systems and AI Lab (DSAIL) at MIT, along with NSF IIS 1900933. This research was sponsored by the United States Air Force Research Laboratory and the Department of the Air Force Artificial Intelligence Accelerator and was accomplished under Cooperative Agreement Number FA8750-19-2-1000. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Department of the Air Force or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.
References [1] Lakshya A Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong, Arnav Singhvi, Herumb Shandilya, Michael J Ryan, Meng Jiang, Christopher Potts, Koushik Sen, Alexandros G. Dimakis, Ion Stoica, Dan Klein, Matei Zaharia, and Omar Khattab. 2025. GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning. arXiv:2507.19457 [cs.CL] https://arxiv.org/ abs/2507.19457 [2] Kamel Alrashedy, Pradyumna Tambwekar, Zulfiqar Haider Zaidi, Megan Langwasser, Wei Xu, and Matthew Gombolay. 2025. Generating CAD Code with VisionLanguage Models for 3D Designs. In The Thirteenth International Conference on Learning Representations. https://openreview.net/forum?id=BLWaTeucYX [3] Eric Anderson, Jonathan Fritz, Austin Lee, Bohou Li, Mark Lindblad, Henry Lindeman, Alex Meyer, Parth Parmar, Tanvi Ranade, Mehul A. Shah, Benjamin Sowell, Dan Tecuci, Vinayak Thapliyal, and Matt Welsh. 2025. The Design of an LLM-powered Unstructured Analytics System. CIDR. [4] Anonymous. 2026. Seek-CAD: A Self-refined Generative Modeling for 3D Parametric CAD Using Local Inference via DeepSeek. In The Fourteenth International Conference on Learning Representations. https://openreview.net/forum?id= PzIc2TxhwN [5] Francesco Buonamici, Monica Carfagni, Rocco Furferi, Lapo Governi, Alessandro Lapini, and Yary Volpe. 2018. Reverse engineering modeling methods and tools: a survey. Computer-Aided Design and Applications 15, 3 (2018), 443–464. arXiv:https://doi.org/10.1080/16864360.2017.1397894 doi:10.1080/16864360.2017. 1397894 [6] Cheng Chen, Jiacheng Wei, Tianrun Chen, Chi Zhang, Xiaofeng Yang, Shangzhan Zhang, Bingchen Yang, Chuan-Sheng Foo, Guosheng Lin, Qixing Huang, and Fayao Liu. 2025. CADCrafter: Generating Computer-Aided Design Models from Unconstrained Images. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 11073–11082. doi:10.1109/CVPR52734.2025.01034 [7] Audrey Cheng, Shu Liu, Melissa Pan, Zhifei Li, Shubham Agarwal, Mert Cemri, Bowen Wang, Alexander Krentsel, Tian Xia, Jongseok Park, Shuo Yang, Jeff Chen, Lakshya Agrawal, Ashwin Naren, Shulu Li, Ruiying Ma, Aditya Desai, Jiarong Xing, Koushik Sen, Matei Zaharia, and Ion Stoica. 2025. Let the Barbarians In: How AI Can Accelerate Systems Performance Research. arXiv:2512.14806 [cs.SE] https://arxiv.org/abs/2512.14806 [8] Kseniya Cherenkova, Djamila Aouada, and Gleb Gusev. 2020. Pvdeconv: PointVoxel Deconvolution for Autoencoding CAD Construction in 3D. 2020 IEEE International Conference on Image Processing (ICIP) (2020), 2741–2745. https: //api.semanticscholar.org/CorpusID:224867618 [9] Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. Training Verifiers to Solve Math Word Problems. arXiv:2110.14168 [cs.LG] https://arxiv.org/abs/2110.14168 [10] FreeCAD contributors. 2026. FreeCAD. https://github.com/FreeCAD/FreeCAD [11] OndselSolver contributors and Mitch Adler. 2026. OndselSolver. https://github. com/FreeCAD/OndselSolver [12] Yuanzhe Deng, James Chen, and Alison Olechowski. 2023. What Sets Proficient and Expert Users Apart? Results of a Computer-Aided Design Experiment. Journal of Mechanical Design 146 (09 2023), 1–39. doi:10.1115/1.4063360 [13] Martin Enthed and AWE XR. 2024. IKEA’s Journey Through 3D Visualization and Spatial Computing. Retrieved January 29, 2026 from https://www.youtube.com/ watch?v=Kup0d4Te3n0
CAIS ’26, May 26–29, 2026, San Jose, CA
[14] Fengxiao Fan, Jingzhe Ni, Xiaolong Yin, Sirui Wang, Xingyu Lu, Qiang Zou, Ruofeng Tong, Min Tang, and Peng Du. 2025. CADDesigner: Conceptual Design of CAD Models Based on General-Purpose Agent. arXiv:2508.01031 [cs.AI] https://arxiv.org/abs/2508.01031 [15] Pouya Hamadanian, Pantea Karimi, Arash Nasr-Esfahany, Kimia Noorbakhsh, Joseph Chandler, Ali ParandehGheibi, Mohammad Alizadeh, and Hari Balakrishnan. 2025. Glia: A Human-Inspired AI for Automated Systems Design and Optimization. arXiv:2510.27176 [cs.AI] https://arxiv.org/abs/2510.27176 [16] Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik R Narasimhan. 2024. SWE-bench: Can Language Models Resolve Real-world Github Issues?. In The Twelfth International Conference on Learning Representations. https://openreview.net/forum?id=VTF8yNQM66 [17] Mohammad Sadil Khan, Elona Dupont, Sk Aziz Ali, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. 2024. CAD-SIGNet: CAD Language Inference from Point Clouds using Layer-wise Sketch Instance Guided Attention. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 4713–4722. [18] Mohammad Sadil Khan, Sankalp Sinha, Sheikh Talha Uddin, Didier Stricker, Sk Aziz Ali, and Muhammad Zeshan Afzal. 2024. Text2CAD: Generating Sequential CAD Designs from Beginner-to-Expert Level Text Prompts. In Advances in Neural Information Processing Systems, Vol. 37. Curran Associates, Inc., 7552–7579. https://proceedings.neurips.cc/paper_files/paper/2024/file/ 0e5b96f97c1813bb75f6c28532c2ecc7-Paper-Conference.pdf [19] Omar Khattab, Arnav Singhvi, Paridhi Maheshwari, Zhiyuan Zhang, Keshav Santhanam, Sri Vardhamanan, Saiful Haq, Ashutosh Sharma, Thomas T. Joshi, Hanna Moazam, Heather Miller, Matei Zaharia, and Christopher Potts. 2024. DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines. The Twelfth International Conference on Learning Representations. [20] Joseph George Lambourne, Karl Willis, Pradeep Kumar Jayaraman, Longfei Zhang, Aditya Sanghi, and Kamal Rahimi Malekshan. 2022. Reconstructing editable prismatic CAD from rounded voxel models. In SIGGRAPH Asia 2022 Conference Papers (Daegu, Republic of Korea) (SA ’22). Association for Computing Machinery, New York, NY, USA, Article 53, 9 pages. doi:10.1145/3550469.3555424 [21] Joseph G. Lambourne, Karl D. D. Willis, Pradeep Kumar Jayaraman, Aditya Sanghi, Peter Meltzer, and Hooman Shayani. 2021. BRepNet: A topological message passing system for solid models. In 2021 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 12768–12777. doi:10.1109/CVPR46437.2021.01258 [22] Robert Tjarko Lange, Yuki Imajuku, and Edoardo Cetin. 2026. ShinkaEvolve: Towards Open-Ended and Sample-Efficient Program Evolution. In The Fourteenth International Conference on Learning Representations. https://openreview.net/ forum?id=lKEdGCoDNC [23] Jiahao Li, Weijian Ma, Xueyang Li, Yunzhong Lou, Guichun Zhou, and Xiangdong Zhou. 2025. CAD-Llama: Leveraging Large Language Models for ComputerAided Design Parametric 3D Model Generation. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR). 18563–18573. doi:10.1109/ CVPR52734.2025.01730 [24] Paweł Liskowski, Benjamin Han, Paritosh Aggarwal, Bowei Chen, Boxin Jiang, Nitish Jindal, Zihan Li, Aaron Lin, Kyle Schmaus, Jay Tayade, Weicheng Zhao, Anupam Datta, Nathan Wiegand, and Dimitris Tsirogiannis. 2025. Cortex AISQL: A Production SQL Engine for Unstructured Data. arXiv:2511.07663 [cs.DB] https://arxiv.org/abs/2511.07663 [25] Chunwei Liu, Matthew Russo, Michael Cafarella, Lei Cao, Peter Baile Chen, Zui Chen, Michael Franklin, Tim Kraska, Samuel Madden, Rana Shahout, et al. 2025. Palimpzest: Optimizing AI-Powered Analytics with Declarative Query Processing. CIDR. [26] Thang Luong, Dawsen Hwang, Hoang H Nguyen, Golnaz Ghiasi, Yuri Chervonyi, Insuk Seo, Junsu Kim, Garrett Bingham, Jonathan Lee, Swaroop Mishra, Alex Zhai, Huiyi Hu, Henryk Michalewski, Jimin Kim, Jeonghyun Ahn, Junhwi Bae, Xingyou Song, Trieu Hoang Trinh, Quoc V Le, and Junehyuk Jung. 2025. Towards Robust Mathematical Reasoning. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, Christos Christodoulopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng (Eds.). Association for Computational Linguistics, Suzhou, China, 35418–35442. doi:10.18653/v1/2025.emnlp-main.1794 [27] Dimitrios Mallis, Ahmet Serdar Karadeniz, Sebastian Cavada, Danila Rukhovich, Niki Maria Foteinopoulou, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. 2025. CAD-Assistant: Tool-Augmented VLLMs as Generic CAD Task Solvers. International Conference on Computer Vision (ICCV) (2025). [28] Brandon Man, Ghadi Nehme, Md Ferdous Alam, and Faez Ahmed. 2025. VideoCAD: A Dataset and Model for Learning Long-Horizon 3D CAD UI Interactions from Video. In The Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track. https://openreview.net/forum? id=7SD9RCvcb9 [29] Alexander Novikov, Ngân Vũ, Marvin Eisenberger, Emilien Dupont, Po-Sen Huang, Adam Zsolt Wagner, Sergey Shirobokov, Borislav Kozlovskii, Francisco J. R. Ruiz, Abbas Mehrabian, M. Pawan Kumar, Abigail See, Swarat Chaudhuri, George Holland, Alex Davies, Sebastian Nowozin, Pushmeet Kohli, and Matej Balog. 2025. AlphaEvolve: A coding agent for scientific and algorithmic discovery. arXiv:2506.13131 [cs.AI] https://arxiv.org/abs/2506.13131
CAIS ’26, May 26–29, 2026, San Jose, CA
[30] OnShape. 2026. OnShape. https://www.onshape.com/en/ [31] Krista Opsahl-Ong, Michael Ryan, Josh Purtell, David Broman, Christopher Potts, Matei Zaharia, and Omar Khattab. 2024. Optimizing Instructions and Demonstrations for Multi-Stage Language Model Programs. 9340–9366. doi:10. 18653/v1/2024.emnlp-main.525 [32] Liana Patel, Siddharth Jha, Melissa Pan, Harshit Gupta, Parth Asawa, Carlos Guestrin, and Matei Zaharia. 2025. Semantic Operators and Their Optimization: Enabling LLM-Based Data Processing with Accuracy Guarantees in LOTUS. Proc. VLDB Endow. 18, 11 (July 2025), 4171–4184. doi:10.14778/3749646.3749685 [33] D. Robertson and T.J. Allen. 1993. CAD system use and engineering performance. IEEE Transactions on Engineering Management 40, 3 (1993), 274–282. doi:10.1109/ 17.233189 [34] Danila Rukhovich, Elona Dupont, Dimitrios Mallis, Kseniya Cherenkova, Anis Kacem, and Djamila Aouada. 2025. CAD-Recode: Reverse Engineering CAD Code from Point Clouds. arXiv:2412.14042 [cs.CV] https://arxiv.org/abs/2412.14042 [35] Matthew Russo and Tim Kraska. 2025. Deep Research is the New Analytics System: Towards Building the Runtime for AI-Driven Analytics. arXiv:2509.02751 [cs.AI] https://arxiv.org/abs/2509.02751 [36] Matthew Russo, Sivaprasad Sudhir, Gerardo Vitagliano, Chunwei Liu, Tim Kraska, Samuel Madden, and Michael Cafarella. 2025. Abacus: A Cost-Based Optimizer for Semantic Operator Systems. arXiv:2505.14661 [cs.DB] https://arxiv.org/abs/ 2505.14661 [37] Dario Satriani, Enzo Veltri, Donatello Santoro, Sara Rosato, Simone Varriale, and Paolo Papotti. 2025. Logical and Physical Optimizations for SQL Query Execution over Large Language Models. Proc. ACM Manag. Data 3, 3, Article 181 (June 2025), 28 pages. doi:10.1145/3725411 [38] Shreya Shankar, Tristan Chambers, Tarak Shah, Aditya G. Parameswaran, and Eugene Wu. 2025. DocETL: Agentic Query Rewriting and Evaluation for Complex Document Processing. Proc. VLDB Endow. 18, 9 (May 2025), 3035–3048. doi:10. 14778/3746405.3746426 [39] Fatemeh Shiri, Xiao-Yu Guo, Mona Golestan Far, Xin Yu, Reza Haf, and YuanFang Li. 2024. An Empirical Analysis on Spatial Reasoning Capabilities of Large Multimodal Models. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (Eds.). Association for Computational Linguistics, Miami, Florida, USA, 21440–21455. doi:10.18653/v1/2024.emnlp-main.1195 [40] SolidWorks. 2026. SolidWorks Design. https://www.solidworks.com/product/ solidworks-design [41] Dilara Soylu, Christopher Potts, and Omar Khattab. 2024. Fine-Tuning and Prompt Optimization: Two Great Steps that Work Better Together. 10696–10710. doi:10.48550/arXiv.2407.10930 [42] Alex Stoermann. 2023. Designing a winning Formula 1 car with NX CAD | Oracle Red Bull Racing. Retrieved January 29, 2026 from https://www.swooshtech.com/ 2023/03/24/designing-a-winning-formula-1-car-with-nx-cad [43] Ilias Stogiannidis, Steven McDonagh, and Sotirios A. Tsaftaris. 2025. Mind the Gap: Benchmarking Spatial Reasoning in Vision-Language Models. arXiv:2503.19707 [cs.CV] https://arxiv.org/abs/2503.19707 [44] Matthias Urban and Carsten Binnig. 2024. Demonstrating CAESURA: Language Models as Multi-Modal Query Planners. In Companion of the 2024 International Conference on Management of Data (Santiago AA, Chile) (SIGMOD ’24). Association for Computing Machinery, New York, NY, USA, 472–475. doi:10.1145/3626246.3654732 [45] Tamás Várady, Ralph R Martin, and Jordan Cox. 1997. Reverse engineering of geometric models—an introduction. Computer-Aided Design 29, 4 (1997), 255–268. doi:10.1016/S0010-4485(96)00054-1 Reverse Engineering of Geometric Models. [46] Siyu Wang, Cailian Chen, Xinyi Le, Qimin Xu, Lei Xu, Yanzhou Zhang, and Jie Yang. 2025. CAD-GPT: synthesising CAD construction sequence with spatial reasoning-enhanced multimodal LLMs. In Proceedings of the Thirty-Ninth AAAI Conference on Artificial Intelligence and Thirty-Seventh Conference on Innovative Applications of Artificial Intelligence and Fifteenth Symposium on Educational Advances in Artificial Intelligence (AAAI’25/IAAI’25/EAAI’25). AAAI Press, Article 876, 9 pages. doi:10.1609/aaai.v39i8.32849 [47] Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brennan, Hao Peng, Heng Ji, and Graham Neubig. 2025. OpenHands: An Open Platform for AI Software Developers as Generalist Agents. arXiv:2407.16741 [cs.SE] https://arxiv.org/abs/2407.16741 [48] Lindsey Linxi Wei, Shreya Shankar, Sepanta Zeighami, Yeounoh Chung, Fatma Ozcan, and Aditya G. Parameswaran. 2026. Multi-Objective Agentic Rewrites for Unstructured Data Processing. arXiv:2512.02289 [cs.DB] https://arxiv.org/abs/ 2512.02289 [49] Karl D. D. Willis, Yewen Pu, Jieliang Luo, Hang Chu, Tao Du, Joseph G. Lambourne, Armando Solar-Lezama, and Wojciech Matusik. 2021. Fusion 360 gallery: a dataset and environment for programmatic CAD construction from human design sequences. ACM Trans. Graph. 40, 4, Article 54 (July 2021), 24 pages. doi:10.1145/ 3450626.3459818
Mitch Adler, Matthew Russo, and Michael Cafarella
[50] Rundi Wu, Chang Xiao, and Changxi Zheng. 2021. DeepCAD: A Deep Generative Network for Computer-Aided Design Models. In 2021 IEEE/CVF International Conference on Computer Vision (ICCV). 6752–6762. doi:10.1109/ICCV48922.2021. 00670 [51] Haoyang Xie and Feng Ju. 2025. Text-to-CadQuery: A New Paradigm for CAD Generation with Scalable Large Model Capabilities. arXiv:2505.06507 [cs.AI] https://arxiv.org/abs/2505.06507 [52] Jingwei Xu, Chenyu Wang, Zibo Zhao, Wen Liu, Yi Ma, and Shenghua Gao. 2025. CAD-MLLM: Unifying Multimodality-Conditioned CAD Generation With MLLM. arXiv:2411.04954 [cs.CV] https://arxiv.org/abs/2411.04954 [53] Yang You, Mikaela Angelina Uy, Jiaqi Han, Rahul Thomas, Haotong Zhang, Yi Du, Hansheng Chen, Francis Engelmann, Suya You, and Leonidas Guibas. 2025. Img2CAD: Reverse Engineering 3D CAD Models from Images through VLM-Assisted Conditional Factorization. In Proceedings of the SIGGRAPH Asia 2025 Conference Papers (SA Conference Papers ’25). Association for Computing Machinery, New York, NY, USA, Article 95, 12 pages. doi:10.1145/3757377.3763891 [54] Zeqing Yuan, Haoxuan Lan, Qiang Zou, and Junbo Zhao. 2024. 3D-PreMise: Can Large Language Models Generate 3D Shapes with Sharp Features and Parametric Control? ArXiv abs/2401.06437 (2024). https://api.semanticscholar.org/CorpusID: 266977564 [55] Zhe Yuan, Jianqi Shi, and Yanhong Huang. 2024. OpenECAD: An efficient visual language model for editable 3D-CAD design. Comput. Graph. 124, C (Nov. 2024), 11 pages. doi:10.1016/j.cag.2024.104048 [56] Shuming Zhang, Zhidong Guan, Hao Jiang, Tao Ning, Xiaodong Wang, and Pingan Tan. 2024. Brep2Seq: a dataset and hierarchical deep learning network for reconstruction and generation of computer-aided design models. Journal of Computational Design and Engineering 11, 1 (01 2024), 110–134. arXiv:https://academic.oup.com/jcde/articlepdf/11/1/110/57275777/qwae005.pdf doi:10.1093/jcde/qwae005