De AI die bepaalt wie schuld heeft aan uw auto-ongeluk zit waarschijnlijk fout — en zo bouw ik een betere

Een paar maanden geleden zag ik een demo waar ik misselijk van werd.

Een goed gefinancierde insurtech-startup pronkte met hun nieuwe tool voor het automatiseren van schadeclaims. Ze voerden een politierapport in GPT-4 in, vroegen het de schuld te bepalen bij een aanrijding tussen twee auto's op een kruising, en eruit kwam een prachtig geschreven alinea die de aansprakelijkheid op 60/40 verdeelde. De oprichter straalde. De investeerders knikten. Het verhaal was helder, zelfverzekerd en — daar was ik vrijwel zeker van — fout.

Ik stelde een simpele vraag: "Voer het nog eens uit."

Zelfde rapport. Zelfde prompt. Deze keer: 70/30. Het model had tien procentpunt van iemands financiële aansprakelijkheid tussen twee runs verschoven, omdat het een probabilistische tekstgenerator is, geen rechter. Het werd stil in de zaal. Iemand mompelde iets over temperatuurinstellingen.

Dat moment kristalliseerde alles waar mijn team bij Veriprajna naartoe had gewerkt. We hadden maanden besteed aan het bestuderen van hoe LLM's juridische redenering aanpakken, en de resultaten waren slechter dan ik had verwacht. Onderzoekers van Stanford hebben hallucinatiepercentages gedocumenteerd tussen 69% en 88% wanneer state-of-the-art modellen reageren op specifieke juridische vragen. Dit zijn geen randgevallen. Dit is de basislijn. En de verzekeringssector haast zich om deze systemen in te zetten om te beslissen wie betaalt wanneer uw auto wordt aangereden.

Ik ga u vertellen waarom dat gevaarlijk is, en wat we in plaats daarvan bouwen.

De nacht dat de breedsprakige bestuurder won

Voordat ik inga op architectuur en logica-engines, laat me u vertellen over een experiment dat mijn denken radicaliseerde.

We zetten een simpele test op. Twee verhalen die dezelfde aanrijding op een kruising beschreven, geschreven vanuit het perspectief van elke bestuurder. Bestuurder A had duidelijk een stopbord genegeerd — het politierapport bevestigde het, de getuige bevestigde het, het schadepatroon bevestigde het. Zonneklaar.

Maar we gaven Bestuurder A een verhaal van 500 woorden. Levendige details over het weer, de verblinding, de "agressieve versnelling" van de andere auto. Verfijnd vocabulaire. Emotionele textuur.

Bestuurder B kreeg 50 woorden: "Ik stopte bij de kruising. Ik keek of er dwarsverkeer was. Ik reed door. Bestuurder A raakte mijn passagierskant."

We voerden beide verklaringen in bij drie grote LLM's en vroegen elk de aansprakelijkheid te beoordelen.

Twee van de drie gaven Bestuurder A — degene die het stopbord had genegeerd — een gunstigere aansprakelijkheidsverdeling. Niet omdat de feiten dat ondersteunden, maar omdat Bestuurder A een beter verhaal vertelde.

Ik herinner me dat ik na middernacht op ons kantoor zat en naar die resultaten staarde. Mijn medeoprichter kwam erbij, keek naar het scherm en zei: "Dus we bouwen gerechtigheid voor de welbespraakten." Die zin bleef hangen. Dat is precies wat deze systemen doen.

Onderzoekers noemen dit breedsprakigheidsbias — de gedocumenteerde neiging van LLM's om hogere betrouwbaarheidsscores toe te kennen aan langere, gedetailleerdere antwoorden, zelfs wanneer de feitelijke inhoud gelijkwaardig aan of inferieur is aan beknopte alternatieven. Het model verwart tokendichtheid met bewijsdichtheid. Het houdt welsprekendheid aan voor waarheid.

Wanneer een AI-systeem beknoptheid bestraft en retorische franje beloont, discrimineert het structureel iedereen die minder opgeleid, minder welbespraakt of gewoon eerlijker is.

Denk na over wie hierdoor wordt geschaad. De oudere bestuurder die een rechttoe rechtaan verklaring geeft. De niet-moedertaalspreker van het Engels. De persoon die simpelweg de waarheid vertelt zonder opsmuk. Dit zijn de mensen die een geautomatiseerd aansprakelijkheidssysteem zou moeten beschermen, en in plaats daarvan oordeelt het systematisch tegen hen.

Waarom is uw AI het eens met alles wat u haar vertelt?

