De formele verifier zei "bewezen." De chip was nog steeds kapot.

De eerste keer dat een van onze eigen tools tegen me loog, deed het dat beleefd. De formele engine gaf een groen vinkje terug. Elke eigenschap die we hadden gevraagd te bewijzen kwam terug als bewezen. De assertiebibliotheek leek compleet. Op papier was het ontwerp geverifieerd.

Het kostte ons twee dagen om te beseffen dat het certificaat waardeloos was — en dat alles wat ik had aangenomen over semiconductor AI-verificatie ons beschermde tegen de verkeerde fout.

De eigenschappen waren gegenereerd door een large language model dat we om de formele engine hadden gewikkeld — precies het soort gladde agentic chipontwerp-demo dat iedereen aan het bouwen was. En de engine had ze in milliseconden bewezen, wat het verklikkersignaal had moeten zijn. Ze waren bewezen omdat de voorwaarden die ze zouden testen nooit werden geactiveerd. Een eigenschap die zegt "elk verzoek krijgt uiteindelijk een toewijzing" is triviaal waar als het verzoek nooit kan plaatsvinden. De solver had geen ongelijk. Hij beantwoordde de vraag die we per ongeluk stelden, en de vraag was leeg. Dat is het moment waarop ik begreep waartegen deze AI-verificatiepijplijnen zich werkelijk moeten verdedigen — en waarom bijna niemand die er een verkocht zich tegen het juiste verdedigde.

Ik wil je vertellen wat we vonden, want de bugklassen die moderne chips om zeep helpen zijn niet degene die de industrie adverteert te kunnen vangen. Wij bouwen maatwerk verificatiepijplijnen voor fabless chipteams — fijnafgestemde open-weight-modellen gewikkeld om de formele engine die een team al bezit, die volledig op hun eigen hardware draaien — en de hele aanpak is voortgekomen uit dit eerst verkeerd doen. Je kunt de vorm ervan zien op veriprajna.com/solutions/semiconductor-ai-verification. Maar de aanpak slaat pas ergens op zodra je een "geslaagd" ontwerp hebt zien falen.

Een getal dat elke fabless CFO zou moeten doen huiveren

Eén statistiek kadert het hele probleem. De 2024 Wilson Research Group / Siemens EDA Functional Verification-studie — de langstlopende benchmark in de industrie — zette first-silicon-succes op 14%. Het laagste dat het in twintig jaar bijhouden is geweest. In 2020 lag dat getal rond de 32%. Het is in vier jaar meer dan gehalveerd.

Dat is geen verhaal over ingenieurs die lui worden. Het is een verhaal over complexiteit die de tools ontgroeit, en over een specificatie die sneller muteert dan de testbench die haar achtervolgt. Dezelfde studie vond dat ruwweg 70% van de respins wordt veroorzaakt door fouten die verband houden met specificatiewijzigingen — geen pure logicabugs.

First-silicon-succes daalde niet doordat chipteams slechter werden. Het daalde doordat de specificatie nu sneller beweegt dan verificatie haar kan afsluiten.

Ik heb lang bij dat getal van 70% stilgestaan, want het klaagt in stilte een hoop "AI voor chipontwerp"-pitches aan. Als de meeste respins voortkomen uit spec drift, dan pakt een tool die alleen logicabugs vangt een deel van het probleem aan en noemt dat de hele taart.

En de kosten van fout zitten zijn wreed op een manier die softwaremensen onderschatten. Een 5nm-maskerset kost $10–20M. Bij 3nm nader je $40M, met zeventig-plus maskerlagen waaronder meer dan twintig EUV-lagen. Een volledige 2nm-tape-out kost nu in de orde van $725M all-in. Wanneer er iets doorheen glipt, is een respin een schuif in de planning van 3 tot 6 maanden bovenop de maskerrekening. In een productvenster van achttien maanden kan een schuif van zes maanden de helft van de levensduuromzet van een chip wegvagen. De CFO ziet verificatie niet als een kostenpost. Ze zien het als verzekering tegen één enkele achtcijferige vergissing.

