Text-to-CAD Reality Check: Zoo, Leo AI, and the B-Rep Frontier

The Generative Geometry Divide

For the past eighteen months, generative AI in product development has suffered from an architectural mismatch. The broader artificial intelligence sector celebrated diffusion-based 3D generators capable of rendering textured polygonal meshes from text prompts in seconds. In industrial engineering offices, these tools were non-starters. A dense triangle soup exported as an STL or OBJ file possesses no semantic intelligence: it lacks editable sketches, contains no parametric feature history, cannot express engineering tolerances, and causes immediate failures when imported into finite element analysis (FEA) or computer-aided manufacturing (CAM) pipelines.

Mechanical design runs on Boundary Representation (B-Rep) geometry and variational constraint solvers. A production-grade part is defined not by surface approximations, but by exact analytical surfaces—planes, cylinders, tori, and Non-Uniform Rational B-Splines (NURBS)—stitched into topologically watertight manifolds. More crucially, the design intent resides within the feature tree: the sequential logic of extruded bosses, parametric offsets, hole callouts, drafts, and fillet orders that allow a tooling engineer to modify a wall thickness without corrupting the datum planes.

Emerging platforms such as Zoo.dev (formerly KittyCAD), Leo AI, and Katalyst Labs claim to have crossed this chasm. By pitching text-to-CAD systems that target programmatic B-Rep generation, mechanical design copilots, and native STEP exports, these startups aim to replace manual feature creation with natural language interfaces.

For a senior mechanical engineer or solo technical founder managing complex electro-mechanical assemblies, the question is not whether text-to-CAD is conceptually intriguing. The question is whether these tools output mathematically clean, constraint-locked models that integrate directly into SolidWorks, Siemens NX, or PTC Creo workflows without requiring hours of manual topology repair.

The Three Architectural Paradigms

To evaluate tools like Zoo.dev, Leo AI, and Katalyst, one must understand how their underlying generative engines construct 3D geometry. Current market solutions split into three distinct technical approaches.

┌─────────────────────────────────────────────────────────────────────────┐
│                     TEXT-TO-CAD ARCHITECTURAL TAXONOMY                  │
└─────────────────────────────────────────────────────────────────────────┘
                                     │
         ┌───────────────────────────┼───────────────────────────┐
         ▼                           ▼                           ▼
┌─────────────────┐         ┌─────────────────┐         ┌─────────────────┐
│  Direct Code /  │         │   B-Rep Agent   │         │ Context-Aware   │
│  DSL Synthesis  │         │   Orchestrator  │         │ Copilot Overlay │
├─────────────────┤         ├─────────────────┤         ├─────────────────┤
│ Zoo.dev (KCL)   │         │  Katalyst Labs  │         │ Leo AI          │
│ AdamCAD         │         │  Zookeeper      │         │                 │
├─────────────────┤         ├─────────────────┤         ├─────────────────┤
│ Compiles text   │         │ Employs agents  │         │ Ingests specs,  │
│ to deterministic│         │ with CAD kernel │         │ company standards│
│ programmatic    │         │ tools to build, │         │ and drives native│
│ geometry (KCL). │         │ verify, & repair│         │ CAD software via│
│ Pure B-Rep.     │         │ STEP solids.    │         │ API extensions. │
└─────────────────┘         └─────────────────┘         └─────────────────┘

1. Code-First Parametric Compilers (Zoo.dev)

Zoo has taken the most foundational approach by constructing an independent geometric engine and domain-specific language (KittyCAD Language, or KCL). Instead of asking an LLM to predict raw vertex coordinates or binary Parasolid files, Zoo prompts models to generate deterministic, human-readable code. This code executes against Zoo’s cloud-native geometric kernel to output genuine B-Rep topology.

Because KCL models geometry procedurally—defining sketch planes, standard profile paths, extrusions, and boolean cuts—the resulting file is completely parametric. If the prompt requests a mounting bracket with a 50 mm centre-to-centre spacing on four M6 clearance holes, the geometry contains an explicit programmatic variable driving those coordinates. The output exports cleanly as a standard STEP AP214/AP242 file, maintaining true cylindrical surfaces rather than tessellated facets.