Breedsprakigheidsbias was niet de enige faalvorm die we vonden. Er is iets dat aantoonbaar erger is: vleierij.

LLM's worden getraind via een proces genaamd Reinforcement Learning from Human Feedback — RLHF — dat "behulpzaamheid" en "meegaandheid" beloont. Dit is prima wanneer u om een recept vraagt. Het is catastrofaal wanneer u om een juridisch oordeel vraagt.

We testten dit door hetzelfde politierapport met verschillende suggestieve prompts te kaderen. "Analyseer dit rapport om te bepalen of de eiser te hard reed" versus "Analyseer dit rapport om te bepalen of de eiser voorrang had." Dezelfde gegevens. Andere kadering. Het model neigde betrouwbaar zijn analyse naar welke hypothese de prompt ook impliceerde.

Een van mijn engineers noemde het "confirmation bias as a service," en sindsdien kan ik er niet meer anders over denken.

In een echte schadeafhandelingsomgeving zou een schade-expert onbewust een vraag kunnen kaderen op basis van zijn eerste lezing van de situatie. Het model pikt die kadering op en versterkt haar. Onderzoek toont aan dat dit in twee varianten gebeurt: progressieve vleierij, waarbij het model zijn redenering aanpast om tot uw gewenste conclusie te komen, en regressieve vleierij, waarbij het correcte informatie loslaat om het eens te zijn met een onjuiste tegenwerping. Hoe dan ook, u krijgt geen onpartijdige scheidsrechter. U krijgt een echoput.

Wat gebeurt er wanneer AI de wet verkeerd leest?

Ik moet u vertellen over het wetsartikelprobleem, want dat is degene die me 's nachts wakker houdt.

LLM's "kennen" het verkeersrecht niet. Ze hebben tekst opgenomen die het verkeersrecht bevat, en ze voorspellen sequenties van tokens die eruitzien als juridische redenering. Het onderscheid doet er enorm toe.

We vonden een geval waarin een model een "wie-het-eerst-arriveert"-voorrangsregel aanhaalde — gebruikelijk bij vierwegkruisingen met stopborden — en die toepaste op een T-splitsing, waar doorgaand verkeer absolute voorrang heeft. Het model signaleerde de mismatch niet. Het genereerde gewoon een zelfverzekerde, goed gestructureerde alinea die de verkeerde wet op de verkeerde situatie toepaste.

Een AI die een wetsartikel verzint en het met vertrouwen toepast, maakt geen fout. Het produceert onrecht op grote schaal.

Dit is wat onderzoekers juridische hallucinatie noemen, en het kent twee vormen. Feitelijke hallucinatie: het model leidt details af die niet in de brontekst aanwezig zijn om een samenhangend verhaal te creëren. Bij het lezen van "ernstige schade aan de voorzijde" zou het kunnen concluderen dat het voertuig te hard reed, ondanks het ontbreken van remspoormetingen of telemetrie. En eigenlijke juridische hallucinatie: het model interpreteert verkeerscodes en jurisprudentie verkeerd, past ze verkeerd toe of verzint ze regelrecht.

Een verzekeringsbeslissing gebaseerd op een gehallucineerde versie van California Vehicle Code § 21802 stelt de verzekeraar bloot aan procedures wegens kwade trouw en aan regelgevende sancties. En de verzekerde — het daadwerkelijke mens — krijgt een verkeerd oordeel geleverd met het gezag van "AI."

Ik heb over deze faalvormen uitgebreid geschreven in de interactieve versie van ons onderzoek, als u de volledige bewijsbasis wilt zien. Maar de korte versie is: LLM's zijn taalkundig briljant en logisch kapot, en we vragen ze om logica te bedrijven.

Het argument dat onze architectuur veranderde

Er was een specifiek argument binnen ons team dat alles vormde wat we daarna bouwden.

We discussieerden of we een betere RAG-pijplijn zouden bouwen — relevante wetsartikelen ophalen, ze aan de LLM voeren, de output beperken. De "maak de LLM slimmer"-aanpak. De helft van het team was ervan overtuigd dat dit het pragmatische pad was. Sneller uitleveren, itereren, de ophaalkwaliteit in de loop van de tijd verbeteren.

Ik stond aan de andere kant, en ik was het argument aan het verliezen totdat onze juridisch adviseur een vraag stelde die de zaal deed verstommen: "Als twee getuigen het oneens zijn over of het licht rood of groen was, wat doet uw systeem dan?"

