Technical Summary: CADDesigner

Problem Statement

Conceptual Computer-Aided Design (CAD) modeling typically requires high levels of expertise to translate abstract or incomplete specifications into precise parametric 3D models. Traditional CAD platforms rely on manual, iterative workflows that are time-consuming and error-prone for novice users. While recent advances in Large Language Models (LLMs) offer opportunities for automation, existing approaches face significant hurdles:

1. Data Scarcity & Resource Intensity: Fine-tuning open-source LLMs for CAD requires substantial GPU resources and high-quality, diverse training datasets, which remain scarce.
2. Representation Limitations: Traditional parametric modeling approaches often support only a narrow set of operations (e.g., sketching and extrusion) and struggle with complex modeling procedures.
3. Context Ambiguity: Existing CAD Software Development Kits (SDKs) like CadQuery often rely on implicit context (fluent APIs) or overloaded symbolic operators, making it difficult for LLMs to track intermediate modeling states, leading to ambiguity and reduced reliability in generated code.

Methodology

The authors propose CADDesigner, an LLM-powered agent framework designed for conceptual CAD model generation. The system accepts multimodal inputs (textual descriptions and sketches) and engages in interactive dialogue to refine design requirements.

1. Agent Architecture (ReAct Paradigm)

CADDesigner employs a ReAct-style agent that orchestrates the modeling process through iterative reasoning, tool execution, and feedback refinement. The workflow involves:

• Requirement Refinement ($T_1$): Converts multimodal user inputs into detailed design specifications through interactive dialogue.
• Knowledge-Constrained Code Generation ($T_2$): Generates executable CAD modeling code by retrieving relevant function annotations and case examples from a structured knowledge base.
• Command Execution ($T_3$): Runs the generated Python code to produce CAD models.
• Visual Feedback ($T_4$): Renders multi-view snapshots of the generated model and uses a visual question-answering mechanism to diagnose errors and determine if the model satisfies user intent. If the model fails, the feedback guides the agent to refine the code iteratively.

2. Explicit Context Imperative Paradigm (ECIP)

A core innovation is the Explicit Context Imperative Paradigm (ECIP), a novel representation style implemented via a lightweight API layer (SimpleCADAPI) built on top of CadQuery.

• Explicit State Transitions: Unlike CadQuery's fluent API which relies on implicit internal state, ECIP enforces explicit passing of all input objects and parameters to each operation ($S_{k+1} = g_k(S_k, p_k)$).
• LLM-Friendly Design:
  • Structured Error Handling: Errors are returned as structured triples (Cause, Location, Corrective Action) to facilitate automated debugging.
  • Explicit Type Annotations: Function names follow a strict pattern (ActionName_rReturnType) to eliminate type ambiguity (e.g., distinguishing between Wire and Edge).
  • Self-Evolving Operations: The system supports defining composite operations (e.g., a "flange" or "screw") that can be reused, allowing the agent to accumulate and leverage domain knowledge.

3. Knowledge Base and Retrieval

The system utilizes a structured knowledge base ($\mathcal{K}$) containing function annotations and basic model cases. This is integrated via Retrieval-Augmented Generation (RAG) to provide semantic and structural references, ensuring the generated code aligns with API semantics and reduces hallucinations.

Key Contributions

1. CADDesigner Framework: A general-purpose agent that integrates requirement analysis, knowledge-constrained code generation, and vision-based error correction to generate CAD scripts from multimodal inputs.
2. Explicit Context Imperative Paradigm (ECIP): A new code generation paradigm that decouples CAD operations, improves code quality through explicit type annotations and error representations, and supports a wide range of operations (extrusion, revolution, fillet, lofting, etc.).
3. Iterative Visual Feedback: A mechanism that uses multi-view rendering and visual question generation to validate model geometry against user intent, enabling self-correction without human intervention during the loop.
4. Structured Knowledge Accumulation: A mechanism to store successful design cases in a structured knowledge base, facilitating continual learning and improvement of code generation.

Experimental Results

The authors evaluated CADDesigner on the DeepCAD dataset (approx. 178K models), using a test subset of 1,000 models for comparison with baselines and 200 models for ablation studies.

• Performance vs. Baselines: CADDesigner outperformed representative baselines (Text2CAD, cadrille, CADCodeVerify) in geometric fidelity metrics (IoU, Chamfer Distance, Hausdorff Distance) and semantic alignment. Notably, while cadrille achieved high syntactic success (SUC), its outputs often lacked semantic alignment with the input instructions.
• Ablation Studies:
  • ECIP Components: Removing structured error handling or type annotations significantly degraded performance (lower Pass@1, higher retry counts, lower SUC), confirming the necessity of explicit context and error signals.
  • Input Modalities: The combination of text and image inputs yielded the best results, demonstrating that visual cues resolve ambiguities that text alone cannot.
  • LLM Backends: The system demonstrated robust performance across different LLM backends (Claude-4-Sonnet, Gemini-2.5-Pro, GPT-5.2-Codex), with Claude-4-Sonnet showing slightly superior geometric fidelity.
• Comparison with Other Paradigms: When compared to CadQuery and build123d representation styles within the same agent framework, ECIP achieved the highest Intersection over Union (IoU) and Success Rate (SUC), indicating that explicit context representation is superior for LLM-driven generation despite build123d's faster latency.

Significance and Claims

The paper claims that CADDesigner successfully lowers the entry barrier for conceptual CAD modeling by automating the translation of abstract ideas into precise parametric models. Its significance lies in:

• Reducing Expertise Requirements: By handling iterative refinement and error correction autonomously, it enables users with limited CAD expertise to generate complex 3D models.
• Improving Code Reliability: The ECIP paradigm addresses the specific limitations of LLMs in tracking implicit state, resulting in more reliable and interpretable code generation compared to existing fluent or symbolic APIs.
• Scalability: The system supports a broad range of operations and standard components (e.g., flanges, screws), moving beyond simple extrusion-based modeling.

The authors acknowledge limitations, noting that end-to-end latency remains non-negligible for complex models and that the current framework lacks specific industrial domain knowledge (e.g., manufacturing constraints, tolerances). Future work aims to incorporate point cloud inputs and optimize inference efficiency for industrial applications.