Hoe hallucineert een LLM eigenlijk in hardware?

Je team gebruikt al LLM's op Verilog. Ik ga niet doen alsof het anders is, en niemand die aan jou verkoopt zou dat moeten doen. Het onderzoeksveld is nu echt — papers over LLM's die Verilog schrijven gingen van één in 2020 naar vierenzestig in 2025. Op de moeilijkere problemen in de VerilogEval-benchmark halen GPT-4-klasse modellen rond de 43% functionele correctheid. Nuttig. Niet betrouwbaar.

De interessante vraag is niet of de modellen helpen. Het is hoe ze falen, want de faalmodi zien er niet uit als de fouten die software-engineers zijn getraind te vrezen. Na genoeg late avonden staren naar waarom "correct ogende" RTL misging, begon ik de fouten in vijf klassen in te delen.

De eerste is de onschuldige. Syntactische hallucinatie — code die simpelweg niet compileert. Verilator of de synthese-frontend vangt het in seconden. Iedereen weet hier al mee om te gaan, en het is de klasse waar mensen naar wijzen wanneer ze willen beweren dat het probleem is opgelost.

De tweede is waar het begint pijn te doen. Semantische hallucinatie, en het schoolvoorbeeld is blocking versus non-blocking assignment. Een model getraind op Python en C leest Verilog alsof statements van boven naar beneden worden uitgevoerd. Dus schrijft het een blocking assignment — een gewone = — binnen een geklokt always_ff-blok waar de taal de non-blocking <= vereist. De ontwerper wilde een tweecyclus-pijplijn. Met blocking assignments leest de tweede fase de nieuwe waarde van de eerste, niet de oude, en het silicium verscheept een bypass van één cyclus in plaats daarvan. Sommige simulators plannen de events in een volgorde die de race volledig verbergt. Het simuleert prima. Het synthetiseert naar de verkeerde machine.

De derde klasse is degene die me leerde de AMBA-spec open te houden op een tweede monitor. Protocol-hallucinatie. De code compileert, doorstaat negentig procent van de gerichte tests, en asserteert vervolgens een write-data-valid-signaal voordat de slave klaar is om het adres te accepteren — een schending van de AXI-handshake. Of het houdt een valid-signaal hoog terwijl het de data eronder omdraait. Of het triggert een subclausule verstopt op pagina 84 van de busspecificatie die geen mens uit het hoofd heeft geleerd. De chip werkt perfect op je interne testharnas en loopt vast op het moment dat hij wordt bedraad aan een geheugencontroller van derden. Je kunt dit niet met brute kracht oplossen met meer simulatiecycli. Je vangt het met vooraf geverifieerde assertiebibliotheken geschreven tegen elk protocol.

De vierde klasse is degene die ons voor de gek hield, en het is de gevaarlijke.

Waarom is "bewezen" het gevaarlijkste woord in een verificatierapport?

Vacuïteit-hallucinatie. Het model genereert een SystemVerilog-assertie. De formele engine bewijst het. Je verscheept. En de eigenschap was triviaal waar omdat het antecedent — het "als"-deel — in de eerste plaats nooit waar werd.

Stel je een arbiter-eigenschap voor: als een verzoek wordt aangeboden, moet er binnen een aantal cycli een toewijzing volgen. Stel nu dat hetzelfde model, in een poging behulpzaam te zijn, ook een aanname schreef die het verzoeksignaal laag forceert. De formele engine bewijst plichtsgetrouw de toewijzingseigenschap in milliseconden, want er is geen verzoek dat het ooit zou schenden. De echte arbiter eronder zou volledig kapot kunnen zijn. Het certificaat zegt "bewezen." Het is waardeloos.

Een formeel bewijs dat in milliseconden draait is niet snel. Het is verdacht. De engine heeft mogelijk helemaal niets bewezen.

