HDLFORGE: A Two-Stage Multi-Agent Framework for Efficient Verilog Code Generation with Adaptive Model Escalation

HDLFORGE is een tweestaps multi-agent framework dat de efficiëntie van Verilog-codegeneratie optimaliseert door standaard een compact model te gebruiken en alleen bij fouten een krachtiger model in te schakelen, waarbij een counterexample-gestuurd agent de bugdetectie versnelt en zo een betere afweging tussen snelheid en nauwkeurigheid bereikt.

De kern

Stel je voor dat je een zeer complexe machine moet bouwen, zoals een auto of een robot, maar in plaats van metaal en schroeven, gebruik je Verilog-code. Dit is de taal die ingenieurs gebruiken om elektronische schakelingen (zoals die in je telefoon of computer) te ontwerpen.

Het probleem is dat kunstmatige intelligentie (AI) deze code kan schrijven, maar vaak fouten maakt. Soms is de code netjes, maar werkt hij niet. Soms is hij perfect, maar duurt het dagen om te controleren of hij wel goed is.

HDLFORGE is een slimme nieuwe methode die dit probleem oplost door een soort "twee-traps raket" te gebruiken. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De Twee Trappen: De Snelle Leerling en de Meester

Stel je voor dat je een moeilijke wiskundeproof moet oplossen.

• Trap A (De Snelle Leerling): Je begint met een slimme, maar kleinere AI (een "compacte coder"). Deze is snel en goedkoop. Hij probeert de code te schrijven en kijkt direct of er grote fouten in zitten (zoals of de code wel compileert of of er waarschuwingen zijn).
  • Analogie: Dit is als een stagiair die snel een eerste ontwerp maakt. Als het er goed uitziet, is het klaar!
• Trap B (De Meester): Als de stagiair vastloopt of de code nog steeds fouten bevat, schakel je pas de "Meester" in. Dit is een enorme, zeer krachtige AI (zoals een supercomputer). Deze is duur en traag, maar kan de moeilijkste problemen oplossen.
  • Analogie: Je belt pas de beroemdste professor van de universiteit als de stagiair echt vastloopt. Je wilt niet elke dag de professor bellen, want dat kost te veel tijd en geld.

De slimme truc: HDLFORGE heeft een slimme manager die beslist wanneer je de Meester moet bellen. Hij kijkt naar een "score" gebaseerd op simpele tests. Is de code bijna goed? Dan blijft de stagiair werken. Is het een hopeloze situatie? Dan schakelt hij direct over naar de Meester. Dit bespaart enorm veel tijd.

2. De "Micro-Tests": De Vlieg die je niet ziet

Een van de grootste problemen bij het bouwen van schakelingen is dat je soms een klein foutje over het hoofd ziet dat pas opduikt onder specifieke omstandigheden (bijvoorbeeld: "als de knop 3 keer snel wordt ingedrukt, crasht de machine").

HDLFORGE heeft een speciale agent die werkt als een detective met een vergrootglas:

• Als de AI een fout maakt, kijkt deze detective niet alleen naar de fout, maar maakt hij een kleine, specifieke test (een "micro-test") die precies die fout simuleert.
• Analogie: Stel dat je een auto bouwt en de remmen werken niet als het regent. In plaats van elke dag de hele auto te testen, maak je een kleine test die alleen regensimuleert. De volgende keer dat je een nieuw ontwerp maakt, test je eerst die regentest. Als hij daar faalt, weet je direct dat het ontwerp slecht is, zonder de hele auto te hoeven testen.
• Deze "micro-tests" worden opgeslagen. Zo leert het systeem van zijn eerdere fouten en vindt het bugs veel sneller.

3. Waarom is dit zo geweldig?

Vroeger moest je kiezen tussen:

1. Snelheid: Gebruik een snelle AI, maar de code is vaak fout.
2. Kwaliteit: Gebruik een superkrachtige AI voor alles, maar het duurt eeuwen en kost een fortuin.

HDLFORGE combineert het beste van beide werelden:

