Can text-to-CAD handle assemblies?

No, text-to-CAD cannot handle assemblies. Not in 2026, not from any tool I've tested, not even close. Every current text-to-CAD tool generates single parts: one body, one STEP file, no mates, no constraints, no component relationships. I found this out the obvious way, by asking Zoo.dev to generate "a simple hinge assembly with a pin, two leaves, and a bushing." What I got back was a single solid body that vaguely resembled a hinge in the same way a snowman vaguely resembles a person. The leaves were fused together. There was no pin. The bushing was a decorative ring attached to the outside. It was a sculpture of the idea of a hinge, not a mechanism.

That was six months ago, and I've retried the same experiment a few times since. The results haven't changed. The tools generate shapes, not assemblies, and the difference is fundamental enough that a prompt rewrite won't fix it.

What assembly design actually requires#

An assembly in CAD isn't just multiple parts sitting in the same file. It's a system of relationships.

Each part exists as a separate component with its own geometry, its own feature tree, its own material assignment. Parts connect to each other through mates or constraints: a bolt passes through a clearance hole and threads into a tapped hole, with a concentric mate aligning the bolt axis to the hole axis and a coincident mate seating the bolt head against the surface. A shaft fits into a bearing bore with a press fit, constrained concentrically and axially. A lid sits on an enclosure, aligned by a tongue-and-groove or a step joint, held by screws in a bolt pattern that matches between the two parts.

These relationships carry engineering meaning. A concentric mate means two features share an axis. A coincident mate means two faces touch. A tangent mate means a curved surface contacts a flat one. The mate types communicate how the assembly goes together, how it moves, and where the critical interfaces are.

Beyond mates, assemblies require interference checking (do any parts collide when assembled?), clearance checking (is there enough room for tools and hands during assembly?), motion simulation (does this linkage actually move the way it should?), and a bill of materials (what parts, how many, what material, from where?). In production work, you also need exploded views, assembly instructions, and a component numbering scheme that connects to your PLM system.

Text-to-CAD tools produce none of this. They generate one shape. A bracket. An enclosure. A standoff. The shape has no knowledge of what it connects to, what it fits inside, or what's supposed to move relative to what.

Why this is harder than single-part generation#

The text-to-CAD limitations are well documented for single parts, but assemblies multiply every one of those problems.

For a single part, the AI needs to get the geometry roughly right. For an assembly, the AI needs to get the geometry right on every part, and it needs to get the relationships between parts right. A 0.5mm error on a bracket dimension might be tolerable. A 0.5mm error on a mating interface means the parts don't fit together. The tolerance for error shrinks dramatically when multiple components have to interact.

The training data problem is also worse for assemblies. Single-part CAD files are relatively common in training datasets. Assembly files are rarer, more complex, and contain relationship data (mates, constraints) that's structured differently in every CAD format. A STEP file of an assembly contains geometry but loses most of the constraint information. A native Fusion 360 or SolidWorks assembly file contains everything, but those formats are proprietary and less available for training.

Then there's the combinatorial problem. A single part has one geometry to get right. An assembly of five parts has five geometries plus every pairwise interaction between them. The number of things that can go wrong scales faster than the number of parts. Anyone who's tried to assemble parts from different vendors, or from the same vendor on different days, knows this feeling. Getting things to fit together is harder than getting things to exist individually.

What current tools actually produce#

I tested four scenarios across Zoo.dev, AdamCAD, and CADScribe to see how they handle requests that imply assembly intent.

Scenario 1: "A hinge with two leaves and a pin." Zoo.dev generated a single body that looked hinge-like but was fused solid. AdamCAD generated OpenSCAD code for two separate rectangular blocks with cylinders, but they overlapped in space and had no hinge geometry that would allow rotation. CADScribe generated a single Fusion 360 body with a split feature that suggested two leaves, but the pin was missing and there was no clearance between the leaves.

Scenario 2: "An enclosure with a removable lid." Zoo.dev generated a box with a separate-looking lid, but the STEP file contained one body. There was no gap between the lid and the box walls. No alignment features. No fastener points. AdamCAD produced two separate bodies (box and lid) but with no tongue-and-groove, no step joint, and wall thicknesses that didn't match between the two. CADScribe generated an enclosure with a shell feature and a separate lid sketch, but the lid dimensions didn't match the enclosure opening.

