1 Introduction↩︎

Large language models (LLMs) have made rapid progress in program synthesis, tool use, and interactive software automation [1]–[5]. Computer-aided design (CAD), however, remains a difficult target for autonomous generation. A useful engineering CAD artifact is not just a visually plausible mesh. It must be represented as editable parametric B-Rep geometry, respect dimensional and topological constraints, preserve feature dependencies, and compose multiple parts through precise assembly relations.

This gap is especially visible in long assembly workflows. An LLM may emit syntactically valid CadQuery or FreeCAD code while placing a cutter in the wrong coordinate frame, selecting a stale local face, duplicating repeated holes with an incorrect offset, or stacking components at the origin. These errors are often invisible at the token level but fatal at the CAD-kernel level. Existing sequence, sketch, and text-to-CAD systems have shown strong progress on part-level modeling and command generation [6]–[10], yet industrial assemblies require a different form of grounding: the model must repeatedly act in, inspect, and recover from an exact geometric environment.

Embodied CAD addresses this problem by treating CAD generation as closed-loop embodied tool use. The agent receives a natural-language specification and a structured parameter set, chooses the next CAD skill, executes it through a deterministic backend, observes solver feedback, and continues until the assembly is complete. The framework follows the loop

The key design choice is to constrain the model to semantically meaningful CAD skills while leaving fragile geometric bookkeeping to deterministic resolvers and the CAD solver.

The paper makes four contributions. First, we formulate autonomous parametric assembly modeling as a solver-grounded skill-trajectory problem rather than open-loop script generation. Second, we design an L0–L4 CAD skill hierarchy that spans workspace operations, primitive construction, feature machining, spatial assembly, and domain-level macros. Third, we introduce operation-family resolution and solver-derived feedback as a bridge between LLM planning and exact B-Rep execution. Fourth, we evaluate the framework on multi-category industrial assembly tasks with solver-aligned metrics and report both quantitative controller performance and qualitative construction traces.

2 Related Work↩︎

Parametric CAD generation. Large CAD datasets and sequence models have made parametric CAD generation a practical learning problem. ABC provides a large B-Rep-oriented corpus for geometric learning [11]; the Fusion 360 Gallery dataset exposes human design histories for programmatic CAD construction [12]. DeepCAD models CAD commands as a sequence generation problem [6], SkexGen improves sequence generation with disentangled codebooks [7], and Text2CAD maps natural language to CAD command sequences [8]. Recent CAD-code systems further explore vision- and text-conditioned code generation [9], [10]. In contrast, Embodied CAD does not ask the model to emit an entire CAD program in one pass. It constrains generation to solver-checked skill trajectories whose intermediate states can be inspected and repaired.

B-Rep learning and executable structure. Engineering CAD models contain topology, analytic surfaces, curves, feature history, and constraints that are not captured by visual surface similarity alone. BRepNet performs topological message passing over solid models [13]; UV-Net learns from parametric curve and surface domains [14]; SolidGen and BRepGen target direct boundary-representation synthesis [15], [16]. Programmatic approaches such as CSGNet and ShapeAssembly show the value of explicit executable structure [17], [18]. Embodied CAD shares this preference for executable structure but focuses on long, editable assembly workflows in which each intermediate CAD state is validated by a solver.

Assembly generation and tool-using agents. Assembly modeling adds repeated parts, joint relations, and spatial constraints beyond single-part generation. JoinABLe studies bottom-up assembly of parametric CAD joints [19]. Tool-augmented CAD systems, including CAD-Assistant, ArtiCAD, and TOOLCAD, connect foundation models to CAD tools or tool-use training pipelines [20]–[22]. Our work is closest to these tool-augmented systems, but emphasizes typed skill calls, operation-family resolution, and solver-aligned evaluation rather than visual-only judging.

3 Problem Formulation↩︎

Given an industrial modeling request \(x\) and a parameter set \(p\), the goal is to produce an executable trajectory \[\tau= (a_1, \ldots, a_T), \qquad a_t = (\ell_t, f_t, \theta_t),\] where \(\ell_t\) is the skill level, \(f_t\) is a skill or operation family, and \(\theta_t\) contains typed arguments. A CAD kernel \(K\) deterministically updates the state: \[s_t = K(s_{t-1}, a_t).\] A trajectory is solver-feasible if every action executes without kernel error and the final state satisfies task-specific checks such as valid solids, expected components, bounding boxes, feature counts, and assembly completion. The central challenge is that \(\theta_t\) often depends on the current geometric state: a hole center, chamfer target, mirrored instance, or repeated fastener index must be selected consistently with previous operations.

