Introduction
A model scores 80% on a medical image benchmark. Impressive — except researchers at Stanford found frontier models like GPT-5, Gemini 3 Pro, and Claude Opus 4.5 achieve 70–80% of those scores without seeing a single image. In the medical domain, that gap nearly vanishes entirely: text-only performance reached 99% of image-mode accuracy.
This isn't a bug you can patch with a better prompt. It's a structural failure in how multimodal models are trained, evaluated, and deployed — and it has a name: the mirage effect.
Understanding it matters for anyone building on vision-language model (VLM) APIs, deploying AI in safety-critical workflows, or trusting benchmark leaderboards to make architectural decisions.
The Mirage Effect vs. Classic Hallucination
These two failure modes are easy to conflate, but they're distinct.
Classic hallucination is a fabrication within a valid frame — a made-up citation in an otherwise coherent answer. The model is at least operating in the right epistemic space.
The mirage effect is a false epistemic frame from the start. The model behaves as though visual input exists and constructs its entire reasoning on that assumption. Ask Gemini 3 Pro to diagnose a missing chest X-ray and it confidently returns STEMI, melanoma, or carcinoma — not because it's confused about the image, but because no image was ever registered as absent.
The alarming part: mirage-mode performance exceeds guess-mode performance. When explicitly told no image is available, the model becomes conservative. When it silently assumes an image exists, it activates richer associative patterns and scores higher — even while fabricating.
Why benchmarks miss it
Standard benchmarks present questions alongside images. They never test what happens when the image is absent or corrupted. The result is that linguistic cues, question structure, and prior knowledge embedded in training data do the heavy lifting — and nobody notices because the answers are often correct anyway.
A 3-billion parameter text-only model fine-tuned on public chest X-ray data (with all images stripped) outperformed every frontier multimodal model on the same benchmark — and beat radiologists by over 10%. The benchmark wasn't measuring vision. It was measuring how well models pattern-match medical language.
How to Evaluate Vision Models Properly
1. Run modality-ablation tests
Before trusting any VLM benchmark score, run the same evaluation in three modes:
- Full mode: image + question
- Mirage mode: question only, no image, no disclosure
- Guess mode: question only, model explicitly told image is missing
The delta between full-mode and mirage-mode accuracy is your actual visual contribution metric. If that gap is under 20%, the benchmark is testing language, not vision.
2. Apply benchmark cleaning (B-Clean logic)
The Stanford study's B-Clean framework removes any question that any tested model answers correctly without an image. This filters 74–77% of questions from popular benchmarks — which tells you how much of the existing leaderboard is noise.
Implementing this yourself:
- Run your candidate models in mirage mode on your evaluation set
- Discard all questions at least one model answers correctly without visual input
- Evaluate only on the residual set
- Report image-delta accuracy, not raw accuracy
3. Use adversarial image probing
Don't just test with correct images. Test with:
- No image (mirage detection)
- Wrong image (does the model adapt or ignore the mismatch?)
- Corrupted or low-resolution image (does confidence appropriately drop?)
- Out-of-distribution images — e.g., natural photos substituted for medical scans
VLAgeBench research on age estimation shows performance degrades significantly with image quality changes, yet confidence often doesn't track degradation. Models that don't signal uncertainty under poor input conditions are dangerous in production.
4. Add grounding verification layers
GUI grounding research demonstrates that models can be explicitly trained and evaluated on whether they're actually using visual coordinates versus guessing layout from context. Apply the same principle to your use case: does the model's answer change when you swap regions of the image? If not, it isn't grounding.
Practical implementations:
- Contrastive image pairs: same question, visually different images with different correct answers
- Attention or attribution probing: check whether visual tokens are actually influencing generation
- Self-consistency across image variations: small crops or rotations shouldn't flip confident answers on stable visual features
Mitigations for Production Systems
Once you've measured the problem, here's how to reduce risk:
RAG for vision: Ground responses in retrieved, verified visual context where possible. Don't let the model reconstruct visual facts from training priors alone.
Structured outputs: Constrain model outputs to predefined schemas. If a field requires bounding box coordinates or a classification from a fixed set, fabrication becomes structurally harder.
Confidence signaling: Prompt models to report uncertainty explicitly. Treat low-confidence responses as triggers for human review or rejection — not just cosmetic annotations. Build pipelines where "I cannot determine this from the provided image" is a valid, routed output.
Modality confirmation checks: In API-based or agentic workflows, verify the image actually arrived before accepting a visual response. Log whether image tokens were passed; don't assume success from the model's confident tone.
Human-in-the-loop escalation: In medical, legal, or safety contexts, route any response generated under degraded visual input to human review. Automation is appropriate for high-confidence, visually-grounded cases only.
What This Means
- For developers: Benchmark scores on multimodal models are largely unreliable proxies for actual visual capability. Implement your own modality-ablation tests before committing to a model for image-dependent workflows.
- For founders: If your product's value proposition depends on a model "seeing" something — medical images, documents, user interfaces — your risk model needs to account for silent image-processing failures, not just hallucinated text.
- For AI teams: Evaluation methodology needs to change. Report image-delta accuracy as a standard metric. Build private or dynamically updated visual benchmarks that can't be absorbed into pretraining corpora.
- For the field broadly: Better language capabilities make the mirage effect worse, not better. As models become stronger reasoners, their linguistic priors increasingly substitute for visual processing. Reliability in multimodal AI requires separate, rigorous measurement of each modality — not aggregate scores that collapse the distinction.
The core issue isn't that these models can't process images. It's that current evaluation infrastructure can't tell whether they did.
