OpenRouter's Image Detail Experiment: Why Lowering Resolution Doesn't Always Save Money

The Intuition That Backfires

It seems obvious: send images at lower resolution to an AI model, use fewer tokens, spend less money. OpenRouter put this intuition to a rigorous test — 1,730 questions across multiple detail levels (low, medium, high, auto) and multiple models. The results challenge the "lower is cheaper" assumption in surprising ways.

The headline finding: GPT-5.5 actually costs MORE at low detail than at high detail for many question types. The model compensates for poor image quality by generating longer, more uncertain outputs — and since output tokens are 6x more expensive than input tokens ($30 vs $5 per million), the verbosity penalty overwhelms the input savings.

How Image Tokens Are Priced

Before diving into the results, it's crucial to understand the token math. For most vision-capable models, images are converted to tokens based on their resolution:

At face value, low detail saves $0.005 per image compared to high. But that's only the input side. The output side tells a completely different story.

OpenRouter's Experiment: The Counterintuitive Results

OpenRouter ran 1,730 vision questions — a mix of OCR tasks, diagram interpretation, UI screenshot analysis, and code screenshot parsing — across all detail levels. They tracked both accuracy and total cost (input + output tokens).

Key findings:

1. GPT-5.5 at low detail costs 15-40% MORE than at high detail for code screenshots and UI analysis. The model outputs 3-5x more tokens when uncertain — hedging, describing possibilities, asking for clarification — because it literally cannot read the image clearly enough to give a concise answer.

2. Claude Opus 4.7 shows the same pattern but less severely (8-20% cost increase at low detail). Claude's vision system appears to handle degraded images with less verbose uncertainty.

3. Medium detail is the sweet spot for most coding tasks. It captures enough resolution for code text and UI elements while using 3x fewer tokens than high detail. Total cost (input + output) is lowest at medium for 62% of test questions.

4. High detail only wins for dense code screenshots — images with 50+ lines of small text, complex diagrams with fine labels, or screenshots with anti-aliased text that becomes unreadable when downscaled.

Why Output Token Costs Dominate

The math that makes low-detail expensive becomes clear when you consider the output token multiplier:

For GPT-5.5: output tokens cost $30/M vs $5/M input — a 6x ratio. For Claude Opus 4.7: $25/M output vs $5/M input — a 5x ratio. Even Claude Sonnet 4.6 has a 5x ratio ($15/$3).

A concrete example from the experiment: parsing a UI screenshot for accessibility issues.

High detail: 1,105 input tokens (image) + 200 tokens (prompt) + 350 output tokens = $0.0065 input + $0.0105 output = $0.017 total

Low detail: 85 input tokens (image) + 200 tokens (prompt) + 1,200 output tokens (verbose, uncertain) = $0.0014 input + $0.036 output = $0.037 total

Low detail costs 2.2x MORE despite using 13x fewer image tokens. The output verbosity penalty completely dominates.

Practical Guidelines for Multimodal Coding Agents

Based on OpenRouter's data, here are cost-optimal settings for common coding agent tasks:

Use medium detail for: UI screenshots for bug reports, component layout analysis, design comparison, wireframe interpretation, general diagram understanding. This covers roughly 60-70% of multimodal coding use cases.

Use high detail for: Code screenshots (especially terminal output or IDE screenshots with small text), architecture diagrams with fine labels, any image where text readability is critical.

Use low detail for: Only when the task is about general image categorization or high-level layout understanding where details don't matter — e.g., "is this a mobile or desktop screenshot?" or "what color scheme is this using?"

Never use low detail for: OCR, code parsing, text extraction, or any task where the model needs to read specific characters from the image.

Monthly Cost Impact for Vision-Heavy Workflows

Consider a frontend team whose AI coding agent processes 50 screenshots per day (design reviews, bug screenshots, UI comparison):

Naive low-detail approach: 50 images x $0.037 x 22 workdays = $40.70/month — with poor accuracy requiring 30% retry rate, true cost ~$53/month

Optimized medium-detail: 50 images x $0.021 x 22 workdays = $23.10/month — with 10% retry rate, true cost ~$25.40/month

All high-detail: 50 images x $0.017 x 22 workdays = $18.70/month — minimal retries, true cost ~$19.50/month

Paradoxically, always using high detail is actually the cheapest option for text-heavy screenshots. The "savings" from low detail are illusory when you account for output verbosity and retry costs.

Recommendations for Agent Developers

If you're building coding agents that process images, implement adaptive detail selection rather than a fixed setting. A simple heuristic: if the task involves reading text from an image, use high detail. If it involves understanding layout or general content, use medium. Reserve low detail for categorization-only tasks.

The broader lesson extends beyond images: optimizing input costs while ignoring output cost multipliers is a common budget mistake. Techniques that make the model "work harder" — shorter prompts, less context, lower image resolution — often backfire because the model compensates with longer, more expensive outputs. The cheapest total cost comes from giving the model clear, complete input so it can respond concisely.