Embodied CAD separates this problem into planning, resolution, and execution. The LLM predicts high-level skills or operation families; deterministic modules derive geometry-dependent arguments; the CAD backend executes each skill; and the feedback is returned to the planner and to the learning objective. This separation reduces hallucinated coordinates and makes failure modes observable.

4 Method↩︎

4.1 Closed-Loop Architecture↩︎

Figure 1 summarizes the architecture. The planner observes the user intent, parameters, construction history, and solver feedback. It selects the next skill or operation family. The resolver maps reusable operation families, such as build_pin_body or cut_hole_grid, to concrete instance identifiers and typed parameters. The executor dispatches the resolved call to the CAD backend. The solver returns structured feedback, including success or failure, object names, validity checks, volumes, bounding boxes, and topology summaries when available.

4.2 Skill Stratification↩︎

A raw CAD scripting space is too large for reliable long-horizon LLM planning. We therefore organize actions into five levels (Table 1). The hierarchy keeps the model’s choices close to engineering operations while preserving enough expressivity to build multi-part assemblies.

4.3 Operation Families and Deterministic Resolution↩︎

Industrial assemblies contain repeated structures: balls in bearings, pins in manifolds, screws in mold plates, guide posts in press machines, and ribs on shafts. Directly predicting instance-specific operation keys entangles semantic intent with fragile indexing. We instead ask the model to predict operation families. The controller resolves a family into the next valid instance using construction state, counters, symmetry rules, and derived geometry. This design preserves the agentic planning role of the LLM while moving coordinate-sensitive computations into deterministic modules.

For example, after the planner predicts a family such as place_guide_post, the resolver determines which post is next, retrieves the corresponding plate corner, computes the local axis and clearance, and produces the typed skill call. The solver then checks whether the post intersects the expected plate stack and whether the resulting solid remains valid. Failures are returned as structured feedback rather than hidden in a failed final script.

4.4 Learning from Solver Feedback↩︎

We use solver feedback in two ways. First, supervised fine-tuning warms up the planner on validated trajectories. Second, GRPO-style refinement samples multiple candidate actions for the same state and scores them with a structured reward: \[R = w_f R_{\mathrm{format}} + w_p R_{\mathrm{policy}} + w_e R_{\mathrm{exec}}.\] Here \(R_{\mathrm{format}}\) checks whether the model emits a parseable action block, \(R_{\mathrm{policy}}\) checks whether the selected skill or operation family matches the expected transition, and \(R_{\mathrm{exec}}\) measures whether the resolved action executes successfully in the CAD backend. The relative reward within each group updates the policy. We report skipped-update and fallback-SFT rates because a high parse rate alone does not guarantee informative reward variance.

5 Benchmark and Metrics↩︎

The benchmark is organized around executable CAD-skill trajectories. Each task provides a natural-language industrial specification and a structured parameter set. The system must generate a sequence of skill calls that can be resolved and executed by the FreeCAD backend. The current task families are:

Standard mechanical assemblies: bearing tasks involving coaxial rings, polar ball arrays, repeated separators, editable ring dimensions, and chamfered mechanical details.

Industrial equipment assemblies: press-machine, cooling-tower, and linear-manifold tasks involving layered structures, repeated connectors, springs, guide posts, fans, holes, and pipe-like features.

Mold assemblies: mold-machine and mold-core insert tasks involving plate stacks, guide posts, hole grids, counterbores, grooves, spline ribs, and editable core-shaft layouts.

We evaluate two evidence levels. The solver-execution level measures whether a resolved trajectory executes in the CAD backend. The learned-policy level measures whether an SFT or GRPO controller predicts the correct next skill or operation family. The distinction is important: deterministic strong-planner trajectories test the capacity of the skill library and resolver, whereas learned-policy metrics measure how much of the planning decision can be delegated to the model.

Metrics are solver-aligned. Valid/executable rate checks parseability or FreeCAD execution success. Skill accuracy checks whether the predicted skill matches the target. Operation-family accuracy checks the reusable family. Exact policy accuracy requires action, skill, and family to be correct for the current state. Task completion evaluates all steps in a full workflow when the workflow log is available. For GRPO, we additionally report group-valid rate, group-exact rate, skipped-update rate, and fallback-SFT rate.

