GPT-5.5 Scored 13.8 Points Worse On The “Cheap” Setting. It Also Cost 13% More.

The dial nobody audits

Every multimodal API call has a parameter most engineers set once and never revisit: image detail. OpenAI, Google, and every provider that routes through them exposes a “low” mode that downsamples an input image to a small, fixed thumbnail before the model ever sees it, cutting the image-token cost of the request. It is usually the first thing a team flips when a vision-heavy product's bill gets too large, because it looks like free money: fewer tokens in, lower cost out, and the accuracy hit is assumed to be a rounding error.

On July 2026, OpenRouter actually tested that assumption, at production scale, across real models people ship with. The dataset was MMMU-Pro Vision: 1,730 ten-option questions, 76% requiring text or OCR reading, 19% screenshots, and a dedicated sample of chart and diagram questions. Every one of the 5 models below ran the full set twice, once with detail: "auto" and once with detail: "low". Low detail standardizes every image down to 512×512 before encoding, regardless of the original resolution; one test image in the set was 2,239×1,279 in its native form.

Every model got worse. No exceptions.

Start with the part that should surprise nobody, but that almost nobody has actually measured on their own traffic: accuracy fell for every single model at low detail. Not most. All 5.

GPT-4.1 took the worst hit of the group: 57.5% accurate at auto detail, 40.1% at low, a 17.4-point collapse. GPT-5.5, OpenAI's current top-tier reasoning model, still lost 13.8 points, from 79.0% down to 65.2%. Even Gemini 3.5 Flash, a model built from the ground up to be the cheap option, still lost 2.2 points it never had to lose. There is no model in this set where flipping to “low” was accuracy-neutral.

The number that shouldn't be possible

The accuracy hit alone would be a reasonable trade if the cost savings were real and proportionate. For most of these models, they were, GPT-5.4-mini dropped 43% in cost at low detail, GPT-4.1 dropped 35%. But GPT-5.5, the flagship model most teams would actually route production traffic to, did the opposite. Low detail cost more than auto detail.

That is not noise. It is a 13% cost increase, on the setting whose entire purpose is cutting cost, paired with a 13.8-point accuracy drop. Anyone who flipped GPT-5.5 to “low” detail to save money on a vision product bought a strictly worse outcome on both axes at once, and the invoice would not have flagged it, because per-token image pricing genuinely did go down. The reasoning-token line is where the money came back.

Why: the model doesn't know it's being cheaped out

The mechanism is straightforward once you look at the token breakdown instead of the headline price. A vision-reasoning model does not treat a blurry image as “less data to think about.” It treats it as a harder problem, and reasoning models respond to harder problems by generating more reasoning tokens. GPT-5.5's reasoning token count jumps from 730 per request at auto detail to 1,180 at low detail, a 1.6x increase; completion tokens climb 39%, from 351 to 489.

# image_detail_cost.py — why "low" detail backfired on GPT-5.5
AUTO = {"reasoning_tokens": 730, "completion_tokens": 351, "cost_cents": 4.5, "accuracy": 79.0}
LOW  = {"reasoning_tokens": 1180, "completion_tokens": 489, "cost_cents": 5.1, "accuracy": 65.2}

reasoning_multiplier = LOW["reasoning_tokens"] / AUTO["reasoning_tokens"]
completion_delta_pct = (LOW["completion_tokens"] / AUTO["completion_tokens"] - 1) * 100
cost_delta_pct = (LOW["cost_cents"] / AUTO["cost_cents"] - 1) * 100
accuracy_delta = LOW["accuracy"] - AUTO["accuracy"]

print(f"Reasoning tokens: {reasoning_multiplier:.1f}x")
print(f"Completion tokens: +{completion_delta_pct:.0f}%")
print(f"Cost: {cost_delta_pct:+.0f}%")
print(f"Accuracy: {accuracy_delta:+.1f} pts")

$ python image_detail_cost.py
Reasoning tokens: 1.6x
Completion tokens: +39%
Cost: +13%
Accuracy: -13.8 pts