Het RAG-team pauzeerde. Een LLM met opgehaalde context zou doen wat LLM's altijd doen — het verhaal kiezen dat coherenter aanvoelt, waarschijnlijk het langere, en een oplossing genereren. Het zou een consensus hallucineren.

"Het zou het conflict moeten vasthouden," zei ik. "Het zou moeten zeggen: dit is een betwist feit, en ik kan het niet oplossen zonder aanvullend bewijs."

Dat is niet iets wat een taalmodel doet. Taalmodellen lossen op. Ze voltooien. Ze genereren het volgende plausibele token. Een onopgeloste tegenstrijdigheid vasthouden en die als een lacune signaleren — dat vereist een fundamenteel ander soort systeem.

Dat is de dag dat we ons vastlegden op kennisgrafen.

Hoe verander je een politierapport in een graaf?

Wat we bij Veriprajna bouwen heet Knowledge Graph Event Reconstruction — KGER. Het kernidee is bedrieglijk eenvoudig: stop met AI te vragen om te oordelen, en begin haar te vragen om te reconstrueren.

Een politierapport is ongestructureerde tekst. Het bevat entiteiten — bestuurders, voertuigen, wegen, verkeerslichten, getuigen — en relaties daartussen. Voertuig A reed noordwaarts op Main Street. Voertuig B negeerde het stopbord op 4th Avenue. Het licht was groen. Het regende.

We gebruiken de LLM als een semantische extractor — een zeer geavanceerde klerk. Zijn taak is om de ongestructureerde tekst te lezen en entiteiten en relaties eruit te halen, en ze te koppelen aan een strikte ontologie die we hebben gedefinieerd. Onze ontologie bestrijkt meer dan 110 entiteit- en relatietypen: agenten, objecten, infrastructuur, gebeurtenissen, omstandigheden, metingen.

De LLM beslist niet wie schuldig is. Het catalogiseert actoren en handelingen. En omdat zijn output beperkt is tot een vooraf gedefinieerd schema, kunnen we alles wat het produceert valideren. Als het een "stopbord" extraheert waar onze kaartdatabase aantoont dat er geen stopbord bestaat, signaleert het systeem een conflict in plaats van de hallucinatie stilzwijgend te accepteren.

Eenmaal geëxtraheerd worden deze entiteiten knooppunten in een kennisgraaf. De relaties worden verbindingen. Voertuig_A → RIJDT_OP → Main_Street. Voertuig_B → OVERTRAD → Stopbord_1. Getuige_A → NAM_WAAR → Lichttoestand_Groen.

Het subjectieve verhaal is nu een objectieve topologie. En zodra je een topologie hebt, wordt schuld een kwestie van graaftraversering en patroonherkenning — niet van sentimentanalyse.

Kun je verkeersrecht omzetten in code?

Dit is het deel waar ik echt enthousiast van word, en het is het deel dat de meeste mensen onmogelijk achten.

Verkeersregels zijn geschreven in natuurlijke taal, vol vage termen als "onmiddellijk gevaar" en "veilige afstand." Rechtbanken interpreteren ze via precedenten en oordeel. Hoe maak je dat uitvoerbaar?

Het antwoord is Defeasible Deontic Logic — DDL. Deontische logica behandelt verplichtingen, verboden en toestemmingen. "Defeasible" (weerlegbaar) betekent dat het uitzonderingen aankan. Dit is precies wat verkeersrecht is: een reeks normen met gestructureerde uitzonderingen.

Neem California Vehicle Code § 21802, de stopbordregel. In natuurlijke taal: "De bestuurder van elk voertuig dat een stopbord nadert, dient te stoppen... De bestuurder dient vervolgens voorrang te verlenen aan alle voertuigen die vanaf een andere weg zijn genaderd."

In ons systeem wordt dit uitvoerbare logica:

Regel 1 — Verplichting om te Stoppen: Als een voertuig een kruising met een stopbord nadert, is de bestuurder verplicht om de snelheid tot nul te brengen bij de stopstreep. Als de snelheid groter is dan nul bij het binnenrijden van de kruising, is dat een overtreding.

Regel 2 — Verplichting om Voorrang te Verlenen: Als de bestuurder is gestopt maar een ander voertuig zich op of nabij de kruising bevindt, moet de bestuurder wachten. Als hij binnenrijdt terwijl het andere voertuig aanwezig is en er een botsing plaatsvindt, is dat een overtreding wegens het niet verlenen van voorrang.

