CADSmith: Multi-Agent CAD Generation with Programmatic Geometric Validation

Het paper introduceert CADSmith, een multi-agent systeem dat door middel van iteratieve correctielussen met programmatische geometrische validatie en een visuele beoordelaar, nauwkeurige CadQuery-code genereert uit natuurlijke taal en zo de betrouwbaarheid en kwaliteit van gegenereerde CAD-modellen aanzienlijk verbetert.

De kern

Stel je voor dat je een architect bent die een heel specifiek huis wil bouwen, maar in plaats van te tekenen, moet je een robot de instructies geven in een vreemde, complexe programmeertaal. Als de robot ook maar één muur een centimeter te hoog bouwt of een raam vergeten is, is het hele huis onbruikbaar.

Dat is precies het probleem dat CADSmith oplost. Het is een slim systeem dat natuurlijke taal (zoals "maak een ronde schakel met zes gaten") omzet in perfecte 3D-tekeningen voor machines.

Hier is hoe het werkt, vertaald in een verhaal met analogieën:

Het Probleem: De "Dromerige" Robot

Vroeger probeerden AI's (zoals grote taalmodellen) direct een tekening te maken. Dit was als een dromerige architect die zegt: "Ik denk dat dit wel goed komt."

• Het resultaat: De tekening zag er misschien mooi uit op het scherm, maar als je de maten nam, bleek de deur 5 centimeter te smal te zijn of de vloer niet waterdicht. De AI "hallucineerde" vaak de maten.

De Oplossing: CADSmith als een Perfect Team

CADSmith is geen enkele robot, maar een team van vijf specialisten die samenwerken in een strakke cyclus. Ze werken als een bouwteam dat niet stopt totdat alles perfect is.

1. De Planner (De Ontwerper)

Eerst komt de Planner. Hij luistert naar jouw zin ("Maak een schakel...") en schrijft een gedetailleerd bouwplan op papier. Hij maakt geen tekening, maar zorgt dat alle maten en onderdelen duidelijk zijn voordat de bouw begint.

2. De Coder (De Bouwer)

Dan komt de Coder. Deze robot bouwt het in de programmeertaal. Maar hij is niet alleen; hij heeft een bibliotheek (een soort Google voor bouwers) bij de hand. Als hij twijfelt over een techniek, slaat hij direct op in de handleiding hoe het moet. Hij hoeft niet alles uit zijn hoofd te kennen, hij kan gewoon naslaan.

3. De Executor (De Werkplek)

Deze robot neemt het plan en probeert het te bouwen in een veilige, gesloten werkplaats.

• Binnenste lus (De "Code-check"): Als het plan een fout bevat (bijvoorbeeld een verkeerde haakje), stopt de werkplek. Een Foutoplosser kijkt naar de foutmelding, raadpleegt de handleiding en probeert het opnieuw. Dit gebeurt maximaal drie keer.

4. De Validator (De Kwaliteitscontroleur)

Als het plan werkt, komt de echte test: De Validator. Deze heeft twee ogen:

• Oog 1: De Meetlat (De Rekenmachine): Hij meet exact: "Is de lengte 50 mm? Is het volume 100 cm³? Is het object waterdicht?" Dit is de harde, wiskundige waarheid.
• Oog 2: De Kunstcriticus (De Visionair): Hij kijkt naar drie foto's van het gebouwd object (van voren, van boven en schuin). Hij vraagt zich af: "Ziet dit eruit als wat de klant wilde? Zijn er gaten waar er gaten moeten zijn?"

De magie: Als de meetlat zegt "Ja, het is 50 mm" maar de foto laat zien dat het een verkeerd vorm heeft, dan is het nog steeds fout. De Validator zegt dan: "Nee, het klopt niet."

5. De Refiner (De Herbouwer)

Als de Validator zegt dat het fout is, gaat de Refiner aan het werk. Hij krijgt de exacte maten van de meetlat én de opmerkingen van de kunstcriticus. Hij past het plan aan en stuurt het terug naar de werkplek.

Dit proces (bouwen -> meten -> kijken -> aanpassen) herhaalt zich totdat het object perfect is.

