🤖 AI

ArtisanCAD: An Industrial-Level CAD Agent with Expert-Grounded Knowledge Distillation

ArtisanCAD is an industrial-level CAD agent that leverages expert-grounded knowledge distillation and an executable intermediate representation (CAD-IR) to transform ambiguous natural language prompts and expert procedural data into production-ready, editable B-Rep models with improved accuracy and robustness.

Original authors: Yunhan Xu, Qifeng Wu, Xunjin Li, Yuanwei Bin, Qingsong Yao, Jianghang Gu, Guan Wang, Weihao Lv, Huiyu Yang, Wenfa Luo, Jiao Xiang, Yuntian Chen, Shiyi Chen

Published 2026-07-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yunhan Xu, Qifeng Wu, Xunjin Li, Yuanwei Bin, Qingsong Yao, Jianghang Gu, Guan Wang, Weihao Lv, Huiyu Yang, Wenfa Luo, Jiao Xiang, Yuntian Chen, Shiyi Chen

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot how to build a complex piece of furniture, like a custom car door or an engine bracket. You can't just say, "Make a door." The robot needs to know exactly how to build it: where to draw the first line, which hole to drill first, and how to make sure the parts fit together perfectly. If you give vague instructions, the robot might build a wobbly mess or get stuck halfway through.

This paper introduces ARTISANCAD, a smart robot assistant designed to solve this problem for industrial engineers. Here is how it works, broken down into simple concepts:

1. The Problem: Vague Instructions vs. Expert Secrets

Current AI tools are good at turning simple text into 3D shapes, but they struggle with real-world industrial parts.

The Issue: If you tell a standard AI, "Make a hinge plate deeper," it might guess the wrong shape or forget to add necessary holes. It lacks the "muscle memory" of a human expert.
The Missing Piece: Real engineers have years of experience. They have recorded videos of their work, written notes on drawings, and saved "macro logs" (digital recordings of their mouse clicks and commands). Existing AI tools ignore this treasure trove of knowledge.

2. The Solution: The "Master Recipe" (CAD-IR)

The core innovation of ARTISANCAD is something called CAD-IR (Computer-Aided Design Intermediate Representation). Think of this as a Master Recipe or a Blueprint for a Blueprint.

Instead of the AI trying to guess the final shape from scratch, it uses CAD-IR to organize the process:

It's a Translator: It takes the messy, real-world recordings of an expert engineer (like a video of them using CATIA software) and turns them into a clean, step-by-step list of instructions.
It's a Checklist: It doesn't just say "make a hole." It says, "First, draw a circle. Second, make sure it's centered. Third, drill it. Fourth, check if it's smooth."
It's a Skill Library: The AI turns these recipes into "Skills." If an engineer knows how to build a car door, that "Skill" is saved. Later, if someone asks for a wider door, the AI doesn't start from zero; it grabs the "Door Skill" and just tweaks the width.

3. How the Robot Works (The Loop)

When a user gives a request (e.g., "Make this car hood panel taller"), ARTISANCAD goes through a cycle:

Retrieval: It looks in its library for the "Hood Panel Skill" created by a human expert.
Adaptation: It takes the expert's "Master Recipe" (CAD-IR) and updates the numbers based on the user's request (e.g., "Change height from 10cm to 15cm").
Execution: It sends these updated instructions to a professional software backend (CATIA) to actually build the 3D model.
The "Eyes" (Visual Feedback): This is a crucial step. The robot generates the model, takes pictures of it from eight different angles (front, back, top, side, etc.), and shows them to an AI "inspector."
- The Inspector asks: "Does this look like a tall hood panel? Did we accidentally delete the holes?"
- If the answer is "No," the robot rewrites the "Master Recipe" (CAD-IR) and tries again.

4. The Results: From "Maybe" to "Production-Ready"

The paper tested this in two ways:

The "Blind" Test: They asked the AI to build shapes from vague descriptions without using any expert help.
- Without the "Master Recipe" (CAD-IR): The AI made mistakes, missing details like holes or thin supports.
- With the "Master Recipe": The AI built much more accurate shapes, filling in the missing details that the vague prompt didn't specify.
The "Real World" Test: They used it on four complex car parts (like a hood panel and a lock plate).
- They recorded human experts building these parts, turned those recordings into "Skills," and then asked the AI to make variations (e.g., "Make it wider," "Make it deeper").
- Result: The AI successfully created new, editable, professional-grade 3D models that engineers could actually use. Without the expert "Skills," the AI failed completely because the instructions were too complex to guess.

Summary Analogy

Imagine you want to bake a complex cake.

Old AI: You say, "Make a cake." The AI guesses the ingredients and bakes a lumpy mess because it doesn't know the order of mixing or baking times.
ARTISANCAD: You say, "Make a cake, but taller." The AI pulls out a Master Recipe written by a master baker (the expert). It knows exactly which pan to use and how to adjust the baking time for a taller cake. It bakes the cake, takes a picture to check if it rose correctly, and if it's slightly off, it adjusts the recipe and bakes again until it's perfect.

In short: ARTISANCAD bridges the gap between vague human ideas and precise industrial manufacturing by teaching AI to learn from the "muscle memory" of human experts, turning their experience into reusable, editable digital skills.

Technical Summary: ARTISANCAD

Problem Statement

Industrial Computer-Aided Design (CAD) for sectors like automotive and aerospace requires long-horizon procedural modeling, robust feature dependencies, and production-grade Boundary Representation (B-Rep) execution. Unlike casual 3D modeling, industrial CAD involves complex workflows with sketches, constraints, and editable parametric geometry.

Existing text-to-CAD methods, while promising, face significant limitations when applied to industrial contexts:

Ambiguity Handling: They struggle when user prompts are ambiguous, underspecified, or describe only high-level design intent without low-level construction details.
Lack of Expert Knowledge: They rarely exploit the rich procedural knowledge naturally available in industrial workflows, such as CATIA operation recordings, macro logs, drawing notes, and engineering descriptions.
Complexity Gap: Current methods are often evaluated on simple parts or short sketch-extrude programs, failing to handle the long-horizon procedures, curved B-Rep surfaces, and hybrid operations required for complex industrial components.

Methodology

The paper presents ARTISANCAD, an industrial-level CAD agent that grounds generation in expert procedural knowledge through a mechanism called Expert-Grounded Knowledge Distillation. The system operates via two primary stages:

1. Expert-to-Skill Acquisition (Offline)

This stage transforms one-off expert CAD records into reusable, parameterized skills.

Input: Heterogeneous expert data including CATIA macro recordings, drawing notes, feature trees, and engineering descriptions.
Process: A code-oriented agent (Codex-xHigh) parses these records into structured modeling procedures.
Output (Part Skill): A skill $s$ $s$ is defined as a tuple $(D_s, O_s, P_s, Z_s)$ $(D_{s}, O_{s}, P_{s}, Z_{s})$ :
- $D_s$ : Basic part description (functional role, geometric characteristics).
- $O_s$ : Expert operation order (a reusable procedural prior, not a fixed script).
- $P_s$ : Parameter schema (editable parameters like width, radius, with valid ranges).
- $Z_s$ : Template CAD-IR (the core executable procedural template).

2. Skill-Guided Variant CAD Generation (Online)

Given a user request for a new variant (e.g., "make the plate deeper"), the agent does not generate a backend script from scratch. Instead, it adapts an existing skill.

Skill Retrieval: The agent retrieves the most relevant skill from the knowledge base based on the user query.
CAD-IR Instantiation: The agent instantiates the template CAD-IR ( $Z_s$ ) with the new request. This fills missing parameters, updates operation arguments, and preserves expert-derived dependencies and verification rules.
CAD-IR (Intermediate Representation): The core innovation is CAD-IR, an executable procedural representation defined as $Z = (P, T, O, E, V)$ $Z = (P, T, O, E, V)$ :
- $P$ : Global part parameters.
- $T$ : Required backend tools (MCP bindings).
- $O$ : Ordered list of CAD operations (intent, tool calls, arguments, outputs, dependencies, verification).
- $E$ : Generated entities and dependency relations.
- $V$ : Verification rules.
Backend Execution: The generated CAD-IR is dispatched to a CATIA-MCP backend, which translates IR operations into native CATIA commands to produce editable B-Rep models.
Vision Feedback Loop: A lightweight multi-view visual feedback system evaluates the generated model. If inconsistencies are found, the agent rewrites the CAD-IR (not the backend script) to correct parameters or operations, iterating until the model passes visual and structural checks.

Key Contributions

Expert-to-Skill Acquisition Mechanism: A novel workflow that distills heterogeneous expert knowledge (macros, logs, notes) into CAD-IR and reusable parameterized skills. This allows expert modeling procedures to be adapted to new variant requests within the same component family.
ARTISANCAD Agent: A skill-guided industrial CAD agent with multi-backend support. It retrieves skills, instantiates and revises procedures at the IR level, and executes them via a dedicated CATIA-MCP backend. It incorporates a multi-view vision feedback loop for iterative refinement.
CAD-IR as a Procedural Scaffold: The paper demonstrates that representing CAD generation as an explicit, executable intermediate representation bridges the gap between vague textual descriptions and complex, executable CAD construction.

Experimental Results

The authors evaluated ARTISANCAD on two fronts:

1. Public Text2CAD Benchmark

Setup: Tested on 100 intermediate-level prompts without using any expert knowledge base (isolating the effect of CAD-IR).
Findings:
- Chamfer Distance (CD): Reduced mean CD from 14.83 (ARTISANCAD w/o IR) to 9.88 (ARTISANCAD with IR).
- Solid IoU: Improved from 0.614 to 0.646.
- Comparison: ARTISANCAD with IR significantly outperformed baselines like Text2CAD (CD 29.80) and CAD-Coder (CD 14.16).
- Significance: Even without expert skills, CAD-IR provides a superior procedural scaffold for converting ambiguous prompts into executable operations.

2. Industrial Automotive Components

Setup: Applied to four complex automotive parts (Hinge Reinforcement Plate, Hood Panel, Outer Panel Bracket, Lock Reinforcement Plate). Expert macro recordings were distilled into skills.
Findings:
- ARTISANCAD successfully generated editable, production-ready B-Rep models for new variant requests (e.g., changing depth, width, or hole layouts) by adapting the distilled skills.
- Ablation: Attempts to generate these complex components without skill-guided CAD-IR failed, as the agent could not infer the necessary long-horizon operation orders and dependencies from short prompts alone.

Significance and Claims

The paper claims that ARTISANCAD represents a shift from generating isolated benchmark CAD sequences to production-oriented CAD automation.

Bridging the Gap: The system effectively bridges the gap between ambiguous user intent and the rigorous, long-horizon procedures required in industrial design.
Knowledge Reuse: By distilling expert macro recordings into reusable skills, the system allows engineers to leverage accumulated procedural knowledge rather than rediscovering workflows from scratch.
Robustness: The use of CAD-IR as an intermediate layer allows for operation-level revisions and visual feedback integration, making the system more robust to ambiguous inputs and execution errors compared to direct backend script generation.

The authors conclude that while current text-to-CAD systems are limited by their lack of procedural priors, ARTISANCAD demonstrates that grounding generation in expert-derived skills and executable intermediate representations is essential for scaling CAD agents to practical industrial workflows.