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

HDLFORGE ist ein zweistufiges Multi-Agenten-Framework, das durch adaptive Eskalation von kompakten zu leistungsstärkeren LLMs und einen gegenbeispielgesteuerten formalen Agenten die Genauigkeit bei der Verilog-Code-Generierung verbessert und dabei die Latenz im Vergleich zu einstufigen Systemen signifikant reduziert.

Das Wesentliche

Stellen Sie sich vor, Sie müssen ein sehr komplexes mechanisches Uhrwerk bauen (das ist im Computer-Jargon der Verilog-Code, der steuert, wie ein Chip funktioniert). Normalerweise würde man dafür einen einzigen, extrem teuren und genialen Uhrmacher (einen riesigen KI-Modell) beauftragen. Das Problem: Diese Genies sind langsam und kosten eine Vermutung. Wenn man sie für jede kleine Schraube einsetzt, wird das Projekt teuer und dauert ewig.

Die Forscher von HDLFORGE haben eine clevere Lösung gefunden, die wie ein zweistufiges Werkstatt-Team funktioniert. Hier ist die Erklärung, wie das System im Alltag funktioniert:

1. Das Team: Der schnelle Handwerker und der große Meister

Statt immer den teuersten Meister zu rufen, hat HDLFORGE zwei Ebenen:

• Stufe A (Der schnelle Handwerker): Das ist ein kleinerer, schneller KI-Assistent (wie ein talentierter Lehrling). Er versucht, das Uhrwerk zu bauen. Er ist schnell, günstig und kann die meisten einfachen Aufgaben perfekt lösen.
• Stufe B (Der große Meister): Das ist ein riesiges, ultra-leistungsfähiges KI-Modell (wie ein weltberühmter Uhrmacher). Dieser wird nur angerufen, wenn der Handwerker wirklich nicht weiterkommt.

2. Der intelligente Chef (Der Eskalations-Controller)

Das Herzstück ist ein „intelligenter Chef", der genau weiß, wann er den Meister holen muss. Er schaut sich nicht blind auf das Ergebnis, sondern nutzt einen Diagnose-Check:

• Passt das Design überhaupt zusammen? (Kompilierung)
• Gibt es offensichtliche Fehler im Code? (Lint-Prüfung)
• Funktioniert es in einer kleinen Testumgebung? (Rauch-Test)

Wenn der Handwerker einen Fehler macht, aber der Chef merkt: „Das ist ein kleiner Tippfehler, der Handwerker kann das selbst korrigieren", dann bleibt er bei Stufe A. Erst wenn der Chef sieht: „Der Handwerker läuft im Kreis, wir brauchen Hilfe", wird der teure Meister (Stufe B) hinzugezogen. Das spart enorm viel Zeit und Geld.

3. Die magische Zeitmaschine (Formaler Agent & Mikro-Tests)

Das ist die genialste Erfindung des Papiers. Wenn der Handwerker einen Fehler macht, passiert oft Folgendes: Er versucht es, scheitert, versucht es anders, scheitert wieder. Er vergisst, warum er gescheitert ist.

HDLFORGE hat einen speziellen „Fehler-Detektiv":

