A new wave of AI-powered tools lets engineers generate 3D models from plain-language prompts. The productivity gains are real, but so are the questions about accuracy, liability, and lock-in.
Type a sentence, get a STEP file. That's the pitch behind a growing class of text-to-CAD tools that wire large language models directly into parametric design workflows. Open-source projects like text-to-cad and CADAM now let engineers describe a part in plain English and receive exportable 3D geometry in seconds. Meanwhile, the semiconductor industry's biggest EDA vendors are racing to ship autonomous AI agents that can carry a chip design from specification to manufacturable layout with minimal human intervention.
The appeal is obvious. But engineering is a domain where a misplaced decimal point can mean a recalled product, a failed structure, or worse. As AI agents gain deeper access to CAD toolchains, the central question isn't whether they boost productivity. It's whether the verification workflows around them can keep pace.
What Text-to-CAD Agents Actually Do Now
The text-to-cad plugin, hosted on GitHub, is a useful lens into how these integrations work in practice. It gives AI coding agents (Claude Code, Codex, Cursor, Gemini, Grok) the ability to generate 3D models as STEP, GLB, STL, or 3MF files from natural-language descriptions. It also runs design-for-manufacturing checks, generates engineering drawings, and connects directly to 3D printing, sheet metal, and CNC fabrication services.
The interaction model is conversational. An engineer types a prompt. The agent produces geometry. A local viewer renders the model inline, letting the user orbit, inspect, and iterate without leaving the chat. The plugin runs locally through uv, and the agent can read what the user has selected and see what the user sees, creating a feedback loop that feels closer to pair-designing than batch-processing.
CADAM, another open-source project documented on GitHub, takes a similar approach as a web application. It generates fully parametric OpenSCAD models from single plain-language descriptions, exportable as STL, SCAD, or DXF. Its benchmarks page showcases multi-part machines built from a single prompt.
These tools are impressive demonstrations. They're also early, and the gap between "impressive demo" and "production-ready engineering tool" is where the hard questions live.
The Hallucination Problem Isn't Theoretical
In software development, an AI coding assistant that hallucinates a function call produces a build error. Annoying, but catchable. In CAD, an AI agent that hallucinates a dimension, misinterprets a tolerance, or generates geometry that looks correct but violates a manufacturing constraint produces something far more dangerous: a plausible-looking part that might actually get built.
This isn't a hypothetical concern. As we explored in our earlier reporting on AI hallucinations in academic research, fabricated outputs from language models have already infiltrated peer-reviewed conferences, with over 50 hallucinated citations discovered in ICLR 2026 submissions alone. The pattern is consistent: AI systems generate confident-sounding output that passes casual inspection but fails under scrutiny.
In engineering contexts, the stakes are higher. A hallucinated citation wastes a researcher's time. A hallucinated wall thickness wastes material, delays production, or compromises structural integrity. Text-to-cad includes design-for-manufacturing checks, which is a smart safeguard. But those checks validate against known manufacturing rules. They don't catch every class of error an LLM might introduce — subtle interference fits, thermal expansion mismatches, or load-path assumptions that don't hold under real-world conditions.
The fundamental issue: language models optimize for plausibility, not correctness. In a domain where correctness is non-negotiable, that mismatch demands robust verification layers that don't yet exist as standard practice.
The EDA Industry Shows Where This Is Heading
The semiconductor industry offers a preview of how AI agents scale in engineering toolchains — and what happens when vendors compete on autonomy claims. All three dominant EDA companies — Cadence, Synopsys, and Siemens — now ship agentic AI for chip design, largely built on Nvidia infrastructure, Tom's Hardware reported. Cadence claims its ChipStack agent reached "bounded Level 5" autonomy in one domain, with most capabilities at "advanced Level 4." Synopsys claims L5 for its long-horizon agents. Siemens launched self-verifying loops.
But the claimed speed improvements, Tom's Hardware noted, are vendors' or customers' own figures, often with "up to" or "early evaluation" caveats. These figures frequently measure different things against different baselines, and independent verification is scarce. The only evaluator Synopsys named, AMD, provided an endorsement but no detailed analysis.
This pattern should concern anyone watching text-to-CAD tools mature, since vendors competing on autonomy levels and speed claims without standardized benchmarks leaves engineers unable to make informed comparisons. The EDA space is further along this curve, and its measurement problems are instructive: "different ideas of 'autonomous'" mean these agents all still answer to older, human-verified tools.
Augmenting Judgment vs. Replacing Verification
The most productive framing isn't "AI vs. human designers." It's about where AI agents sit in the verification chain.
A text-to-CAD tool that generates a first-draft model from a prompt, which an engineer then reviews, modifies, and validates? That's augmentation. It compresses the tedious early phase of parametric modeling and lets the engineer focus on judgment calls — material selection, tolerance stacking, assembly fit.
A workflow where the AI agent generates geometry, runs its own DFM checks, and sends the file directly to a fabrication service? That's replacement of verification steps. And it's a workflow these tools already make technically possible. Text-to-cad's direct connection to 3D printing and CNC services means the distance between "AI-generated model" and "manufactured part" can be alarmingly short.
The parallel to AI coding tools is direct. Early GitHub Copilot adoption showed that developers who accepted suggestions without review introduced more bugs than those who treated suggestions as starting points. The same dynamic will play out in CAD, but with physical consequences.
Liability, Lock-in, and the Dependency Trap
When an AI-generated CAD model fails in production, who's responsible? The engineer who approved it? The company that deployed the tool? The AI vendor? Current product liability frameworks weren't designed for this question, and the answer is genuinely unclear.
Tooling lock-in is a related concern, though projects like text-to-cad and LuaCAD are open-source, which helps. LuaCAD, for instance, uses Lua scripting with a Rust engine and can open existing OpenSCAD files, preserving some portability. But as AI agents become more deeply integrated into specific toolchains, the models they produce may carry implicit assumptions about the host environment. A parametric model generated by one agent may not transfer cleanly to another tool's constraint solver.
The EDA industry again offers a cautionary example. Cadence, Synopsys, and Siemens each have proprietary agent architectures tightly coupled to their existing tool suites. Engineers who adopt one vendor's AI agent become more dependent on that vendor's entire stack. The same dynamic is emerging in mechanical CAD, just earlier in its arc.
What Comes Next
The trajectory is clear: AI agents will become standard fixtures in CAD workflows within the next few years. The open-source ecosystem is moving fast, commercial vendors are investing heavily, and the productivity gains for routine modeling tasks are genuine.
But the industry needs three things it doesn't have yet. First, standardized benchmarks for AI-generated geometry accuracy, analogous to what the EDA space is still lacking. Second, clear liability frameworks that account for AI-assisted design decisions. Third, verification tooling that's as sophisticated as the generation tooling — because right now, the ability to create models is outpacing the ability to validate them.
The engineers who thrive in this transition will be the ones who treat AI-generated CAD output the way good developers treat AI-generated code: as a useful draft that earns trust through review, not a finished product that deserves it by default.