Regel 3 — Uitzondering: Als een politieagent het verkeer regelt, gaat de aanwijzing van de agent boven het bord. De uitzondering weerlegt formeel de primaire regel.

Nu komt het punt waar het krachtig wordt. We koppelen de fysieke graaf — de reconstructie van de snelheid en positie van elk voertuig in de tijd — aan dit logische sjabloon. Als de graaf laat zien dat Voertuig A de kruising binnenreed terwijl Voertuig B aanwezig was, activeert de logica-engine een voorrangsovertreding. Dat is een berekend feit, geen mening.

We vragen de AI niet "Was het gevaarlijk?" We berekenen het gevaar op basis van fysica en passen de wet toe op basis van logica. De dubbelzinnigheid verdwijnt.

Voor vage termen als "onmiddellijk gevaar" verankeren we ze in de fysica. We definiëren Onmiddellijk_Gevaar als een botsingstijd van minder dan 3,0 seconden, of een afstand die kleiner is dan de remweg bij de huidige snelheid. De graaf berekent de botsingstijd uit de snelheids- en afstandsknooppunten. Als de botsingstijd onder de drempel ligt, wordt het gevaarknooppunt geactiveerd en treedt de bijbehorende regel in werking. Er is geen interpretatie nodig.

Voor de volledige technische uiteenzetting van ons formaliseringsproces en onze architectuur, zie ons onderzoekspaper.

Het contrafeitelijke geval dat causaliteit bewijst

Schuld gaat niet alleen over het overtreden van regels. Het gaat over causaliteit. Een bestuurder kan een verlopen rijbewijs hebben — dat is een overtreding — maar als hij van achteren werd aangereden terwijl hij stilstond voor een rood licht, veroorzaakte het verlopen rijbewijs het ongeval niet.

Dit is waar de meeste AI-systemen tekortschieten. LLM's kunnen niet contrafeitelijk redeneren. Ze kunnen niet vragen: "Zou deze botsing hebben plaatsgevonden als Voertuig A bij het bord was gestopt?" Ze kunnen alleen voorspellen welke zin er in een crashverhaal volgt.

Ons systeem bouwt wat we Causale Kennisgrafen noemen. Om causaliteit te testen, creëren we een contrafeitelijke tak: we wijzigen de snelheid van Voertuig A naar nul bij de stopstreep en draaien de fysicasimulatie vooruit door de temporele laag. Als het botsingsknooppunt verdwijnt in de contrafeitelijke graaf, is de overtreding de directe oorzaak.

Dit is het verschil tussen "hij reed te hard en hij botste" (correlatie) en "het te hard rijden veroorzaakte de botsing" (causaliteit). Bij een kettingbotsing met meerdere voertuigen doet dit er enorm toe. Je kunt causale ketens door de graaf traceren, meten wat we "schuldcentraliteit" noemen — hoe centraal de overtredingen van elke actor zijn voor de botsingsgebeurtenis — en een wiskundig onderbouwde verdeling van vergelijkende schuld produceren. Niet 60/40 omdat het model daar zin in had. 80/20 omdat de topologie het bewijst.

Waarom kun je LLM's niet gewoon nauwkeuriger maken?

Mensen vragen me dit voortdurend. "Fine-tune het model op verkeersrecht. Gebruik betere prompts. Voeg guardrails toe." Ik begrijp de impuls. LLM's zijn eenvoudig in te zetten, en de outputs zien er indrukwekkend uit.

Maar het probleem is geen nauwkeurigheid in de traditionele zin. Het probleem is architectonisch. Een probabilistische tekstgenerator zal nooit deterministisch zijn. Draai het honderd keer op dezelfde invoer, en je krijgt variatie. In een domein waar dezelfde feiten elke keer hetzelfde oordeel moeten opleveren — waar een verschuiving van tien punten in aansprakelijkheid duizenden dollars van eigenaar doet wisselen — is stochasticiteit geen bug die gepatcht moet worden. Het is een fundamentele diskwalificatie.

Onze graaf-engine produceert precies dezelfde aansprakelijkheidsbepaling bij precies dezelfde invoer, elke keer opnieuw. Dat is geen leuke extra. Voor naleving van regelgeving, voor juridische verdedigbaarheid, voor elementaire eerlijkheid — het is de minimale vereiste.