Waarom is dit zo slim?

• Geen "Gokken": Andere systemen vertrouwen op het uiterlijk. CADSmith vertrouwt op exacte metingen (zoals een bouwkundige die met een meetlint werkt) én op visuele controle (zoals een inspecteur die rondloopt).
• Geen Oefenen, maar Leren: In plaats van dat de AI duizenden uren moet oefenen om een nieuwe taal te leren (wat vaak verouderd raakt), leest hij gewoon de actuele handleidingen. Als de software van de bouwers verandert, werkt CADSmith nog steeds perfect.
• De "Jury" is slimmer: De AI die de fouten vindt (de Validator) is een slimmere versie dan de AI die bouwt. Zo voorkomt men dat de bouwer zichzelf bedriegt door te zeggen: "Ja, dit ziet er goed uit," terwijl het eigenlijk fout is.

Het Resultaat

In tests bleek dat dit systeem 100% van de tijd een werkend plan maakt, terwijl eerdere systemen vaak vastliepen. De fouten in de maten werden met 38 keer verkleind.

Kortom: CADSmith is als een onuitputtelijk team van een ontwerper, een bouwer, een meetkundige en een inspecteur die samenwerken totdat het product niet alleen "eruit ziet" alsof het klopt, maar wiskundig en visueel perfect is. Het maakt het mogelijk om complexe machines en onderdelen te maken door simpelweg te praten, zonder dat je zelf een expert hoeft te zijn in 3D-tekenen.

Technische samenvatting

Probleemstelling

Het genereren van CAD-modellen (Computer-Aided Design) uit natuurlijke taal is een complexe taak die hoge eisen stelt aan precisie. Bestaande methoden voor "text-to-CAD" generatie lijden aan twee fundamentele tekortkomingen:

1. Gebrek aan geometrische verificatie: Veel systemen werken in één pass zonder verificatie, wat leidt tot fouten in afmetingen en topologie.
2. Verlies van precisie door visuele feedback: Systemen die wel iteratief werken (zoals Query2CAD), vertrouwen vaak op visuele feedback (beelden) die dimensionale fouten (bijv. enkele millimeters) niet kunnen detecteren.
3. Hallucinaties: Large Language Models (LLM's) neigen tot het hallucineren van afmetingen en het verkeerd gebruiken van API's, wat resulteert in modellen die er visueel goed uitzien maar dimensionaal onbruikbaar zijn voor fabricage.

Er is behoefte aan een systeem dat zowel exacte numerieke metingen (voor dimensies) combineert met holistische visuele beoordeling (voor algemene vorm en coherentie) binnen een gesloten iteratieve lus.

Methodologie: CADSmith Pipeline

CADSmith is een multi-agent systeem dat CadQuery-code genereert en verfijnt via twee geneste correctielussen. Het systeem gebruikt geen fine-tuning, maar vertrouwt op Retrieval-Augmented Generation (RAG) over API-documentatie om actueel te blijven.

De pipeline bestaat uit vijf gespecialiseerde agents:

1. Planner: Zet de natuurlijke taal prompt om in een gestructureerd ontwerpplan (JSON) met componenten, doelmatingen en geometrische constraints.
2. Coder: Genereert de CadQuery Python-script. Deze agent gebruikt RAG met twee kennisbanken:
   • KB1: Gedetailleerde API-documentatie van CadQuery.
   • KB2: Patronen voor foutoplossing (bijv. boolean-operaties, fillet-fouten).
3. Executor: Voert de gegenereerde code uit in een geïsoleerde Python-subprocess.
   • Bij succes: Exporteert het model en haalt exacte geometrische metingen op uit de OpenCASCADE (OCCT) kernel (volume, bounding box, aantal vlakken/ribben/hoekpunten, geldigheid van het massief).
   • Bij mislukking: Vangt de traceback op en activeert de inner loop.
4. Validator (Judge): Een onafhankelijke Vision-Language Model (VLM) (Claude Opus) dat fungeert als rechter. Deze ontvangt vier inputs:
   • De originele prompt.
   • De gegenereerde code.
   • Exacte kernmetingen van de Executor.
   • Drie gerenderde beelden van het object (isometrisch, hooghoek achterkant, front profiel).
     De Judge beoordeelt of het model voldoet aan de prompt door visuele bewijzen te kruisverwijzen met de numerieke metingen.
5. Refiner: Ontvangt feedback van de Validator en de Executor en genereert gecorrigeerde code om de fouten te verhelpen.

De twee correctielussen:

• Inner Loop: Handelt uitvoeringsfouten (syntax, runtime errors) af. De Error Refiner gebruikt de traceback en RAG-context om de code te repareren (max. 3 pogingen).
• Outer Loop: Handelt geometrische fouten af. Als de code werkt maar de vorm verkeerd is, gebruikt de Validator de OCCT-metingen en visuele inspectie om feedback te geven. De Refiner past de code aan (max. 5 iteraties).

Belangrijkste Bijdragen

1. Multi-agent Architectuur: Vervangt monolithische single-model benaderingen door een gespecialiseerd team van agents (Planner, Coder, Executor, Validator, Refiner).
2. Dubbel-lus Programmatic Geometric Validation: Een unieke combinatie van een inner loop voor code-fouten en een outer loop die OpenCASCADE kernel-metingen (exacte dimensies) koppelt aan visuele inspectie.
3. Onafhankelijke VLM-as-Judge: Gebruik van een sterker model (Claude Opus) als Judge dan het generatiemodel (Claude Sonnet) om zelf-bevestigingsbias te voorkomen. De Judge combineert numerieke data met drie-view rendering.
4. RAG in plaats van Fine-tuning: Het systeem blijft up-to-date met de evolutie van de CadQuery API zonder opnieuw getrainde modellen te hoeven gebruiken.

Resultaten

Het systeem werd geëvalueerd op een aangepast benchmark van 100 prompts verdeeld over drie moeilijkheidsgraden (T1: primitieven, T2: engineering-onderdelen, T3: complexe onderdelen).

Vergelijking met Zero-Shot Baseline:

• Uitvoeringssucces: Steeg van 95% naar 100%.
• Chamfer Distance (Mean): Verminderd van 28,37 naar 0,74 (een verbetering van factor 38). Dit toont aan dat de iteratieve correctie catastrofale geometrische fouten elimineert.
• F1 Score (Median): Verbeterd van 0,9707 naar 0,9846.
• IoU (Median): Verbeterd van 0,8085 naar 0,9629.

Ablatie-studies:

• Zonder visie (No-vision): Als de Judge alleen op kernmetingen vertrouwt (zonder beelden), stijgt de gemiddelde Chamfer Distance voor complexe onderdelen (T3) van 1,42 naar 49,68. Dit bewijst dat visuele feedback essentieel is om "valse convergentie" te detecteren (waarbij afmetingen kloppen maar de vorm fundamenteel verkeerd is).
• Moeilijkheidsgraden: Het systeem presteert bijna perfect op T1 en T2. Op T3 (complexe onderdelen met sweeps, lofts, shells) daalt de prestatie iets, maar blijft aanzienlijk beter dan de baseline.

Betekenis en Discussie

CADSmith bewijst dat een gesloten lus (closed-loop) met zowel programmatieke als visuele feedback de betrouwbaarheid van LLM-generatie voor CAD aanzienlijk verbetert.

• Kwaliteit: Het systeem kan complexe, multi-stap engineering-onderdelen genereren die dimensionaal exact zijn, wat essentieel is voor fabricage.
• Beperkingen: Een "near-miss" geval (T3 019, een quadcopter-frame) toonde aan dat vaste weergaven soms kleine gaten of onvolledige boolean-operaties kunnen missen die voor fabricage kritiek zijn.
• Toekomst: De auteurs suggereren adaptieve weergavekeuze en hogere resolutie voor kritieke gebieden als volgende stappen.

Het paper markeert een belangrijke stap richting betrouwbare, geautomatiseerde CAD-generatie die niet alleen "er goed uitziet", maar ook technisch en dimensionaal correct is voor de industrie.