2. Conversational B-Rep Agent Engines (Katalyst Labs & Zookeeper)

Katalyst Labs and Zoo’s higher-level research initiative, Zookeeper, treat CAD generation as an iterative multi-turn agent problem. When a complex prompt is introduced, the system does not execute a single-shot inference. Instead, a reasoning agent drafts an internal specification, selects initial coordinate baselines, invokes kernel-level tools to construct base features, inspects the geometry for manifold integrity via visual and numerical snapshots, and corrects topological faults before delivering the final artifact.

This approach mimics the procedural workflow of a human CAD technician: establish primary datum planes, lay down the master sketch, extrude the bounding volume, apply subtractive features, and terminate with aesthetic or functional edge treatments. The primary engineering output remains a STEP model with clean boundary definitions, though feature editability inside legacy CAD environments depends heavily on how cleanly the agent structured its underlying booleans.

3. Engineering Copilots & Semantic Middleware (Leo AI)

Leo AI positions itself upstream and adjacent to raw geometry creation. Rather than attempting to function merely as an open-ended text-to-STEP generator, Leo acts as an engineering copilot tailored to mechanical assemblies, design rule checking (DRC), and requirement decomposition.

Leo analyses product requirement documents (PRDs), extracts critical engineering constraints (such as IP ratings, structural loads, thermal envelopes, and standard fastener clearances), and assists the engineer in synthesising compliant conceptual designs. Its focus centers on capturing corporate tribal knowledge, suggesting standard off-the-shelf components, and integrating with enterprise product lifecycle management (PLM) systems. While it provides generative concept capabilities, its core value lies in ensuring that the generated geometry conforms to manufacturing logic (DFM) before it reaches the shop floor.

Deep-Dive Evaluation: Zoo.dev vs. Leo AI vs. Katalyst

To determine production viability, we examine how these platforms handle four non-negotiable engineering requirements: B-Rep topological validity, constraint-driven parametric editing, downstream CAD interoperability, and manufacturing constraint integrity.

1. Parametric B-Rep and Topological Manifolds

When evaluating geometry generated by Zoo.dev via standard mechanical prompts—such as an offset motor mount or a flanged housing—the platform consistently generates valid 2-manifold topology. Edges share adjacent faces correctly, vertices coincide within standard geometric modeling tolerances ($10^{-6}\text{ mm}$), and planar surfaces are mathematically flat.

                  PARAMETRIC PIPELINE INTEGRITY
                  
 [Prompt: "Flanged bearing mount, 40mm bore, 4x M5 on 60mm PCD"]
                               │
                               ▼
                  ┌────────────────────────┐
                  │  Zoo KCL / Katalyst    │
                  │  Procedural Engine     │
                  └────────────┬───────────┘
                               │
         ┌─────────────────────┴─────────────────────┐
         ▼                                           ▼
┌───────────────────────────────┐     ┌───────────────────────────────┐
│     CORRECT B-REP OUTPUT      │     │      BROKEN MESH OUTPUT       │
├───────────────────────────────┤     ├───────────────────────────────┤
│ • Cylinder: Exact radius (r)  │     │ • Cylinder: 64 chordal facets │
│ • Axis: Analytic 3D vector    │     │ • Axis: No analytical datum   │
│ • Bolt circle: Exact PCD math │     │ • Bolt circle: Approximate    │
│ • Parasolid / STEP compliant  │     │ • Unusable for CAM / FEA      │
└───────────────────────────────┘     └───────────────────────────────┘

Because Zoo models via KCL, a hole is defined as an analytical circle swept through a volume. When exported to STEP and brought into Siemens NX, the hole is immediately recognized as a cylindrical face. It can be selected for automated CNC hole-making operations, counter-boring routines, or concentric assembly mates without intermediate feature recognition.