⚠ FIX: the image-token savings from downsampling to 512x512 were smaller
  than the reasoning-token cost of compensating for the lost resolution.
  "Low detail" cut the wrong tokens.

Fewer image tokens went in. More reasoning tokens came out, because the model worked harder to make up for what it could no longer clearly see, and you are billed for the tokens it generates, not the ones it doesn't. On a reasoning-heavy flagship model, that compensation effect outweighs the up-front savings entirely.

The one place it hurts most: exactly the content you send AI models

The accuracy damage was not evenly distributed across question types. It concentrated hardest on charts and diagrams, which is the single most common reason a business sends an image to an AI model in the first place: a dashboard screenshot, a benchmark comparison, a financial chart. On Gemini 3.1 Pro, chart-reading accuracy fell from 91.7% at auto detail to 78.6%at low detail, a 13.1 point drop, on the exact task “send AI a chart” describes.

A 512×512 downsample destroys exactly the fine detail a chart depends on: small axis labels, close gridlines, thin data series. Text-heavy OCR questions took a hit too, but nothing as steep as this. If your product's vision use case is “read this screenshot,” low detail is the worst place to cut.

The lever that actually works

OpenRouter also tested a second cost lever on the same model, same questions: reasoning_effort: "low" instead of the default, leaving image detail untouched at auto. Same stated goal, cut cost, a completely different result.

Cutting reasoning effort dropped GPT-5.5's cost per question from 5.1¢ to 1.7¢, a 67% reduction, while accuracy slipped just 1.3 points, from 65.2% to 63.9%. Two settings, both labeled as ways to spend less, produced outcomes on opposite ends of the spectrum. The dial that sounds like it touches “how much the model sees” quietly touches how hard it has to work to compensate. The dial that sounds like it touches “how hard the model thinks” is the one that actually maps cleanly to cost.

The penalty isn't even consistent across models

Widen back out to all 5 models and the failure mode splits into two distinct patterns. GPT-5.4-mini, GPT-4.1, and Gemini 3.1 Pro did save real money at low detail, 43%, 35%, and 14% respectively, they just paid for it with an accuracy loss nobody priced in. GPT-5.5 and Gemini 3.5 Flash lost accuracy and paid more. Both failure modes were sitting behind the same toggle.

What this means for anyone routing AI calls at scale

The uncomfortable finding here is not “low detail is bad,” it's that a setting's name is not a reliable guide to its effect on your bill. “Low” sounds cheap. On a reasoning-heavy flagship model it was measurably not cheap, and the only way to know that in advance is to run the same before/after test OpenRouter ran: hold the model fixed, flip one setting, measure cost and accuracy together, not cost alone. Most teams never do this, because the pricing page makes the direction of the effect look obvious. It isn't.

This is also a routing problem, not just a settings problem. The right answer to “which detail level should this request use” depends on the model behind the call, since GPT-5.5 and Gemini 3.1 Pro responded to the identical toggle in opposite cost directions. A static default applied across every model in a fleet will be wrong for at least some of them, silently.

If you want to build your own before/after audit

The image_detail_cost.py snippet above works for a single model, single setting comparison you already have numbers for. A live version needs to run the actual A/B across every model in your routing pool, on a recurring schedule, since provider pricing and model behavior both drift. That is a natural fit for a mhermesagent, it runs on its own isolated VM with shell access and scheduling, so it can fire a small held-out eval set through each candidate model and detail/reasoning-effort combination on a cron job, and flag the moment a “cost saving” setting stops actually saving cost on a given model.

And once you know which lever genuinely cuts cost per model, MegaBrain gives you one API across 500+ models with transparent, at-cost pricing, so routing a vision-heavy workload to the model and settings combination that actually clears your cost and accuracy bar is a config change, not a re-integration.

Sign up at getmegabrain.com to route at cost, or spin up a mhermes agent to keep this exact audit running the next time a provider quietly changes what “low” actually costs.