6 Results↩︎

6.1 Solver-Aligned Performance↩︎

Table 2 shows the main quantitative results. Deterministic strong planning executes all evaluated workflow families in the current benchmark. The weak-planner SFT policy reaches 93.1% exact accuracy on the state-policy benchmark, and GRPO refinement gives a small gain to 93.2%. The direct skill-family SFT model is more challenging because it must predict the family directly under boundary, random-parameter, and paraphrase stress tests; it reaches 76.6% exact accuracy in the aggregate.

The GRPO run contains 18,335 candidate groups. Its group-valid rate is 100.0%, and its group-exact rate is 73.5%. The skipped-update rate is 68.3%, and the fallback-SFT rate is 10.3%. These diagnostics indicate that format validity is not the bottleneck; the main learning challenge is obtaining reward variance that distinguishes plausible but geometrically incorrect next actions.

6.2 Task-Level Evidence and Ablations↩︎

Table 3 breaks the evidence down by controller and task family. The strong-planner rows confirm that the skill library and deterministic resolver can generate complete solver-checked assemblies for the evaluated families. The learned-policy rows show that exact next-action prediction remains task dependent. Bearing tasks are relatively regular because repeated features follow polar patterns, while press-machine and mold-machine tasks require more mixed feature orders and spatial relations.

The ablation trend supports the design choice behind operation families. Direct family prediction exposes the model to many similar but index-sensitive decisions, producing lower exact accuracy. The weak-planner state policy predicts a compact controller action and leaves deterministic geometry and instance resolution to the controller, which improves exact state-policy performance. GRPO refinement provides a limited gain in the current logs, but the skipped-update rate suggests that future reward shaping should create more informative contrasts among candidate actions.

6.3 Qualitative Analysis↩︎

Figure 2 visualizes intermediate states rather than only final renders. This is useful for CAD-agent evaluation because many failures occur before the final view: a guide post can be created at the wrong height, a cutter can remove the wrong plate, or an array can be mirrored around the wrong origin. Intermediate solver-checked snapshots make these errors diagnosable.

Figure 3 compares same-prompt outputs against paper-inspired ArtiCAD-style and TOOLCAD-style proxy baselines rendered in the same viewer. These proxy columns are not official reproductions and should not be interpreted as definitive baseline numbers. They are included as diagnostic comparisons for visual feature coverage under the same prompts. The key difference is that Embodied CAD produces executable skill workflows, whereas the proxy outputs are evaluated by visual coverage only.

6.4 Failure Modes↩︎

The remaining failures fall into four recurring categories. Family confusion occurs when the model selects a plausible but wrong next operation, such as a chamfer before all cuts have been applied. Index ambiguity occurs when repeated instances are not grounded to the construction state. Coordinate-frame errors occur when local and global frames are mixed, especially for mirrored or rotated features. Reward sparsity occurs when many sampled candidates are parseable and executable but have identical group rewards. Operation-family resolution reduces the second and third categories, while richer solver diagnostics are needed for the first and fourth.

7 Discussion and Limitations↩︎

Embodied CAD is most effective when the assembly can be decomposed into reusable engineering operations. This is also its main limitation: new domains require new skills, resolvers, and validation checks. The current benchmark emphasizes parametric mechanical and mold-oriented assemblies; free-form surfacing, complex organic shapes, tolerance-stack analysis, and downstream manufacturing simulation are outside the present scope. The proxy comparisons are useful for debugging but should be replaced with official implementations or standardized benchmark submissions when available. Finally, the current GRPO results show that solver feedback is necessary but not sufficient: a training signal must distinguish geometrically meaningful alternatives, not only executable syntax.

8 Conclusion↩︎

We introduced Embodied CAD, a closed-loop framework for autonomous parametric B-Rep assembly modeling with LLM agents. By separating LLM planning, deterministic operation-family resolution, and CAD-kernel execution, the framework converts open-loop script generation into solver-grounded skill trajectories. Experiments on multi-category industrial assemblies show that the skill library and resolver can execute complete workflows, while learned policies achieve high valid rates but still face long-horizon exact-action errors. The results suggest that future text-to-CAD systems should evaluate not only visual plausibility, but also solver execution, editability, and intermediate state validity.

References↩︎