A developer going by 'drydock' on DEV.to has published a detailed post-mortem of seven concrete failures encountered when integrating an LLM agent with a CAD kernel for a silicone casting mold application. Rather than treating this as a simple AI problem, the analysis frames these failures through the lens of architectural containment—a reminder that in precision domains, the split between language model and deterministic system is where the real engineering happens.

Why CAD Breaks the "Good Enough" Paradigm

LLMs have trained the industry to accept probabilistic outputs. A slightly wrong email summary? Tolerable. A 0.5mm machining error on a mold that costs $2,000 to recut? That's a different conversation entirely. The core insight driving drydock's architecture is that CAD operations demand exact geometric correctness, and LLMs fundamentally struggle with maintaining numerical precision across multi-step reasoning chains.

Failure Mode #1: Coordinate Drift in Multi-Step Operations

The first documented failure involved the agent losing track of coordinate reference frames as it issued sequential kernel commands. The LLM would issue a valid command in one context, but subsequent operations would execute from an implicit origin that had shifted during intermediate transformations—a classic spatial reasoning gap where the model's internal representation diverged from what the CAD kernel expected.

Failure Mode #2: Implicit Assumption Inheritance

The agent was observed propagating unstated assumptions across operation boundaries. When a user described "a standard mold draft," the LLM would substitute its own default values rather than querying for explicit parameters, leading to geometries that looked reasonable in isolation but failed tolerance checks downstream.

The Architectural Split as Containment Strategy

The solution wasn't better prompting—it was enforcing a strict interface contract. By routing all geometric decisions through an intermediary validation layer with explicit parameter schemas, the system could catch probabilistic drift before it reached the kernel. This is the pragmatic "split" mentioned in the post: LLMs handle conversation and intent classification; deterministic code handles execution.

Key Takeaways

  • Treat LLM-to-kernel integration as a security boundary, not just an API call chain
  • Explicit schemas prevent implicit assumption inheritance between operations
  • Coordinate reference frames need explicit tracking that survives model context windows
  • Validation layers serve double duty: catching AI errors and providing audit trails

The Bottom Line

This isn't a hit piece on LLMs—it's infrastructure documentation from someone who actually shipped the thing. If you're building agents for any domain where "close enough" costs money or safety, read this before you wire your first API call.