Dit is geen randrisico. Siemens publiceert al sinds 2017 waarschuwingen over vacuë bewijzen, en het veld verscheept nog steeds flows zonder automatische vacuïteitscontrole. Als ik mensen vertel dat een formele verificatieflow zonder vacuïteitsdetectie erger is dan geen formele verificatie, denken ze dat ik dramatisch doe. Dat is niet zo. Geen verificatie laat je gepast bang achter. Een vacuë "bewezen" laat je zelfverzekerd en fout achter, met een afgetekend blok op weg naar tape-out. Dat is de fout die bijna verscheept werd in ons eigen vroege prototype, en het veranderde permanent wat we bouwen.

De vijfde klasse is degene die simulatie structureel niet kan zien. Clock-domain-crossing-blinde vlekken. Een LLM leest signaalnamen; het neemt geen clock domains waar. Dus verbindt het een signaal van een 2 GHz CPU-domein rechtstreeks in een 400 MHz peripheral-domein-flop, en slaat de dubbele-flop-synchronizer over die metastabiliteit voorkomt. RTL-simulatie modelleert geen metastabiliteit — dus slaagt de regressie, elke keer, en het silicium loopt vast in het veld. Dit is waarom CDC-bugs maskersets opeten. Het is ook waarom Accellera in 2024 een CDC/RDC-interoperabiliteitsstandaard opende: de fragmentatie over de commerciële CDC-tools was erg genoeg geworden om sign-off te breken.

Klassen twee tot en met vijf delen één angstaanjagende eigenschap: ze doorstaan de simulatie. Ze komen pas in silicium aan de oppervlakte. Dat is de subset van bugs die tape-outs nog steeds opblaast, en het is precies de subset die een "vangt logicabugs"-pitch op tafel laat liggen.

De vendormuur waar een chipteam eigenlijk voor staat

Toen ik op zoek ging naar werkelijk onafhankelijke hulp bij een tape-out, kwam ik uit op minder opties dan ik een paar jaar eerder had gehad — en dat is geen nostalgie, het is de marktstructuur. De drie EDA-vendors waaruit een design-verification-lead daadwerkelijk kan kiezen — Synopsys, Cadence, Siemens — zijn gegaan van onder de 75% van de markt tien jaar geleden naar meer dan 85% vandaag. Tel Synopsys' $35B Ansys-overname erbij en de top vier controleert ruwweg 90%. Het veld waarin een fabless startup winkelt is versmald, niet verbreed, precies terwijl het probleem moeilijker werd.

En de gevestigde partijen staan niet stil op AI. Synopsys leverde AgentEngineer in maart 2026, een agentic verificatieworkflow die twee-tot-vijf-maal productiviteit claimt, en het zit bovenop VC Formal — de meest geloofwaardige agentic vendor-stack die ik heb geëvalueerd. Cadence kondigde zijn ChipStack AI Super Agent aan in februari 2026 en draait Cerebrus AI Studio voor reinforcement-learning-gedreven implementatie, met JasperGold dat de gouden-standaard formele engine blijft waaraan iedereen anders wordt afgemeten. Ik zeg dat zonder voorbehoud: JasperGold en VC Formal zijn oprecht uitstekend. Iedereen die een pitch opent door ze af te kraken heeft je verteld dat ze nooit een echte tape-out hebben afgesloten.

Het addertje zit in de prijsstelling en de houding. JasperGolds historische basislijn lag rond de $225K plus $45K per seat — prima voor een groot fabless bedrijf, buiten bereik voor de early-stage RISC-V- en AI-accelerator-startups die het meest interessante werk doen. En de nieuwste AI-features van de gevestigde partijen zijn cloud-first, wat frontaal botst met de ene eis waarop deze klanten niet zullen buigen. Daarover zo meer.

Dan is er de startup-golf, en die is luid. Op de laatste DAC en DVCon was een DV-lead met wie ik werk in één enkel kwartaal gepitcht door acht verschillende "agentic AI voor chipontwerp"-bedrijven. ChipAgents heeft begin 2026 $74M opgehaald en claimt tien-maal ontwerp-en-verificatie-productiviteit. Normal Computing haalde $50M op onder leiding van Samsungs Catalyst Fund, en bouwt auto-formalisatie — LLM's die de intentie van de ingenieur rechtstreeks vertalen naar formele eigenschappen en ze bewijzen — en zegt dat de helft van 's werelds top-tien halfgeleiderontwerpbedrijven het gebruikt. Er zijn er meer: MooresLabAI die volledige testbenches genereert, Bronco voor regressieanalyse, Silimate voor power-performance-area-voorspelling.

