LLM Judges See Presence but Not Absence: Omission Blindness Systematically Breaks AI Medical Note Review
A Counterintuitive Finding
Give an LLM judge the task of reviewing AI-generated medical notes. Deliberately delete a key piece of information — say, a penicillin allergy — and ask the judge: "Is anything wrong with this note?"
You'd expect it to say yes. But across 8 different judge designs and 500 pairs of single-error notes, paired discrimination (the probability a flawed note scores lower than a clean note) was only 0.50–0.63 for omissions — essentially a coin flip. For commissions (incorrect information added), the same judges scored 0.79–0.94.
In other words, LLM judges can reliably detect what a note *added* incorrectly, but almost completely fail to detect what a note *left out*.
This is not a single-model issue. It persisted across 8 judge designs, two model families, prompt optimization, voting, and wording variations. The paper's thesis in one line: LLM Judges Verify Presence, Not Absence.
Why This Is Worse Than You Think
Medical AI scribes (ambient documentation systems) are being deployed at scale. The paper's companion study audited three commercial AI scribes across 565 notes from 142 encounters and found: one in three notes (31.3%) carried verified failures, concentrated in allergy information, medication details, fabricated patient identities, and history-turned-physical-exam errors in telehealth notes.
The dominant failure mode is omission — notes missing information actually established during the visit.
The industry-standard detection method is an 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 wrong.
Paired discrimination of 0.5 means notes with omissions score nearly identically to clean notes. No threshold can separate them — because there is no separable signal.
What They Tried, and Why Nothing Worked
The paper spends substantial effort ruling out "the prompt wasn't written well." The 8 judge designs included:
- Different model families (GPT and Claude series)
- Different phrasings ("find problems" vs. "find missing content" 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 = an apparently normal -3.6 gap)
- CROP: token-level filtering misses counterfactual sensitivity
- Gender Bias: BBQ tests explicit bias but misses dialect-based bias
- Calibrated Enough to Know: models know when they're unpredictable at 90%, but the action gate doesn't consult that judgment
- Code review: LLMs can find "added bugs" — can they find "missing error handling"?
- Documentation review: LLMs can find "wrong descriptions" — can they find "missing sections"?
- Security review: LLMs can find "present vulnerabilities" — can they find "missing safeguards"?
- Compliance review: LLMs can find "violations" — can they find "required steps not performed"?
Result: all of these moved the operating point, but none recovered usable detection. They changed where you sit on the alert-rate vs. precision trade-off curve — but the curve itself didn't move. The omission detection ceiling stayed near chance.
More strikingly: human physicians show no such asymmetry. On the same notes, human reviewers detected omissions and commissions symmetrically. So this isn't "omissions are inherently hard" — it's a specific blind spot of LLM judges.
A Mechanistic Explanation
The paper's explanation is remarkably concise: omissions leave nothing to point at.
A commission is "text that shouldn't be there." The judge can point at that text and say "this contradicts the transcript." Detection is: find evidence in the note, compare against the transcript.
An omission is "text that should be there but isn't." To detect it, the judge must first establish, from the transcript, the expectation that "this information should appear in the note," then verify the expectation fails. But the LLM judge's operating mode is "read the note, find problems" — it has no expectation list of "what should be there," only a perception of "what is there."
One sentence: 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 isn't diagnosing the problem but an unexpectedly simple repair:
Don't ask the judge directly whether the note has problems. First, have a module enumerate all facts established by the transcript; then run a closed presence check on each fact — "does this fact appear in the note?"
This reframing converts one absence-detection task into a set of presence-detection tasks. The judge no longer needs to "reason about what should exist" — only to "perceive whether it does."
Two independent methods converged on this restructuring:
1. Per-fact pipeline: one module lists facts; a second runs a closed check per fact. At a 2.7% false-positive rate, it can pinpoint exactly which fact is missing and how severe it is. 2. GEPA-evolved prompt: a single-call prompt, optimized via evolutionary search, that internally executes the same "list + per-item check" procedure. Detection rate 36.9% (vs. 24.6% for the pipeline, 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 Physicians Stand
In a key experiment, on 10 notes where the pipeline and the best monolithic judge disagreed, a physician author blind-adjudicated. The physician sided with the pipeline on all 10 (p=0.002).
Subsequently, an independent physician blind-rated severity; the two doctors' severity judgments agreed to within one grade on both evaluations.
This is the paper's heaviest blow: it's not "the pipeline is a bit better than the judge" — the pipeline aligns with physician judgment while the judge systematically diverges from it.
Another Instance of the Evaluation Blind-Spot Law
This paper precisely hits a pattern observed repeatedly — the evaluation blind-spot law: evaluation systems systematically miss one class of failures, and the class they miss is exactly the most important one.
Previous cases:
Omission blindness is the purest form yet: the evaluator's detection capability for an entire failure class (omission) equals chance, and that class happens to be the most frequent error type in real deployments (31.3% of notes carried omission-type failures).
A deeper isomorphism: judgment–gate decoupling. The LLM judge "knows" what a note should contain (asked whether a note should include allergy information, it says yes), but that judgment never flows into the "find problems" action gate. The judgment module and 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 so the action module only does what it's good at. This matches the judgment–gate decoupling repair direction exactly: don't train the gate to be smart; redesign the pipeline so the gate doesn't need to be.
Implications for All LLM-as-Judge Systems
The paper's conclusions extend well beyond medical notes. Any scenario using an LLM judge for "completeness checking" faces the same blind spot:
The universal repair template: any "completeness check" LLM judge task should first enumerate "what should exist," then run a closed check on each item. This isn't a prompt trick — it's an architectural restructuring of the task.
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 differ in distribution, so all thresholds need recalibration. 2. The omission detection ceiling is still low. The best method (evolved prompt) reaches only 36.9% detection. "Random" was fixed; "reliable" was not. 3. Cost trade-offs. The pipeline is precise but expensive; the evolved prompt is cheap but noisier. Production deployments must weigh the options.
But the most important open question: is omission blindness an essential limitation of LLMs, or an artifact of the current training paradigm? The paper doesn't answer this. If future models break through on absence reasoning, the fix may become unnecessary. Until then, task restructuring is the only reliable defense.
A Deeper Philosophical Question
The paper's most fascinating element is its mechanistic explanation — omission leaves nothing to point at. This isn't just an LLM problem; it's a human cognition problem too: we notice what is present far more easily than what is absent.
But human physicians learn "systematic checklists" through training — they don't rely on "feeling whether something is wrong" but on "item-by-item confirmation of what should be there." Which is precisely the paper's fix.
In other words: the LLM judge's omission blindness is, at bottom, a failure to learn human checklist thinking. The repair isn't making the LLM smarter — it's giving it an externalized checklist.
This isomorphism reaffirms a conclusion: many "capability deficits" of AI systems are really architecture-level task-assignment 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 + an audit of 565 real notes from 142 encounters