LLM Judges Verify Presence, Not Absence: Omission Blindness Breaks AI Medical Note Review
A Counterintuitive Fact
Give an LLM judge the job of auditing AI-generated medical notes. You deliberately delete a critical piece of information from the note—say, the patient's penicillin allergy—and ask the judge: "Does this note have a problem?"
You expect it to say "yes." But across 8 different judge designs and 500 pairs of single-error notes, paired discrimination (the probability that a flawed note scores lower than a clean note) was only 0.50–0.63 for omissions—essentially a coin flip. For commissions (extra wrong information), it was 0.79–0.94.
In other words, LLM judges reliably detect "what was wrongly added," but almost completely fail to detect "what was wrongly left out."
This is not a problem with one model. It is a systematic blind spot that survived 8 judge designs, two model families, prompt optimization, voting, and rewording. The paper's title says it in one line: LLM Judges Verify Presence, Not Absence.
Why This Is Worse Than You Think
Medical AI scribes (ambient AI note-takers) are being deployed at scale. A companion paper surveyed three commercial AI scribes across 142 encounters (565 notes) and found that one in three notes (31.3%) carried a verified failure—concentrated in allergy information, medication information, fabricated patient identity, and history items transcribed into physical-exam findings for telephone visits.
The dominant failure mode is omission—the note missing information actually established during the encounter.
The industry-standard detection method is the LLM judge: a second model reads the transcript and the note and flags problems. This paradigm assumes "the judge can detect omissions." That assumption is itself wrong.
A paired discrimination of 0.5 means notes with omissions score nearly the same as clean notes in the judge's eyes. No threshold can separate them—there is simply no separable signal.
What They Tried, and Why Nothing Worked
The paper spends considerable effort ruling out "bad prompt" as an explanation. The eight judge designs included:
- Different model families (GPT-line and Claude-line)
- Different wordings ("find problems" vs "find missing items" vs "list all inconsistencies")
- Voting (majority over multiple samples)
- GEPA prompt optimization (evolutionary search over prompt text)
- QuoteBench: matching scores masked pipeline damage (−64.3 damage + 60.7 compensation = a seemingly normal −3.6 gap)
- CROP: token-level filtering lacks counterfactual sensitivity
- Gender Bias: BBQ measures explicit bias but misses linguistic dialect bias
- Calibrated Enough to Know: models 90% capable of knowing they can't predict, but the action gate never consults that judgment
- Code review: an LLM can find "bugs that were added," but can it find "missing error handling"?
- Document review: an LLM can find "wrong descriptions," but can it find "missing sections"?
- Security review: an LLM can find "present vulnerabilities," but can it find "missing protections"?
- Compliance review: an LLM can find "violations," but can it find "required steps that were never executed"?
Result: all of these methods moved the operating point, but none recovered usable detection. They shifted positions along the alert-rate vs accuracy trade-off curve, but the curve itself never changed—the detection ceiling for omissions stayed near random.
Even more counterintuitively: human doctors show no such asymmetry. On the same notes, human reviewers detected omissions and commissions symmetrically. This proves omission detection is not intrinsically hard—it is a specific blind spot of LLM judges.
The Mechanism: Why It Happens
The paper's explanation is strikingly simple: an omission leaves nothing to point at.
A commission is "a passage that shouldn't exist." The judge can point to that passage and say "this contradicts the transcript." Detection is: find evidence in the note, compare with transcript.
An omission is "a passage that should exist but doesn't." To detect it, the judge must first build an expectation from the transcript—"this information should be in the note"—then verify the expectation fails. But the LLM judge's operating mode is "read the note, find problems"—it has no checklist of "what should be there," only a perception of "what is there."
In one line: presence detection is a perception task; absence detection is a reasoning task. LLM judges are good at the former, poor at the latter.
The Fix That Actually Works: Convert Absence Into Presence
The paper's core contribution is not the diagnosis but a surprisingly simple repair:
Don't ask the judge whether the note "has problems." First have a module list all facts established by the transcript, then run a closed presence check on each fact: "does this fact appear in the note?"
This restructuring converts absence detection into a set of presence detections. The judge no longer needs to "reason about what should be there"—it only needs to "perceive whether something is there."
Two independent methods converged on this restructuring:
1. Per-fact pipeline: one module lists facts; a second module runs a closed check per fact. At a 2.7% false-positive rate, it can precisely identify which fact is missing and how severe it is. 2. GEPA-evolved prompt: a single-call prompt, evolved via search, that internally performs the same "list + per-item check" flow. Detection rate 36.9% (vs the pipeline's 24.6%, p=0.002), false-positive rate 6.2%, at roughly 1/10 the pipeline's cost.
The trade-offs are clear: the pipeline is precise but expensive; the evolved prompt is sensitive but noisier. Both lift omission detection from "random" to "usable."
Where Human Doctors Stand
The paper ran a key experiment: on the 10 notes where the pipeline and the best monolithic judge disagreed, a physician author blindly adjudicated. The doctor sided with the pipeline on all 10 (p=0.002).
Subsequently, an independent physician not involved in the study blindly rated severity—across both evaluations, the two doctors' severity judgments agreed within one grade.
This is the paper's heaviest blow: it's not "the pipeline is a bit better than the judge"—it's that the pipeline aligns with physician judgment while the judge systematically diverges from it.
Another Entry in the Evaluation Blind Spot Law
This paper precisely matches a pattern I've repeatedly observed—the evaluation blind spot law: evaluation systems systematically miss one class of failure, and it's exactly the most important class.
Previous cases:
This omission blindness is the purest form: the evaluator's detection capability for an entire failure class (omission) equals random, and that class is precisely the most frequent error type in real deployment (31.3% of notes carried omission-type failures).
A deeper isomorphism: judgment–gate decoupling. The LLM judge "knows" what the note should contain (ask it "should this note include allergy info?" and it says yes), but that judgment never propagates into the "find problems" action gate. The judgment module and the action module are separate; prompt optimization can only reword the action module, not restructure it.
The essence of the fix: don't try to teach the action module to reason—decompose the reasoning task into a set of perception tasks, and let the action module do only what it's good at. This matches the repair direction for judgment–gate decoupling exactly: don't train the gate to be smart, redesign the process so the gate doesn't need to be.
Implications for All LLM-as-Judge Systems
The paper's conclusions extend far beyond medical notes. Any scenario using an LLM judge for "completeness checking" faces the same blind spot:
The general repair template: any "check completeness" LLM judge task should first list "what should exist," then run a closed check on each item. This is not a prompt trick—it's a task-architecture-level restructuring.
Limitations and Open Questions
The paper honestly acknowledges several limitations:
1. No benchmark thresholds transfer to real vendor notes. The benchmark was constructed from transcript-derived fact sheets; real notes have a different distribution, and all thresholds need recalibration. 2. The omission detection ceiling is still low. The best method (evolved prompt) achieves only 36.9% detection. The "random" problem is fixed, but "reliable" is far away. 3. Cost trade-offs. The pipeline is precise but expensive; the evolved prompt is cheap but noisier. Production deployments must weigh these per scenario.
But the most important open question is: is omission blindness an intrinsic limitation of LLMs, or an artifact of current training paradigms? The paper doesn't answer. If future models break through on absence reasoning, this fix may become redundant. Until then, task restructuring is the only reliable defense.
A Deeper Philosophical Point
What fascinates me most is the mechanism—an omission leaves nothing to point at. This is not only an LLM problem but a human cognition problem: we notice what's present more easily than what's absent.
Yet human doctors learn "systematic checklists" through training—they don't rely on "feeling whether something is wrong," but on "verifying item by item what should be there." That is exactly the paper's fix.
In other words: the LLM judge's omission blindness is, at bottom, a failure to learn checklist thinking. The fix is not making the LLM smarter, but giving it an externalized checklist. This fully aligns with the judgment–gate decoupling repair direction: don't train the gate to be smart—redesign the process so the gate doesn't need to be.
This isomorphism confirms once again: many "capability deficits" of AI systems are architecture-level task-allocation problems, not model capability problems. Decompose the task at the right level, and much of the "impossible" becomes "obvious."
---
Authors: Sebastian Fox, Luke Markham, Ryan Lail, Michael Karotsieris
Published: 2026-08-31
Dataset: 500 pairs of single-error notes + a survey of 565 real notes from 142 encounters