LLMs for CAD: From Script Generation to a Gateway for Physical AI
Large language models can connect design intent to controlled CAD operations without replacing geometric kernels. This article examines the architecture, declarative scripting, validation workflows, data governance, and evaluation metrics needed to deploy LLM-powered CAD. It also outlines how integrated 2D, 3D, and cloud workflows can turn design scripts into reusable assets and prepare industrial data for simulation, robotics, and physical AI.
1. Why CAD Needs a Semantic Compiler
CAD software has long faced a structural challenge: geometric kernels, constraint solvers, and feature-based modeling systems are highly specialized, but interacting with them requires considerable expertise. Writing scripts is costly, and coordinating work across design stages is complex. Designers must translate intent into menu actions, parameter settings, or scripts, while organizations need to turn individual expertise into reusable design assets.
The role of a large language model (LLM) is not to replace the geometric kernel. Instead, it can act as a semantic compiler: translating natural language, drawings, point clouds, model trees, and manufacturing constraints into controlled sequences of CAD operations. Constraint validation, permission checks, and rollback planning must take place before execution.
Technically, this process has three layers:
- Intent understanding: Parse a request such as “Change the bracket thickness to 3 mm and check for interference” into target objects, operation types, parameters, and units.
- Operation planning: Map the intent to atomic operations, such as parameter changes, feature regeneration, material replacement, and scene layout adjustments.
- Execution and verification: Execute operations through a geometric kernel adapter, using constraint checks, collision detection, version snapshots, and audit logs to maintain control.
The LLM does not modify models arbitrarily. It generates scripts within a controlled domain-specific language (DSL) and tool-calling framework. The surrounding system validates and executes those scripts.
2. Beyond Script Generation: Managing the Script Lifecycle
The first capability LLMs bring to CAD is script generation. Developers can define a modeling-oriented DSL that converts natural-language requests into structured operations. For example, a request to modify a component’s geometry, material, and scene placement should produce a verifiable operation plan—not free-form prose.
The second capability is script lifecycle management. Scripts need version control, parameter templates, access controls, regression testing, execution monitoring, and rollback mechanisms. They become enterprise design assets only when generation is part of a complete workflow:
Generate → Review → Release → Execute → Monitor → Reuse
The goal is not to produce longer scripts. It is to make operations atomic, constraints explicit, and execution reversible.
For example:
- A wall-thickness change must specify units and a minimum thickness constraint.
- A material replacement must identify the material library entry and its applicable use.
- A layout adjustment must trigger collision detection.
Responsibilities should remain distinct: the LLM maps semantics to a plan, the geometric kernel performs geometric calculations, and the platform handles permissions, auditing, and resource scheduling. This separation helps prevent model hallucinations from directly affecting production models.
3. Reference Architecture: Multimodal Inputs, Tool Calling, and Geometry Adapters
A practical LLM-powered CAD architecture typically includes five modules.
Multimodal Input Layer
This layer accepts natural language, 2D drawings, 3D model trees, bills of materials (BOMs), manufacturing constraints, point clouds, and simulation results.
Inputs require format normalization, consistent units, sensitive-data redaction, and binding to specific data versions.
Industrial Knowledge Base
The knowledge base captures design standards, standard-component libraries, material libraries, constraint rules, historical scripts, and failure cases.
It should be more than a document collection. It needs searchable structured rules and referenceable excerpts from relevant cases.
LLM Orchestration Layer
This layer handles intent recognition, task decomposition, tool selection, parameter extraction, and result explanation.
Complex tasks may use multistep planning and self-checking, but the final output must remain restricted to an approved set of operations.
Geometric Kernel Adapter
The adapter translates abstract operations into concrete modeling functions, including parameter modification, feature regeneration, Boolean operations, assembly constraints, material assignment, and scene transformations.
It should support dry runs, snapshots, rollback, and difference comparisons.
Execution and Governance Layer
This layer manages permission checks, resource quotas, execution queues, audit logs, exception alerts, and human review.
Production workflows should default to preview before commit, with additional confirmation required for high-risk operations.
For cloud deployment, general-purpose compute, object storage, logging, and monitoring services—including those offered by Baidu AI Cloud—can support an elastic, observable design collaboration environment. Specific interfaces, quotas, and service availability must be checked against the official documentation.
Model services, geometric computation, and data storage should be decoupled so that a single point of failure does not compromise design assets.
4. A Controlled Scripting DSL and Execution Workflow
A declarative DSL can reduce the risk of an LLM generating uncontrolled executable code. The model describes intended operations, and an executor validates them.
The following structure is illustrative and does not represent a specific product API:
{"intent": "modify_part","target": {"id": "bracket_assembly"},"operations": [{"op": "set_parameter", "path": "bracket.thickness", "value": 3.0, "unit": "mm"},{"op": "replace_material", "path": "bracket.surface", "material": "aluminum_alloy"},{"op": "transform", "path": "bracket.position", "translate": [0, 0, 10], "unit": "mm"}],"constraints": {"min_thickness": 2.5,"collision_check": true,"preserve_mates": true}}
The executor can follow the validation and execution pattern illustrated below:
ops = parse_model_output(response)for op in ops.operations:assert op.op in ALLOWED_OPSassert check_units(op)assert check_constraints(op, current_model)dry_run_plan = dry_run(op, current_model)snapshot = create_snapshot(current_model)execute_with_plan(dry_run_plan)if not verify_geometry(current_model, ops.constraints):rollback(snapshot)raise ReviewRequired("Constraint validation failed; human review required")commit_with_audit_log(ops, snapshot)
The essential sequence is to parse the model output, validate it against rules, and only then allow geometric execution. Failures must support rollback and retain an audit trail. For multi-operation scripts, the execution plan must cover the complete operation sequence rather than only the final operation.
Batch scripts also require regression tests. Given standard models and expected outcomes, the test suite should verify that scripts remain reliable when parameters, units, and assembly relationships change.
5. Integrating 2D, 3D, and Cloud Workflows
To improve design efficiency, LLM capabilities must extend beyond isolated script generation and become part of an integrated 2D, 3D, and cloud workflow.
- 2D drawings provide engineering representation and annotations.
- 3D models represent geometry and assemblies.
- Cloud platforms manage versions, permissions, collaboration, and compute scheduling.
A shared data model should include, at minimum, object identifiers, geometric parameters, material properties, assembly constraints, version lineage, approval status, and audit records.
In collaborative workflows, an LLM can help draft change descriptions, compare versions, extract design intent, recommend reusable standard components, and convert natural-language change requests into script plans awaiting approval.
The platform distributes approved plans to authorized execution nodes and records:
- Who changed which component, and when.
- Which constraint checks were triggered.
- Whether execution required rollback.
This makes CAD usage measurable beyond menu clicks. More meaningful indicators include script adoption, design asset reuse, first-pass change approval, and collaboration cycle time.
6. Multimodal Industrial Data and the Boundaries of AI
Multimodal models can broaden AI applications in industrial software, but data governance is a prerequisite.
Different data sources must be aligned within a shared semantic framework:
- Symbols, annotations, and layers in 2D drawings.
- Feature trees, assembly relationships, and constraints in 3D models.
- Tolerances and material requirements in manufacturing documents.
- Scanned geometry in point clouds.
- Stress and temperature distributions in simulation results.
Organizations need data classification, redaction, authorization, and traceability mechanisms. Sensitive models should not be sent directly into environments outside their control.
Initial applications should prioritize tasks with verifiable outputs, including:
- Standard-component replacement.
- Parametric design variants.
- Drawing annotation checks.
- Preliminary assembly interference screening.
- Material and scene layout adjustments.
- Script comment generation.
- Change impact analysis.
Final conclusions about safety, structural strength, or manufacturing feasibility must be reviewed using specialized tools and qualified engineers. The LLM provides candidate solutions and explanations; it does not replace accountable decision-makers.
7. Evaluation Metrics and Risk Governance
LLM-powered CAD should be evaluated through several layers of metrics.
| Category | Example metrics |
|---|---|
| Task performance | First-pass script success, constraint validation pass rate, rollback rate, human review rate |
| Efficiency | Modeling cycle time, change response time, standard-component reuse |
| Quality | Missed interference rate, unit error rate, explainability of version differences |
| Business outcomes | Script adoption, cloud collaboration activity, paid AI feature conversion, renewal rate |
Every metric should be tied to a baseline and a staged rollout. A successful demonstration is not a substitute for production validation.
Risk governance must address hallucinations, unauthorized execution, data leakage, script supply-chain risks, and missing audit records. Relevant controls include:
- Operation allowlists and least-privilege permissions.
- Two-person review for sensitive changes.
- Execution sandboxes.
- Snapshot-based rollback.
- Tamper-resistant logs.
- Structured validation of model outputs.
- Sensitive-data redaction and data-localization policies.
High-risk geometric modifications should not be committed automatically by default. They should follow a semi-automated workflow:
Generate a plan → Obtain human confirmation → Execute
8. CAD as a Gateway to Physical AI
Over the longer term, CAD is more than a drafting tool. It is one entry point for digitizing the physical world.
Physical AI and embodied intelligence require geometry, materials, assembly constraints, scene layouts, and physical properties. Much of this information already exists in industrial design data.
LLMs provide a semantic interface that converts natural-language tasks into executable modeling and simulation operations. CAD and cloud platforms provide structured world models and versioned assets. Simulation and robotics systems then consume those assets.
Together, these systems can form a semantics–geometry–physics loop that supports more complex applications involving the physical world.
Assessing the Business Impact
For industrial software companies, an AI transition must be supported by more than a compelling narrative.
Business and valuation analysis should distinguish cash reserves, existing subscription revenue, the share of revenue from cloud offerings, and incremental AI revenue. Relevant indicators include annual recurring revenue (ARR), renewal rates, script adoption, R&D investment, and progress in ecosystem collaboration.
Companies with strong cash reserves have more room to experiment. However, AI development, data governance, and ecosystem investment can also put pressure on near-term margins.
Assessment should therefore focus on verifiable product capabilities, customer adoption, and revenue composition—not on a single AI theme.
9. A Three-Stage Implementation Roadmap
Stage 1: Controlled Script Generation and Validation
Start with low-risk tasks such as standard-component replacement, parameter changes, and material adjustments.
Establish a closed-loop process for script generation, validation, execution, and rollback.
Stage 2: Script Lifecycle Management and Integrated Collaboration
Connect script workflows with 2D, 3D, and cloud collaboration.
Build template libraries, regression tests, permission controls, audit capabilities, and version comparisons so that scripts become reusable, governed design assets.
Stage 3: Multimodal Data Workflows and Physical AI Interfaces
Standardize geometry, materials, constraints, and scene assets. Make these assets available to simulation, robotics, and digital twin workflows through a governed industrial data lifecycle.
Each stage needs a defined rollout scope, evaluation metrics, and a rollback plan. The objective is not simply to add an LLM to CAD, but to introduce its capabilities into production in a way that remains controlled, auditable, and scalable.