Sommige hiervan zijn echt. Geen van hen lost het werkelijke probleem van de klant op, namelijk dat ze nu drie van deze puntoplossingen hebben gekocht en geen idee hebben hoe ze die samen kunnen laten werken binnen de sign-off-flow die ze al vertrouwen.

Het reinforcement-learning-placement-verhaal dat niemand hardop wil zeggen

Er is een parallelle verleiding in chipontwerp voorbij verificatie: reinforcement learning gebruiken om de fysieke floorplanning te doen — beslissen waar de grote blokken op de die komen te zitten. Het is verleidelijk, en het meest geciteerde resultaat is aangevochten op een manier die de meeste pitches gemakshalve overslaan.

De Google Nature-paper uit 2020 claimde dat RL simulated annealing verslaat voor macro placement, en het is gebruikt in echt silicium — TPU-generaties zijn ermee verscheept. Maar in 2023 voegde Nature een redactionele noot toe nadat methodologische zorgen werden geopperd. Igor Markov, nu bij Synopsys, publiceerde een regel-voor-regel-kritiek waarvan de kernvergelijking moeilijk te vergeten is: de RL-aanpak kostte 32,31 uur, een afgestemde simulated-annealing-basislijn kostte 12,5 uur, en een commerciële Cadence-tool voltooide dezelfde klus in 0,05 uur. DeepMind sloeg terug met een paper getiteld "That Chip Has Sailed." Jaren later heeft geen enkele onafhankelijke externe replicatie de oorspronkelijke claims bevestigd, en zowel de kritiek als de weerlegging staan nog steeds overeind.

Ik breng dit ter sprake vanwege wat er gebeurt wanneer een consultant RL placement pitcht aan een echt formeel team en doet alsof de controverse niet bestaat. Ze ruiken het binnen tien minuten, en je bent de zaal kwijt. De eerlijke positie is dat er echte niches zijn — chiplet- en 3D-IC thermisch-bewuste floorplanning, analoge layout, RISC-V IP-optimalisatie op open tooling — waar een hybride aanpak zijn geld waard is. Een frontale aanval op de placement-engines van de gevestigde partijen niet. Het verschil kennen, en het hardop zeggen, is de hele klus.

Wat er veranderde nadat onze tool ons voor de gek hield

Dus hier is waar de vacuë-bewijs-ramp ons naartoe leidde. We stopten met proberen een betere AI te bouwen die Verilog schrijft, want dat is een drukke race met acht gefinancierde deelnemers, en begonnen het ding te bouwen dat geen van hen verkoopt: de vendor-neutrale integratielaag die de bestaande tools van een team betrouwbaar maakt.

Concreet betekent dat een paar beslissingen, elk afgedwongen door een fout die we hadden gezien. We stemmen een open-weight-model fijn — Qwen Coder, Llama, welke ook past — op het eigen RTL-corpus van de klant, hun specs, hun bughistorie uit het verleden, want een model dat jouw huisstijl niet heeft gezien hallucineert ertegen. We wikkelen het om welke formele engine het team ook al bezit: JasperGold, VC Formal, Questa Formal, of open-source SymbiYosys. We vragen ze nooit om de gouden-standaard tool die ze al vertrouwen eruit te rukken. En elke eigenschap die het model voorstelt loopt door vacuïteit- en dekkingscontroles voordat iemand het woord "bewezen" mag lezen — want we hebben op de dure manier geleerd dat een onbewaakt bewijs theater is.