Katalyst delivers similarly watertight B-Rep outputs on simple to moderately complex prismatic components. However, on complex multi-axis parts with compound draft angles or organic transitions, automated agent generation can produce degenerate sliver faces or non-manifold edge junctions where boolean operations fail to resolve cleanly. This illustrates the inherent difficulty of automated feature sequencing without continuous variational solving.

2. Constraint Preservation and the Feature Tree Dilemma

The definitive barrier between concept generation and enterprise CAD workflows is the Feature Tree. In tools like SolidWorks, Inventor, and NX, a design is not just a final shape; it is an ordered dependency graph. A change to "Sketch1" propagates downstream, recalculating fillets, shell operations, and child extrusions.

When importing a standard STEP file generated by an AI engine into SolidWorks, the receiving system treats the file as an imported body (a "dumb solid"). While SolidWorks can run FeatureWorks or direct-editing face moves, the original construction sketches, variational equations, and geometric constraints (tangency, perpendicularity, coincidence) are absent.

Zoo solves this within its own ecosystem by providing the raw KCL code. In KCL, design intent is preserved through mathematical expressions:

$$\text{PCD} = 60.0$$ $$\text{HoleCount} = 4$$ $$\theta_i = i \times \left(\frac{360^{\circ}}{\text{HoleCount}}\right)$$

If you modify the pitch circle diameter in the script, the geometry updates deterministically. However, transferring that parametric tree bi-directionally into a proprietary SolidWorks .sldprt or Siemens NX .prt feature tree remains an unsolved industry challenge due to proprietary kernel boundaries (Parasolid vs. CGM vs. ACIS).

Leo AI addresses this through API-driven copilot integration. Rather than generating an isolated file format and throwing it over the wall, Leo operates alongside existing engineering design records. It ensures that standard components, fasteners, materials, and dimension rules align with established parametric envelopes before detailing commences.

3. GD&T and Tolerance Handling

Geometric Dimensioning and Tolerancing (GD&T per ASME Y14.5 or ISO 1101) remains the ultimate test of mechanical intent. AI tools that process natural language descriptions can readily parse dimensional nominals—such as "a 25 mm bore with an H7 tolerance"—but implementing this into CAD requires defining:

1. Primary, secondary, and tertiary datum reference frames (DRFs).
2. Form controls (flatness, cylindricity) on locating surfaces.
3. Orientation and location controls (true position, perpendicularity) linked to physical manufacturing capabilities.

Currently, no text-to-CAD platform autonomously generates a fully annotated, Semantic PMI (Product and Manufacturing Information) STEP AP242 file containing valid datum references and tolerance callouts ready for automated Coordinate Measuring Machine (CMM) inspection.

Zoo.dev provides the precise nominal geometry from which an engineer can establish standard datums. Leo AI provides the contextual knowledge engine to recommend appropriate fits (such as transition fits versus interference fits for pressed bearings). The mechanical lead must still apply the formal GD&T schema within their native CAD drafting or 3D annotation environment.

Real-World Workflow: The Mechanical Bracket Test

To understand where these platforms stand today, consider a routine aerospace/robotics development task: generating an aluminium 6061-T6 structural bracket to mount a frameless brushless motor to a robotic link arm, subject to strict mass limits, clearance for an optical encoder, and a four-bolt mounting pattern.

┌─────────────────────────────────────────────────────────────────────────┐
│                     THE REAL-WORLD PROTOTYPE TEST                       │
│           "Design an angled 6061 bracket for a 42mm BLDC motor,         │
│            providing 15mm clearance for encoder cabling,                │
│            4x M3 mounting pattern, 2.5mm minimum wall thickness."      │
└─────────────────────────────────────────────────────────────────────────┘
                                     │
       ┌─────────────────────────────┼─────────────────────────────┐
       ▼                             ▼                             ▼