1. Wenn ein Fehler auftritt, erstellt dieser Detektiv eine Zeitlupe-Aufnahme (einen sogenannten „Counterexample"-Trace), die genau zeigt, wo das Uhrwerk stecken bleibt.
2. Aus dieser Aufnahme baut er einen winzigen, automatisierten Test-Check (ein Mikro-Test).
3. Der Clou: Dieser Test wird in den Werkzeugkasten gelegt. Wenn der Handwerker beim nächsten Versuch denselben Fehler macht, wird er sofort vom Test-Check abgefangen, noch bevor er die ganze Arbeit neu machen muss.

Stellen Sie sich vor, Sie haben eine Liste mit „Fehler, die wir schon einmal gemacht haben". Wenn Sie versuchen, das Gleiche falsch zu machen, sagt Ihnen die Liste sofort: „Halt! Das haben wir schon probiert, es geht nicht!" Das spart unzählige Versuche.

4. Das Ergebnis: Schnell, günstig und trotzdem perfekt

In Tests hat sich gezeigt, dass dieses System:

• Schneller ist: Weil es die meisten Aufgaben vom schnellen Handwerker erledigen lässt.
• Genauso gut ist: Weil der große Meister nur für die wirklich schwierigen Fälle einspringt.
• Dynamisch lernt: Durch die Mikro-Tests wird das System mit jedem Fehler schlauer und macht weniger Wiederholungen.

Zusammengefasst:
HDLFORGE ist wie eine intelligente Werkstatt, die nicht blindlings den teuersten Experten für jeden Auftrag ruft. Stattdessen nutzt sie einen schnellen Assistenten, der von einem cleveren Chef überwacht wird. Wenn der Chef merkt, dass es zu schwierig wird, holt er den Experten. Und das Beste: Das Team lernt aus jedem Fehler, indem es sich eine „Spickzettel"-Liste mit den spezifischen Fehlern anlegt, damit sie nie wieder passieren. So wird das Bauen von Computer-Chips schneller, billiger und fehlerfreier.

Technische Zusammenfassung

Hier ist eine detaillierte technische Zusammenfassung des Papers „HDLFORGE: A Two-Stage Multi-Agent Framework for Efficient Verilog Code Generation with Adaptive Model Escalation" auf Deutsch.

1. Problemstellung

Die Nutzung von Large Language Models (LLMs) zur Generierung von Verilog-Code (HDL) hat zwar die Produktivität erhöht, führt jedoch häufig zu Syntaxfehlern, funktionalen Bugs und Halluzinationen, selbst bei kleinen Designs. Bestehende Ansätze zur Verilog-Generierung nutzen oft feste Modellgrößen und behandeln die Rechenzeit sowie die Kosten als sekundäre Faktoren.
Das zentrale Problem besteht darin, einen optimalen Kompromiss zwischen Genauigkeit (korrekter Code) und Latenz/Kosten (Rechenzeit) zu finden. Die Verwendung von extrem großen Modellen für jede Aufgabe ist ineffizient, während reine Nutzung kleinerer Modelle oft zu unzureichender Codequalität führt. Zudem fehlt es vielen Systemen an effektiven Mechanismen, um Bugs frühzeitig zu erkennen und iterative Reparaturprozesse zu beschleunigen.

2. Methodik: HDLFORGE-Architektur

HDLFORGE ist ein zweistufiges Multi-Agenten-Framework, das die Generierung von Verilog-Code durch adaptive Eskalation optimiert. Das System besteht aus sieben koordinierten Agenten, die in zwei Hauptphasen arbeiten:

A. Die zwei Stufen (Stages)

1. Stufe A (Primärer Solver):
   • Nutzt ein kompaktes Modell (z. B. Qwen2.5-Coder-7B) als Standard.
   • Führt iterative Generierungs- und Reparaturzyklen durch, gesteuert durch kostengünstige Feedback-Schleifen (Kompilierung, Linting, Smoke-Tests).
   • Ziel ist es, die meisten Aufgaben schnell und kosteneffizient zu lösen.
2. Stufe B (Finaler Versuch):
   • Wird nur bei Bedarf aktiviert, wenn Stufe A nicht erfolgreich ist.
   • Nutzt ein ultra-großes Cloud-Modell (z. B. Claude 3.5 Sonnet).
   • Erhält Kontextinformationen über gescheiterte Versuche und Verdachtsbereiche, um eine hochwertige Lösung zu generieren.

B. Der Eskalations-Controller

Ein zentrales Element ist der kalibrierte Eskalations-Controller. Er entscheidet basierend auf einem Score $Z$, wann von Stufe A zu Stufe B gewechselt werden muss. Der Score wird aus fünf diagnostischen Signalen berechnet:

• $s_{comp}$: Erfolg der Kompilierung.
• $s_{lint}$: Codequalität (Anzahl der Warnungen).
• $s_{smoke}$: Konsistenz bei kurzen Smoke-Tests.
• $s_{trace}$: Stabilität der Fehlerlokalisierung über Versuche hinweg.
• $s_{budget}$: Verbleibendes Budget an Versuchen.
  Nur wenn der Score einen Schwellenwert $\tau$ unterschreitet oder das Budget erschöpft ist, erfolgt die Eskalation.

C. Counterexample-Guided Formal Agent (CEGIS-Ansatz)

Ein innovativer Bestandteil ist der Tiny Formal Amplifier Agent ($A_{form}$):

• Er führt Bounded Model Checking (BMC) durch, um Sicherheitsverletzungen zu finden.
• Aus den gefundenen Gegenbeispiel-Traces (Counterexamples) werden wiederverwendbare Mikro-Tests (Micro-tests) generiert.
• Diese Mikro-Tests werden in einen Hilfs-Testpool aufgenommen und bei zukünftigen Smoke-Tests sofort ausgeführt. Dies verhindert, dass derselbe Fehler erneut generiert wird, und beschleunigt die Fehlererkennung erheblich.

D. Workflow der Stufe A

1. Multi-Plan Generation: Ein Planner-Agent erstellt mehrere Implementierungsstrategien.
2. Candidate Implementation: Ein Coder-Agent generiert parallele Kandidaten.
3. Rapid Selection: Ein Judge-Agent filtert Kandidaten durch Kompilierung und Smoke-Tests.
4. Full Testing & Failure Analysis: Der beste Kandidat wird mit dem offiziellen Testbench getestet. Bei Fehlern analysieren ein Tracer-Agent (AST-basierte Rückverfolgung) und ein Reflexion-Agent die Fehlerursache.
5. Micro-Test Accumulation: Der Formal-Agent wandelt Fehler in Mikro-Tests um, die den Testpool erweitern.
6. Repair & Iteration: Der Coder repariert den Code basierend auf den neuen Mikro-Tests.

3. Hauptbeiträge

1. HDLFORGE-Framework: Einführung eines zweistufigen Multi-Agenten-Systems, das standardmäßig kleine Modelle nutzt und nur bei Bedarf auf große Modelle eskaliert, was den Genauigkeits-Latenz-Kompromiss verbessert.
2. Portabler Eskalations-Controller: Die Eskalationslogik kann als externe Schicht über bestehende Verilog-LLM-Pipelines (wie AutoVCoder oder VerilogCoder) gelegt werden, ohne deren interne Prompts oder Modelle zu ändern.
3. Formaler Mikro-Test-Amplifier: Umwandlung von BMC-Traces in deterministische Mikro-Tests, die die Fehlererkennung beschleunigen und die Anzahl der Reparaturiterationen reduzieren.
4. Geschlossener Regelkreis: Ein System, in dem Agenten nur über Tool-Signale (Scores, Traces, Tests) interagieren, was eine neue Architektur im Bereich Verilog-LLMs darstellt.

4. Ergebnisse

Die Evaluierung erfolgte auf den Benchmarks VerilogEval Human, VerilogEval V2 und RTLLM.

• Genauigkeit vs. Latenz:
  • HDLFORGE-Qwen (mit 7B-Modell in Stufe A) erreicht 91,2 % Pass@1 auf VerilogEval Human und 91,8 % auf V2. Dies ist eine drastische Verbesserung gegenüber anderen 7B-Modellen (z. B. AutoVCoder mit ~48 %).
  • Die Median-Latenz ist im Vergleich zu Systemen, die durchgehend große Modelle nutzen, um ca. 50 % niedriger.
  • Auf RTLLM wird 97,2 % Pass@5 erreicht.
• Vergleich mit großen Modellen:
  • HDLFORGE-GPT4o (Stufe A mit GPT-4o) erreicht 95,5 % Pass@1 (Human) und 96,8 % (V2), was die Leistung von Systemen wie CoopetitiveV und MAGE (die durchgehend große Modelle nutzen) übertrifft oder gleichzieht, bei oft besserer Latenz.
• Portabilität:
  • Das Framework konnte erfolgreich auf AutoVCoder und VerilogCoder angewendet werden. Die Genauigkeit stieg um 3–5 Prozentpunkte bei nur geringfügiger Erhöhung der Latenz (<10 %).
• Bug-Injection-Studie:
  • Das System mit Mikro-Tests erkannte 95 % der injizierten Bugs (gegenüber 64–72 % bei Baselines).
  • Die Anzahl der benötigten Reparaturiterationen sank von 7,0 auf 3,0, und die Gesamtzeit verringerte sich trotz des Overheads durch formale Checks.

5. Bedeutung und Fazit

HDLFORGE demonstriert, dass die reine Vergrößerung von Modellen nicht der einzige Weg zu besserer HDL-Generierung ist. Durch die intelligente Kombination aus:

1. Adaptiver Ressourcennutzung (Kleines Modell zuerst, großes Modell nur bei Bedarf),
2. Formaler Verifikation (CEGIS-Ansatz mit Mikro-Tests) und
3. Multi-Agenten-Kollaboration

kann ein System erreicht werden, das sowohl kosteneffizient als auch hochpräzise ist. Die Fähigkeit, das Framework als „Wrapper" über existierende Pipelines zu legen, macht es zu einem vielseitigen Werkzeug für die Hardware-Entwicklung, das die Genauigkeit bestehender Systeme ohne aufwendiges Re-Training signifikant steigern kann. Dies markiert einen wichtigen Schritt hin zu ressourcenoptimierten, verifizierungsgetriebenen KI-Systemen im Hardware-Design.