On a ceiling is as much a routing rule as a specification. An output ceiling is easy to read as a limit and hard to read as a routing instruction. Gemini 3.8 Flash model on OrcaRouter caps output at 65,536 tokens against a 1,048,576-token input window, at $0.75 in / $3.75 out / $0.075 cache. For a pipeline that occasionally needs a longer answer, that cap is not a reason to reject the card – it is a condition to route on.
The distinction matters because the alternative – using a card with a 393,216-token ceiling for every request – costs more on the 99% of traffic that never approaches either limit.
The arithmetic of overflow routing
Suppose a document pipeline answers 1,000 requests a day: 950 of them produce 30,000 output tokens, 50 of them produce 75,000.
All on this card: the 50 long requests fail or truncate. Not a cost problem; a correctness problem.
All on a card with a 393,216 ceiling at $0.15 and $0.60: 32.25 million output tokens a day, $19.35.
Routed: 950 requests on this card at $3.75 and 50 on the larger-ceiling card at $0.60. Output cost is $106.88 + $2.25 = $109.13 a day — five and a half times the all-on-DeepSeek figure [OURS].
Which is the wrong way round. The cheap card is cheap because its rate is low, not because its ceiling is small; routing work *to* the expensive-per-token card for a ceiling advantage is a losing trade unless that card buys something else.
The rule that follows: route on the ceiling only when the cheap card cannot finish the job, and never assume the bigger ceiling costs more per token — here it costs six times less.
What this card’s ceiling actually costs
At $3.75 per million output tokens, 65,536 is $0.2458 for a maximum-length answer [OURS]. The same ceiling on a $0.60 card is $0.039.
So the ceiling is not where this card is expensive either. Its cost lives in the input rate: $0.75 per million, five times the cheap tier, and it is the price of a million-token window and five input modalities.
That is the honest framing of the card: you are paying for intake, not output. A pipeline that reads a great deal and writes a little gets value; a pipeline that writes a great deal is overpaying twice — once on the ceiling and once on the rate.

How to implement the overflow rule
Three lines of policy, in order.
Classify by requested output. If the client asks for more than the ceiling, route to a card that can finish it. This needs no model call — it is a comparison against `max_tokens`.
Classify by input size. If the input exceeds the destination card’s window, route elsewhere. Here the window is a million tokens, so this rule fires almost never.
Log the split. Record what fraction of traffic takes each path. If the overflow path is above 5%, the ceiling is wrong for the workload and the card is the wrong purchase; if it is zero, the rule is dead code that costs nothing.
The value of the rule is not the routing itself but the measurement: a pipeline that logs its output lengths knows, after a week, whether a 65,536-token ceiling is generous or a constant source of failures.

What the pipeline should log
The routing rule is only as good as the data behind it, and four fields are enough.
Requested output. The `max_tokens` the client asked for, not the tokens produced. This is what the rule compares against the ceiling.
Produced output. The actual count, and whether `finish_reason` says length. A pipeline that never truncates has a generous ceiling; one that truncates weekly does not.
Input tokens. The other half of the fit check, and the number that prices the card.
Cache hits. At $0.075 per million cached tokens, a repeat read is a tenth of the fresh rate; a pipeline with no hits is paying a premium it did not plan for.
Log those four for a week and the ceiling question answers itself — with a number rather than an opinion about whether 65,536 is “enough”.
The alternative to a second card
Routing is not the only way to handle a ceiling. The other is to change the shape of the request.
Ask for an outline, then sections. A 90,000-token report becomes one 2,000-token outline and eight 11,000-token sections, each inside the ceiling and each cheaper to review. The cost is coherence: sections written separately drift.
Ask for a summary and a link. If the artefact’s purpose is to be read by a person, a 10,000-token executive summary plus the source may serve better than 90,000 tokens nobody reads.
Ask for structured data instead of prose. A table of findings at 5,000 tokens is more useful to a downstream tool than a report at 90,000, and it fits everywhere.
Each of those keeps the work on one card. Routing to a bigger ceiling is the right answer only when the artefact genuinely has to be one document — and that is rarer than the number of requests suggests, because “one report” is often a formatting preference rather than a requirement.
The number to carry away
$0.2458 per maximum answer, $0.75 per million to read. The second number is the one that buys this card’s value; the first is the one that decides whether it fits at all. Two numbers, one decision — and a routing rule that keeps the expensive half where it belongs. The ceiling is a routing input, not a verdict on the card, and most pipelines that reject it have never measured their own output lengths. A ceiling is a number you design around, not a number you argue with, and the design is three lines of client code that most pipelines never write. Route on the ceiling where it binds, and nowhere else, because a routing rule that fires on every request is just a more expensive default.
The takeaway
A 65,536-token output ceiling is a routing instruction, not a defect — but route on it only where it binds, because the card with the bigger ceiling also has the lower rate in this comparison. Pay for intake here, not output: $0.2458 buys a maximum answer, $0.75 per million buys five modalities and a million-token window, and logging your output lengths tells you which of those you are actually buying.
Sourcing note: pricing, cache rate, context, output ceiling, modalities, latency, throughput, error rate and traffic figures are OrcaRouter production telemetry for the seven days ending 2026-11-05 [OURS]. Routing arithmetic uses the stated request counts and average output length against the published rates of two cards on the same gateway. Checked 2026-11-06.