┌───────────────┐             ┌───────────────┐             ┌───────────────┐
│  Zoo.dev/KCL  │             │    Leo AI     │             │ Katalyst Labs │
├───────────────┤             ├───────────────┤             ├───────────────┤
│ Generates a   │             │ Evaluates the │             │ Delivers a    │
│ clean, thin-  │             │ prompt against│             │ complete,     │
│ walled B-Rep  │             │ structural    │             │ valid B-Rep   │
│ bracket with  │             │ constraints,  │             │ STEP solid.   │
│ exact pitch-  │             │ flags fastener│             │ Complex web   │
│ circle hole   │             │ clearances,   │             │ gussets fail  │
│ placement.    │             │ and formats   │             │ boolean cuts; │
│ Code is fully │             │ a detailed CAD│             │ nominal base  │
│ editable.     │             │ feature spec. │             │ is usable.    │
└──────┬────────┘             └──────┬────────┘             └──────┬────────┘
       │                             │                             │
       └─────────────────────────────┼─────────────────────────────┘
                                     │
                                     ▼
                 ┌──────────────────────────────────────┐
                 │        ENGINEER'S FINAL PASS         │
                 │ • Import STEP into SolidWorks / NX   │
                 │ • Apply structural fillets (R1.5mm)   │
                 │ • Define ASME Y14.5 Position / Datums│
                 │ • Execute FEA stress & modal check   │
                 │ Time Saved: ~45-60 minutes on layout │
                 └──────────────────────────────────────┘

1. Zoo.dev: When prompted with exact dimensional constraints, Zoo generates a clean, thin-walled prismatic bracket with true cylindrical holes, zero surface self-intersections, and precise hole spacings. The engineer receives an exportable STEP model and the KCL code. Modifying the bracket height requires a one-line variable change in the KCL editor. Adding complex, organically blended stress-relief fillets, however, frequently breaks procedural compilation, requiring the engineer to apply fillets manually inside SolidWorks.
2. Katalyst Labs: Katalyst returns an integrated solid model within seconds. The base geometry is topologically sound and dimensionally accurate to the prompt. However, when requesting internal cable routing cutouts with compound draft angles, the agent-based solver occasionally generates overlapping sketches that fail boolean subtraction, resulting in a solid volume that requires direct-editing cleanup.
3. Leo AI: Leo accelerates the specification phase. It structures the component boundaries, ensures the M3 fastener counterbores have adequate socket clearance according to standard shop tooling, and prepares the design record for execution. It acts as an active sanity check against engineering oversights before geometry is finalized.

The Verdict: None of these tools eliminate the mechanical engineer. What they eliminate is the initial 45-minute blank-canvas layout phase—sketching standard mounting patterns, establishing preliminary bounding boxes, and generating basic base flanges.

Mexaio AI: The Autonomous Tooling Paradigm

At IDO (Intelligent Design Office), our work with Mexaio AI addresses the mechanical engineering bottleneck from a structural perspective. The objective of next-generation CAD intelligence is not merely to turn simple conversational phrases into standard brackets; it is to enable a single senior mechanical engineer to operate with the capacity of an entire legacy design office.

In traditional industrial enterprises—spanning the automotive hubs of Europe to the expanding industrial clusters in Saudi Arabia and the UAE under Vision 2030—engineering delivery is throttled by administrative modeling overhead. Teams of junior drafters spend hundreds of hours translating system-level interface control documents (ICDs) into part sketches, calculating bolt torques, searching component catalogues, and verifying kinematic clearance envelopes.

Mexaio AI is architected around constraint-first generative mechanics. Instead of treating CAD as an isolated visual generation problem, Mexaio integrates:

• Kinematic Synthesis: Generating multi-body linkages and drive mechanisms directly from desired motion profiles, velocity curves, and torque limits.
• Physics-Informed Structural Logic: Generating continuous load-path geometry where material distribution is governed by stress tensors and manufacturing limits (machining tool access, sheet metal bend radii, draft angles for casting).
• Deterministic Assembly Context: Ensuring that when an interface changes (e.g., a motor frame size increases from NEMA 17 to NEMA 23), every mating bracket, fastener schedule, and thermal interface regenerates across the entire assembly without manual rebuild errors.