Scenario 3: "A bracket with two M4 bolts." Every tool generated a bracket with holes. None generated bolts. The "assembly" was always interpreted as a single part with holes, not a multi-component system.

Scenario 4: "A shaft in a bearing block." Zoo.dev generated a block with a cylindrical hole. No shaft. AdamCAD generated a block and a cylinder, but the cylinder diameter matched the hole diameter exactly (zero clearance, press fit by accident, bearing fit by coincidence). CADScribe generated a bearing block body only.

The pattern is clear: text-to-CAD for mechanical parts means single mechanical parts. Assembly prompts are either ignored, misinterpreted, or reduced to single-body approximations.

The workaround workflow#

If you want to use text-to-CAD in a project that involves assemblies, the workflow is generate parts individually and assemble them yourself. It works, with caveats.

Step 1: Break your assembly into individual components. Think about each part independently. What are its dimensions? What features does it need? What are the interface dimensions that must match other parts?

Step 2: Generate each part with explicit dimensions for all mating interfaces. If the bracket has M4 clearance holes on a 40mm by 30mm pattern, specify that exactly. If the lid needs to be 82mm by 62mm to fit inside an 80mm by 60mm enclosure with 1mm clearance per side, specify 82mm by 62mm, not "a lid that fits the enclosure."

Step 3: Export each part as STEP and import them into your CAD assembly environment. Fusion 360, SolidWorks, whatever you use.

Step 4: Add mates and constraints manually. Align the holes. Seat the surfaces. Check the fits. This is where the actual assembly engineering happens.

Step 5: Check interference. Run the interference detection tool. Fix the overlaps. Adjust the clearances. This step almost always reveals problems because the individual parts weren't designed with a shared reference frame.

I've done this workflow a few times. It's faster than modeling every part from scratch when the parts are simple. It's slower than modeling from scratch when the parts have complex mating interfaces, because the AI-generated dimensions on interface features are the least reliable, and those are exactly the dimensions that matter most in an assembly.

The text-to-CAD guide describes this as a "concept assembly" workflow, which is about right. You get a rough assembly that communicates the general arrangement. You don't get a production assembly that you can send to a contract manufacturer with a BOM and expect functional parts back.

When might assembly generation arrive?#

This is speculation, but informed speculation based on where the research is heading.

The near-term likely improvement is multi-body generation: a tool that produces multiple separate bodies in one output, dimensionally coordinated but without formal assembly constraints. This would be the equivalent of generating parts that fit together by design, even if the CAD file doesn't contain mate definitions. It's a geometry problem rather than an assembly-data problem, and it's plausible within the next year or two.

True assembly generation, with mates, constraints, and component relationships, is a harder problem. The AI would need to understand not just what each part looks like, but how it connects to other parts, what degrees of freedom the connection allows, and how the constraints propagate through the assembly. This requires a fundamentally different training approach than current single-part generation, and the training data for assemblies is scarce compared to individual parts.

The most realistic path is probably CAD-native integration. A tool like CADScribe, which works inside Fusion 360's API, could theoretically generate components in the Fusion assembly environment and apply mates using Fusion's native constraint system. The AI would need to understand Fusion's assembly features, but the assembly data structure would be handled by the CAD platform rather than invented by the AI. This is harder than generating single bodies but possible within the existing CAD infrastructure.

The practical reality#

If your work involves assemblies, text-to-CAD is useful for generating the easy parts quickly and useless for the hard parts: the interfaces, the fits, the constraints, the motion, the BOM. Assembly design is where engineering judgment lives, and it's the last place AI will replace human thinking.

I still use text-to-CAD for individual components when the geometry is simple and the AI CAD output is good enough for real work. But the moment I need those components to fit together, I'm in Fusion 360 doing the assembly work the same way I've always done it: manually, carefully, with the mate dialog open and the measure tool within reach.

The hinge I tried to generate six months ago? I modeled it from scratch in Fusion in about twenty minutes. Two leaves, a pin, a bushing, proper clearances, and mates that actually let it rotate. Twenty minutes isn't long. But it was twenty minutes of actual engineering, and that's the part no text prompt replaces.