A driver runs a stop sign and T-bones another car. The at-fault driver submits a 500-word statement full of vivid detail — the weather, the "aggressive" other vehicle, their emotional state. The innocent driver writes 50 words: "I stopped. I checked for traffic. I proceeded. They hit me." An AI reads both statements and sides with the longer one.
This isn't a hypothetical. It's a documented pattern called verbosity bias, and it's one of several reasons large language models are dangerously unsuited for determining who's at fault in a car accident. Stanford researchers have found that state-of-the-art AI models hallucinate legal information — inventing fake statutes, misapplying real ones — at rates between 69% and 88% on specific legal queries. The insurance industry is racing to automate liability decisions with these same models.
We've spent years studying how AI handles fault determination, and our conclusion is blunt: asking a language model to read a police report and assign blame is asking a poet to do physics. The answer might sound beautiful. It will likely be fiction.
The Three Ways AI Misjudges Fault
Most people assume AI fails at legal reasoning because it doesn't "understand" the law well enough. The reality is worse. The failures are structural — baked into how these models work — and they systematically disadvantage certain people.
Verbosity bias is the first problem. When AI models compare two conflicting accounts, they consistently prefer the longer, more detailed one. Research on "LLM-as-a-judge" benchmarks shows that models including GPT-4 award higher confidence scores to verbose responses even when the factual content is equivalent or inferior to shorter ones. In a liability dispute, this means articulate, educated claimants get an automatic advantage over people who are simply direct. The model mistakes word count for evidence.
Sycophancy is the second. Language models are trained to be helpful and agreeable, which means they tend to confirm whatever hypothesis the user brings to the conversation. If an insurance adjuster prompts the system with "Analyze this report to see if the claimant was speeding," the AI is statistically more likely to find evidence of speeding — even if it has to stretch or fabricate that evidence. It's confirmation bias as a service.
Hallucination is the third and most dangerous. Models don't just get facts wrong — they invent them with complete confidence. An AI reading that a car had "severe front-end damage" might conclude the driver was speeding, despite no skid mark measurements or data recorder evidence in the report. Worse, models routinely cite traffic codes that don't exist or misapply real ones. A liability decision based on a hallucinated version of California Vehicle Code § 21802 would expose an insurer to bad-faith litigation.
An AI that favors the articulate over the truthful isn't impartial. It's a system that penalizes honesty.
We explored these failure patterns in depth in our interactive analysis of deterministic liability attribution.
Why "Better Prompts" Won't Fix This
The natural response to these problems is to assume we just need better prompts, better fine-tuning, or better guardrails. We tested that assumption extensively. The problem isn't the prompt — it's the architecture.
Language models work by predicting the next most likely word in a sequence. They're statistical engines, not logical agents. When you ask one to determine fault in a multi-vehicle accident, it needs to do something called abductive reasoning — looking at incomplete, conflicting evidence and inferring the most likely explanation. Research shows that while AI handles deduction (applying a rule to a case) and induction (generalizing from examples) reasonably well, it consistently fails at abduction.
Consider a three-car pileup. Determining the root cause requires counterfactual thinking: "If Vehicle A hadn't changed lanes, would the collision between B and C have happened?" A language model treats this as a text completion exercise. It predicts what sentence should come next in a crash narrative. It cannot simulate the physics, test the hypothesis, or rule out alternatives.
Fault determination must be deterministic — the same facts must produce the same verdict every time. Language models can't guarantee that. Run the same report through the same model twice, and you might get two different answers.
Reconstructing Accidents as Graphs, Not Narratives
Our approach starts from a different premise entirely. Instead of asking AI to read a report and render judgment, we ask it to extract facts — and hand the judgment to a system built for logic.
We call this Knowledge Graph Event Reconstruction. Think of it as building a digital twin of the accident: every vehicle, every traffic sign, every road segment, every witness statement becomes a node in a structured map. The relationships between them — "Vehicle A was approaching Intersection X," "Intersection X was controlled by a stop sign," "Vehicle B was already in the intersection" — become the connections.
Once you have this map, fault becomes a question of structure, not storytelling. Did Vehicle A's path cross a stop sign node? Was Vehicle A's speed property greater than zero at the intersection entry point? If yes, that's a violation — computed from data, not inferred from narrative tone.
The language model still plays a role, but a radically constrained one. It reads the police report and extracts entities: vehicles, drivers, road features, weather conditions, timestamps. It maps them to a strict vocabulary — our ontology covers over 110 entity and relationship types. But the model never decides who's at fault. It's a clerk, not a judge.
This constraint is what neutralizes the bias. Even if the model "wants" to be sycophantic, the rigid schema forces it to output only structured facts. You can't be verbose in a graph.
Turning Traffic Law into Executable Code
The second half of the problem is equally important: how do you apply the law consistently?
Traffic codes aren't stories. They're logical rules with conditions, obligations, and exceptions. California Vehicle Code § 21802, for example, says a driver approaching a stop sign must stop, then yield to vehicles already in the intersection. That's a clear if-then structure: if approaching a stop sign, then you are obligated to stop; if another vehicle is present, then you are obligated to yield; if a police officer directs you otherwise, that overrides the sign.
We translate these rules into what's called Defeasible Deontic Logic — a formal system designed specifically for laws, because it handles both norms (what you must do) and exceptions (what overrides those norms). Every traffic rule becomes executable code with three components: the conditions that trigger it, the obligation or prohibition it creates, and the exceptions that can override it.
When the system evaluates an accident, it runs these formalized rules against the knowledge graph. It checks: did Vehicle A stop? (Was speed zero at the limit line?) Did Vehicle A yield? (Did it enter the intersection while Vehicle B was present?) If the answer to the first question is no and no police override existed, the system flags a violation of the stop obligation. If the answer to the second is no, it flags a failure-to-yield violation.
We don't ask AI "Was it hazardous?" We calculate time-to-collision from speed and distance nodes in the graph, then apply the rule. Physics first, then law. Never sentiment.
The vague terms that trip up language models — "immediate hazard," "safe distance" — get grounded in measurable physics. "Immediate hazard" becomes time-to-collision less than 3.0 seconds, calculated from the graph's speed and distance properties. No interpretation required.
Proving Causation, Not Just Correlation
Identifying a rule violation isn't enough. The critical legal question is: did the violation cause the accident? A driver with an expired license who gets rear-ended while stopped at a red light violated a rule, but that violation didn't cause the crash.
Our system handles this through counterfactual simulation. It creates an alternate version of the knowledge graph — a "what if" branch — where the violation didn't happen. If Vehicle A had actually stopped at the stop sign, would the collision still have occurred? The system modifies Vehicle A's speed to zero at the limit line, runs the trajectories forward using the temporal layer, and checks whether the paths still intersect.
If the collision disappears in the counterfactual graph, the violation is the proximate cause. If it doesn't, the violation is incidental. This is the difference between "he was speeding and he crashed" (correlation) and "the speeding caused the crash" (causation).
For multi-vehicle accidents where fault is shared, the graph's structure provides a mathematical basis for splitting liability. If Driver A's distraction led to a lane departure that caused the collision, while Driver B was also speeding, the system traces each causal chain to the collision node and assigns weight based on the strength of each link. An 80/20 split becomes a computed output, not an adjuster's gut feeling.
For the full technical methodology behind this approach, see our detailed research on legal liability and AI knowledge graphs.
What Makes This Auditable (and Defensible)
Every conclusion traces back to a specific node and a specific rule. "Why is Driver A at fault?" produces a concrete answer: "Because Vehicle A violated Rule 21802(a) (Failure to Stop) at timestamp 12:01:30, and counterfactual simulation confirmed this violation as proximate cause."
The knowledge graph can be visualized — showing the exact chain of events and logic. In litigation or regulatory review, this is vastly more defensible than an opaque AI text block that can't explain its reasoning. It also satisfies emerging regulatory requirements for explainable AI in financial and legal decision-making, requirements that black-box models routinely fail.
Running the analysis 100 times on the same graph produces the exact same liability determination 100 times. That consistency matters for large insurers managing thousands of claims across dozens of adjusters with varying levels of experience and judgment.
What About Edge Cases and Messy Data?
Real-world accident data is contradictory. A police report says "northbound." A witness says "towards the city." One witness says the light was green; another says red.
The knowledge graph handles this through entity resolution and conflict detection. If two sources describe the same vehicle differently — "the red Ford" and "the pickup" — the system uses shared attributes like color, make, and license plate to merge them into a single node. When witnesses genuinely contradict each other about a material fact like a traffic light's state, the graph records both observations as separate nodes linked to the same traffic light and flags the conflict as a disputed fact.
This is a crucial difference from language models. An AI reading conflicting witness statements might quietly resolve the contradiction by favoring the longer or more detailed account — verbosity bias again. The graph engine holds the conflict open, preventing a premature liability decision until additional evidence like dashcam footage can break the tie.
The Real ROI Isn't Speed — It's Accuracy
The insurance industry loses billions annually to what's called "claims leakage" — paying more than warranted because liability was assessed incorrectly. A language model confronted with messy, conflicting narratives might default to a 50/50 split because it can't untangle the accounts. A graph-based system analyzing the same data might reveal a clear 100/0 liability based on a specific, documented right-of-way violation.
The operational benefits compound from there. Simple fender benders are already automated in most large carriers. Complex intersection crashes still go to human adjusters. A deterministic reasoning engine that can reliably adjudicate complex scenarios enables straight-through processing for claims that currently take weeks of human review — without sacrificing accuracy or auditability.
Industry leaders are already moving in this direction. Kennedys IQ recently launched what they describe as the insurance industry's first neuro-symbolic AI solution, specifically to eliminate the "black box" concern that has slowed AI adoption in claims.
What This Means for Your Organization
If you're evaluating AI for claims automation or legal analysis, the question isn't whether to use AI. It's whether to trust a system that confuses eloquence with evidence.
Three things worth considering:
Audit your current AI's consistency. Run the same claim through your model five times. If you get different liability splits, you have a stochastic problem masquerading as automation.
Separate extraction from judgment. Language models are excellent at reading messy documents and pulling out structured facts. They are unreliable judges. Use them for what they're good at.
Demand traceability. If your AI can't show you exactly which rule it applied to which fact to reach its conclusion, it's not ready for production in a regulated industry.
Justice isn't a matter of probability. It's a matter of topology — the precise structure of who did what, where, when, and which rule applies.
The insurance and legal industries have a narrow window to get this right. The models are getting deployed now. The question is whether we build systems that are merely impressive or systems that are actually correct. In liability determination, those are very different things.
We'd welcome hearing how your teams are navigating the tension between AI speed and AI accuracy in claims. What's working? What isn't?