De vooraf geverifieerde assertiebibliotheken doen er net zoveel toe als het model. Voor een RISC-V-core wordt het formele harnas geleverd met de AXI4-, AHB- en TileLink-compliancechecks, de pipeline-hazard-asserties, de load-store-scoreboarding, de debug-unit-correctheidseigenschappen — de dingen die protocol- en semantische hallucinatie vangen voordat het silicium het doet. Dit is niet speculatief. Het formele adviesbureau Axiomise heeft 65+ bugs in Ibex gevonden, de open RISC-V-core binnen Googles OpenTitan, waaronder branch-instructie-bugs in de debug-unit die alleen formeel kon vangen. Formeel werkt op RISC-V. Het schaarse ding is niet de methode; het is een team dat weet hoe het te hanteren.

De echte opening hier was nooit een slimmer Verilog-model. Het was een eerlijk harnas gewikkeld om de dure tools die een team al vertrouwt.

Waarom draai je het niet gewoon in de cloud?

Mensen vragen me dit voortdurend, en het antwoord is dezelfde reden dat elke cloud-first EDA-AI-startup dood is bij aankomst bij de klanten die mij aan het hart gaan: RTL is het kroonjuweel, en het verlaat het gebouw niet.

De register-transfer-level-code van een fabless bedrijf is het bedrijf. Defensie- en luchtvaartklanten hebben het air-gapped nodig, soms in een beveiligde faciliteit. Commerciële fabless teams willen on-prem, virtual-private-cloud op zijn allerminst. Dus draaien we alles op de eigen hardware van de klant — vLLM of vergelijkbare inference op hun bestaande H100- of H200-cluster, lokale retrieval over hun eigen corpus, geen RTL dat ooit de netwerkgrens oversteekt. De nieuwste agentic features van de gevestigde partijen zijn cloud-first; dat is een feature voor hen en een non-starter voor een IP-gevoelig chipteam. De grootste opening die ik zie is helemaal geen algoritmenprobleem. Het is een deployment-en-integratieprobleem dat de mensen met de beste algoritmen hebben besloten niet op te lossen.

De andere vraag komt van de automotive-teams, en het is degene die alles voor hen bepaalt. Verscheep een chip in een auto op ASIL C of D — de safety integrity levels waar ISO 26262 formele verificatie niet langer slechts suggereert maar begint te verplichten — en de tool zelf moet een TCL2- of TCL3-kwalificatiepakket dragen. De kernengines van de gevestigde partijen hebben die certificering door derden; een gloednieuwe AI-tool niet. Ik heb een werkelijk betere tool op de bank zien belanden in een automotive-programma om precies deze reden: geen kwalificatiepakket, geen plek in de sign-off-flow, einde gesprek. Dus proberen we niet de gekwalificeerde tool te zijn. We helpen teams AI-assistentie naast de gekwalificeerde gevestigde engines te draaien zonder de kwalificatieketen te breken — want in automotive is een technisch superieure tool die een audit niet kan overleven niets waard.

Het certificaat is niet de chip

Ik blijf terugkomen op die twee dagen die we besteedden aan het vertrouwen van een groen vinkje dat niets betekende. De les was niet "LLM's zijn slecht in Verilog." Ze worden elk kwartaal beter. De les was dat in hardware de kloof tussen lijkt geverifieerd en is geverifieerd wordt gemeten in achtcijferige maskersets en schuiven van zes maanden — en de tools die deze ruimte in stormen racen er grotendeels om het "lijkt geverifieerd"-deel sneller te maken.

Op een maskerset van $10M is een "bewezen" die je niet kunt herleiden tot een niet-vacuum bewijs, gedraaid op hardware die jij beheert, tegen asserties geschreven door iemand die pagina 84 van de spec heeft gelezen — dat is geen verificatie. Het is een hoop met goede productiewaarden. Als je wilt zien hoe wij het verschil aangeven, staat het allemaal uiteengezet op veriprajna.com/solutions/semiconductor-ai-verification.

De chip geeft niet om wat het rapport zegt. Hij doet alleen wat het silicium daadwerkelijk gebouwd was om te doen. Verificatie is de discipline om die twee dingen hetzelfde te maken — en op het moment dat een AI je vertelt dat ze in milliseconden hetzelfde zijn, is dat precies wanneer je naar de spec zou moeten grijpen.