• Het is snel omdat het meestal de snelle AI gebruikt.
• Het is zeer nauwkeurig omdat het de superkrachtige AI gebruikt op het juiste moment.
• Het is slimmer omdat het van elke fout leert door die "micro-tests" te maken.

Samenvatting

HDLFORGE is als een slimme bouwteam-leider. Hij laat eerst een snelle, goedkope werknemer het werk doen. Hij houdt de voortgang in de gaten met simpele controles. Als het werk goed gaat, is het klaar. Als het werk vastloopt, roept hij direct de beste expert ter wereld om het op te lossen. Bovendien zorgt hij ervoor dat ze van elke fout een "herinnering" maken, zodat ze die fout nooit meer maken.

Het resultaat? Snellere, goedkopere en foutloze elektronische ontwerpen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "HDLFORGE: A Two-Stage Multi-Agent Framework for Efficient Verilog Code Generation with Adaptive Model Escalation" in het Nederlands.

Probleemstelling

Het gebruik van Large Language Models (LLM's) voor het genereren van Verilog-code (HDL) is toegenomen, maar er blijven aanzienlijke uitdagingen bestaan:

1. Fouten en Hallucinaties: LLM's genereren vaak code met syntaxisfouten, functionele bugs en hallucinaties, zelfs voor relatief kleine ontwerpen.
2. Efficiëntie vs. Nauwkeurigheid: Bestaande systemen kiezen meestal voor één modelgrootte. Het gebruik van zeer grote (en dure) modellen voor elke taak is computatief inefficiënt, terwijl het gebruik van alleen kleine modellen vaak leidt tot onnauwkeurige code.
3. Gebrek aan Adaptiviteit: Huidige Verilog-LLM-systemen schalen niet dynamisch op basis van de moeilijkheidsgraad van de taak en missen vaak geavanceerde mechanismen voor het detecteren en repareren van complexe bugs.

Methodologie: HDLFORGE Architectuur

HDLFORGE is een twee-staps multi-agent framework dat een adaptieve escalatiestrategie hanteert om de afweging tussen snelheid (latency) en nauwkeurigheid te optimaliseren. Het systeem bestaat uit zeven gecoördineerde agenten die werken in een gesloten lus.

1. Twee-Staps Cascade

• Fase A (Primair Oplosser): Gebruikt een compacte coder gebaseerd op een middelgroot LLM (bijv. Qwen-7B). Deze fase probeert de taak op te lossen via iteratieve generatie en reparatie, geleid door goedkope diagnostische feedback.
• Fase B (Finale Poging): Wordt alleen geactiveerd als Fase A niet voldoende vooruitgang boekt. Hierbij wordt een krachtige, ultra-grote cloud-model (bijv. Claude 3.5 Sonnet) ingezet voor één hoogwaardige poging.
• Escalatiebeslissing: Een kalibratiecontroller bepaalt op basis van een score ($Z$) of er moet worden geëscaleerd. Deze score is gebaseerd op vijf diagnostische signalen:
  • $s_{comp}$: Succesvolle compilatie.
  • $s_{lint}$: Kwaliteit van de code (aantal waarschuwingen).
  • $s_{smoke}$: Consistentie tijdens korte "rooktesten" (smoke tests).
  • $s_{trace}$: Stabiliteit van de foutlocatie over iteraties heen.
  • $s_{budget}$: Beschikbaarheid van resterende pogingen.

2. Kerncomponenten en Agenten

• Multi-Plan Generatie: Een Planner-agent genereert meerdere implementatiestrategieën.
• Snelle Selectie: Een Judge & Smoke-agent voert goedkope compilatie- en lint-checks uit, gevolgd door korte simulaties met een set van "micro-tests".
• Formele Amplificatie (CEGIS-stijl): Een unieke innovatie is de Tiny Formal Amplifier Agent. Deze agent:
  • Voert bounded model checking (BMC) uit op de gegenereerde code.
  • Converteert counterexample-traces (foutbewijzen) naar herbruikbare micro-tests.
  • Voegt deze micro-tests toe aan een auxiliaire testset ($U_k$).
  • Zorgt ervoor dat toekomstige kandidaten die dezelfde fout maken direct worden afgewezen tijdens de smoke-test, zonder dure volledige simulaties.
• Reparatie: Een Reflexion-agent analyseert fouten (gebaseerd op AST-traces en golfformaten) en stelt gerichte reparaties voor in plaats van het hele module opnieuw te genereren.

3. Portable Controller

De escalatielogica is ontworpen als een losse laag die bestaande Verilog-generatiepijplijnen (zoals AutoVCoder of VerilogCoder) kan "omhullen" zonder hun interne prompts of tools aan te passen. Dit maakt de methode breed toepasbaar.

Belangrijkste Bijdragen

1. HDLFORGE Framework: Een tweestaps-framework dat standaard een klein model gebruikt en alleen schakelt naar een groot model wanneer een gekalibreerde score dit vereist, wat de afweging tussen nauwkeurigheid en latentie verbetert.
2. Portable Escalatiecontroller: Een modulaire laag die bestaande pipelines kan verbeteren zonder hun interne architectuur te wijzigen.
3. CEGIS-Style Micro-Test Generator: Een agent die formele tegenvoorbeelden omzet in deterministische micro-tests, wat de bugdetectie versnelt en het aantal reparatie-iteraties drastisch verlaagt.
4. Gesloten Lus Multi-Agent Systeem: Een ontwerp waarbij agenten (Coder, Specialist, Judge, Formal Amplifier) uitsluitend communiceren via tool-niveau signalen (scores, traces, tests), wat nieuw is in de Verilog-LLM literatuur.

Resultaten

Het framework is geëvalueerd op de benchmarks VerilogEval Human, VerilogEval V2 en RTLLM.

• Nauwkeurigheid vs. Latentie:
  • HDLFORGE-Qwen (gebaseerd op Qwen-7B + Claude 3.5) bereikt 91,2% Pass@1 op VerilogEval Human en 91,8% op V2. Dit is een aanzienlijke verbetering ten opzichte van andere 7B-modellen (bijv. AutoVCoder scoort hier ~48,5%).
  • HDLFORGE-GPT4o (gebaseerd op GPT-4o + Claude 3.5) bereikt 95,5% Pass@1 op Human en 96,8% op V2, wat beter is dan systemen die alleen grote modellen gebruiken (zoals CoopetitiveV).
  • Op RTLLM bereikt HDLFORGE-Qwen 97,2% Pass@5.
• Efficiëntie:
  • HDLFORGE-Qwen heeft een ongeveer 50% lagere mediane latentie dan systemen die direct grote modellen gebruiken, terwijl de nauwkeurigheid aanzienlijk hoger is dan andere middelgrote modellen.
  • De escalatie naar Fase B gebeurt slechts bij ongeveer 10-15% van de taken, wat de kosten beperkt.
• Bug-Injectie Studie:
  • Met de micro-test amplifier stijgt de detectiegraad van bugs naar 95% (tegenover 64-72% bij baselines).
  • Het aantal reparatie-iteraties daalt van gemiddeld 7 naar 3, en de wall-clock tijd neemt af.
• Ablatie Studies:
  • Het verwijderen van enige agent (zoals de Judge, Tracer of Micro-tests) leidt tot een daling van de nauwkeurigheid met 4-5 procentpunten en een toename van de tijd, wat aantoont dat elke component essentieel is.

Betekenis en Conclusie

HDLFORGE bewijst dat het niet noodzakelijk is om voor elke taak het grootste en duurste model te gebruiken. Door slimme escalatie en het gebruik van formele methoden (BMC) om herbruikbare tests te genereren, kan het systeem:

1. De productiviteit van hardwareontwerpers verhogen door snellere en nauwkeurigere codegeneratie.
2. De kosten van LLM-inference verlagen door alleen dure resources te gebruiken waar nodig.
3. Een nieuwe standaard bieden voor multi-agent systemen in hardwareontwerp, waarbij de integratie van formele verificatie en LLM's leidt tot robuustere resultaten.

De portabiliteit van de controller maakt het een praktische tool die direct op bestaande workflows kan worden toegepast om de snelheid-nauwkeurigheid afweging te optimaliseren.