Grounded AI design review: how Cadre measures geometry so the AI can't guess

Large language models are confidently wrong about geometry. Ask one whether a part is watertight, how thick its thinnest wall is, or whether it has a sealed internal cavity, and you'll often get a fluent, specific, and incorrect answer — because the model is reasoning about a picture or a description, not measuring the solid.

Cadre takes the opposite approach. Its AI design review never measures geometry with the language model. The geometry kernel measures; the AI only narrates measurements it's handed. And any manufacturability flag the kernel measurement does not support is dropped on the server before it reaches you. This post is exactly how that works — because "grounded in real measurement" is a claim worth being able to check.

The kernel is the source of truth, not the model

Cadre's geometry lives in a Rust kernel compiled to WebAssembly that runs in your browser. Every geometric fact in a review comes from that kernel as a number, computed deterministically — the same input always produces the same measurement. The language model receives those numbers as structured input and writes the human explanation around them. It is the narrator, not the instrument.

That single architectural choice — measurement is the instrument, the LLM is the narrator — is what separates a review you can trust from a plausible-sounding guess.

What the kernel actually measures

A review is built from kernel-measured signals, not inferred ones:

• Is it a valid solid (watertight)? The kernel checks that every edge is shared by exactly two triangles — the definition of a closed, manifold solid. If a model isn't watertight, its volume, surface area, and wall-thickness numbers are not trustworthy, and the review says so plainly instead of quoting a fabricated volume.
• Are there enclosed voids? A sealed internal cavity traps uncured resin or unfused powder and can't drain — a real, common, and usually-missed print failure. Cadre detects enclosed voids topologically: it evaluates the winding number just inside each surface shell, so a sealed empty cavity reads differently from the solid material around it. It also reports connected shells and through-tunnels (the part's genus) as a compact topological summary.
• Exact surface geometry, not tessellation. A 3D model on screen is a triangle mesh — a 48-sided cylinder is 48 flat strips, and naively measuring its radius from those strips reads slightly small (the strips sit inside the true circle). Because Cadre's primitives are parametric, the kernel knows the exact surface each face lies on: a cylinder side is a cylinder of a specific radius and axis, full stop. It hands that exact descriptor to the reviewer — a cylinder of radius r, not a 48-strip estimate — so the model reasons about the true radius instead of a tessellation artifact.
• Wall thickness and overhang. Minimum wall thickness is measured against the chosen process's floor (roughly 0.4 mm on FDM); overhang area is measured against a bottom-up build direction, not guessed from a thumbnail.

The part that makes it trustworthy: measured-or-dropped

Here's the mechanism that matters most. The language model is asked to produce manufacturability flags — thin wall, sharp corner, overhang, enclosed void, non-manifold mesh — and to cite the measured number behind each one. But a prompt is only a request. So before any flag reaches you, the server re-checks each measured-kind flag against the kernel's measurement and discards the ones the measurement doesn't support.

If the model claims a thin wall on a part the kernel measured as comfortably thick, that flag is dropped. If it claims an enclosed void where the kernel counted zero, dropped. If it flags a non-manifold mesh on a body the kernel verified as a closed solid, dropped. The model cannot invent a manufacturability problem that the geometry doesn't actually have — the kernel has the final say.

This is the inversion that makes the difference: most "AI for CAD" tools let the model's judgment through and hope the prompt kept it honest. Cadre treats the model's judgment as a proposal that the measurement either confirms or vetoes.

Why this is the right shape for 3D printing

For a tool whose output is an STL, a mesh kernel that measures the solid exactly is not a compromise — it's the correct instrument. You don't need a full B-rep CAD kernel to know a wall is too thin or a cavity won't drain; you need a kernel that measures the things that make a print fail, reports them as verifiable numbers, and refuses to let an AI overstate them. That's what Cadre is built around.

What it deliberately doesn't do

Being honest about the limits is part of being trustworthy:

• It is not a substitute for a test print. It catches the class of failure that's decided in the geometry — thin walls, overhangs, voids, sharp internal corners — not everything that can go wrong on a bed.
• It reviews what it can measure. Exact analytic surfaces today cover the parametric primitives; richer cases (carrying exact surfaces through boolean operations) are work in progress, and the review is candid about what's measured versus estimated.
• It won't quote numbers it can't stand behind. On a model that isn't a valid closed solid, it tells you the metrics are unreliable rather than inventing a clean answer.

Try it

Cadre runs this review in the browser, before you export an STL — model, review, fix the number, export. If you build or evaluate AI tools for CAD and 3D printing and want a review you can actually trust, the architecture above is the reason to look: the measurement is the instrument, the AI is the narrator, and the kernel gets the last word.

Open Cadre and run a review on your next part. For the manufacturability rules in plain language, see design for 3D printing; for what the review checks, see AI manufacturability review.