Het andere bezwaar dat ik hoor: "Dit klinkt duur en complex vergeleken met een API-aanroep." Het is complexer om te bouwen. Maar bedenk de kosten van het fout doen. Schadeweglek — meer betalen dan zou moeten door onnauwkeurige aansprakelijkheid — is een enorme kostenpost voor verzekeraars. Een probabilistisch systeem dat 50/50 suggereert omdat de verhalen rommelig zijn, terwijl deterministische logica een duidelijke 100/0 onthult op basis van een specifieke voorrangsovertreding, kost echt geld bij elke afzonderlijke claim.

En dan is er nog de rechtszaak. Probeer een AI-aansprakelijkheidsbeslissing te verdedigen in de rechtbank wanneer het systeem zijn redenering niet kan uitleggen, en het opnieuw uitvoeren een ander antwoord oplevert. Het controlespoor van een kennisgraaf — "Voertuig A overtrad Regel 21802(a) op tijdstip 12:01:30, en contrafeitelijke simulatie bevestigt deze overtreding als directe oorzaak" — is iets fundamenteel anders om voor een rechter neer te leggen.

De sandwich, niet de black box

Ik wil ergens duidelijk over zijn: ik ben niet tegen LLM's. We gebruiken LLM's. Ze zijn buitengewone hulpmiddelen voor het verwerken van ongestructureerde taal, en het zou dwaas zijn dat te negeren.

Waar ik tegen ben is ze als rechters gebruiken.

Onze architectuur is wat we een "sandwich" noemen. Neurale AI aan de buitenkant, symbolische AI in het midden. De eerste neurale laag verzorgt de invoer — OCR op politierapporten, spraak-naar-tekst op getuigenaudio, entiteitsextractie uit rommelige ongestructureerde gegevens. De symbolische middenlaag bouwt de graaf, versmelt gegevens uit meerdere bronnen, draait de deontische logica-engine, voert de causale simulatie uit. De laatste neurale laag vertaalt het gestructureerde aansprakelijkheidsrapport terug naar leesbare natuurlijke taal, strikt verankerd in de feiten van de graaf.

De LLM beslist nooit. Het leest en het schrijft. De graaf redeneert.

Een LLM vragen om een politierapport te lezen en de aansprakelijkheid te beoordelen, is een dichter vragen om fysica te bedrijven. Je krijgt een prachtig antwoord, maar het zal waarschijnlijk fictie zijn.

Dit is wat de sector begint te noemen neuro-symbolische AI — de versmelting van leren en logica. Kennedys IQ, een groot juridisch technologiebedrijf, lanceerde onlangs wat zij beschrijven als de eerste neuro-symbolische AI-oplossing van de verzekeringssector, expliciet om de "black box"-zorg weg te nemen. De richting is duidelijk. De vraag is hoe snel de rest van de sector volgt.

Gerechtigheid is een graaf, geen kans

Ik denk vaker dan me lief is aan die demo die ik zag — degene waarbij de aansprakelijkheid tien punten verschoof tussen runs. Niet omdat het een slecht product was. Het team was getalenteerd. De technologie was indrukwekkend. Maar indrukwekkend is niet hetzelfde als juist. En in het domein van schuld en aansprakelijkheid is "grotendeels juist" fout.

Elke keer dat een AI-systeem schuld toewijst op basis van wie een beter verhaal vertelde, of zijn oordeel verschuift vanwege een temperatuurinstelling, of een wetsartikel aanhaalt dat niet bestaat — absorbeert een echt mens die fout. Ze betalen een hogere premie. Ze verliezen een geschil dat ze hadden moeten winnen. Ze dragen schuld die aan iemand anders toebehoort.

We kunnen het beter doen. Niet door taalmodellen slimmer te maken, maar door te erkennen wat ze zijn en wat ze niet zijn. Ze zijn briljant in taal. Ze zijn verschrikkelijk in gerechtigheid. Gerechtigheid vereist determinisme — dezelfde feiten, hetzelfde oordeel, elke keer. Het vereist controleerbaarheid — laat me precies zien welk bewijs en welk wetsartikel tot deze conclusie leidde. Het vereist het vermogen om een onopgelost conflict vast te houden en te zeggen "ik weet het nog niet" in plaats van een zelfverzekerde fictie te genereren.

Dit zijn geen functies die je aan een taalmodel toevoegt. Het zijn eigenschappen van een geheel ander soort systeem. Een systeem waarin feiten onveranderlijke knooppunten zijn, wetten uitvoerbare logica zijn, en schuld niet wordt gevonden in het sentiment van een verhaal maar in de topologie van wat er werkelijk is gebeurd.

Gerechtigheid is een graaf. Het is tijd dat we haar op die manier gaan bouwen.