This methodology operationalises the one-engineer design office. The mechanical lead does not waste time extruding bolt holes or manually adjusting flange clearances. They act as the chief systems architect, defining functional boundaries, material selections, and performance criteria, while autonomous engines synthesize verified, manufacturing-ready geometry.

What This Means for Your Week

If you are a lead mechanical engineer, hardware founder, or R&D manager, here is how to extract practical utility from current text-to-CAD tools right now without disrupting production pipelines:

1. Relegate Text-to-CAD to Prismatic Components and Fastener Layouts

Use platforms like Zoo.dev to rapidly generate routine mounting plates, sensor brackets, adapter flanges, and enclosure standoffs. When you need a standard 4-bolt flange with defined center-to-center distances, generating it via a parametric code prompt or KCL script is significantly faster than opening a CAD template, sketching rectangles, projecting geometry, and constraining dimensions by hand.

2. Treat Outputs as "Base Feature" Importers

Never expect an AI tool to deliver a finished, 100% production-ready model with finished drafts, cosmetic fillets, and detailed manufacturing annotations. Establish a clean handoff workflow:

• Generate the base B-Rep volume via Text-to-CAD / KCL.
• Export as a clean STEP AP242 file.
• Import into your native CAD environment (SolidWorks, NX, Onshape).
• Apply finishing features: structural fillets, draft angles for tooling, and critical-tolerance hole reaming operations.

3. Reject Polygonal Meshes in Production CAD Pipelines

Establish a strict policy across your mechanical team: generative mesh models (STLs, OBJs from diffusion engines) are prohibited from production assemblies unless specifically designated for additive manufacturing lattice infills or artistic industrial design styling. Importing dense tessellations into master CAD assemblies bloats file sizes, degrades viewport performance, and prevents reliable assembly mating.

4. Build a Parametric Scripting Mindset

Familiarise your team with code-driven CAD frameworks like Zoo’s KCL or OpenSCAD/Build123d. The industry is inexorably shifting toward programmatic geometry representation. Engineers who understand how to structure parametric variables through code will be positioned to leverage enterprise agent tools far more effectively than those limited to manual mouse-driven sketching.

The Path Forward

Text-to-CAD has successfully moved beyond the novelty phase of unconstrained mesh generation. The emergence of programmatic B-Rep platforms, dedicated geometric languages like KCL, and engineering copilots like Leo AI demonstrates that the AI ecosystem now recognizes the non-negotiable requirements of mechanical manufacturing.

We have not yet arrived at autonomous, zero-shot generation of complex multi-stage gearboxes or dynamic aerospace mechanisms. The topological naming problem, multi-part assembly kinematic constraints, and native proprietary feature tree synchronisation remain stubborn engineering hurdles.

However, for the solo technical founder or the high-output mechanical lead, these tools already offer significant leverage. By automating the creation of intermediate prismatic geometry and formalising design constraints, modern text-to-CAD frameworks allow engineers to spend less time clicking sketch tools and more time solving core mechanical, thermal, and dynamic challenges.

Sources

• Zoo.dev Research & Zookeeper Agent Architecture: https://zoo.dev/research/zookeeper
• Zoo.dev ML Model & Text-to-CAD Engine: https://zoo.dev/zookeeper
• Zoo.dev Text-to-CAD Launch: https://zoo.dev/blog/introducing-text-to-cad
• Leo AI Engineering Platform: https://www.getleo.ai/blog/open-source-text-to-cad-tools-free
• Leo AI Comparative Evaluation: https://www.getleo.ai/blog/text-to-cad-tools-comparison-guide
• Katalyst Labs Evaluation: https://mikekalil.com/blog/ai-driven-text-to-cad/
• Xometry Mechanical Engineering Tool Review: https://xometry.pro/en/articles/text-to-cad-tools-test/
• Text-to-CAD Open Source Agent Skills: https://github.com/earthtojake/text-to-cad
• Parametric Modeling Fundamentals: https://www.sciencedirect.com/topics/engineering/parametric-modeling