GPT-5.6 Luna API is OpenAI’s economy-tier reasoning model, and how much it can write in one response is governed by a per-request max-output-tokens ceiling rather than one fixed published number. The trade-off to internalise is simple: output is the expensive direction of its budget — $1.20 per million output tokens against $0.20 for input after the price cut, per OrcaRouter’s catalog — yet its per-task cost is the lowest on the independent board. The current rate card and spec sheet live on GPT-5.6 Luna; here is the plain version of the output-cap question on its own.
When you ask a model how long its answer can be, you are really asking about a budget with two sides. The input side of Luna is famously large; the output side is the one that decides whether a 10,000-word report, a full file of code, or a long agent run finishes in one call or gets chopped into retries. Most of the interesting cost and quality behaviour of this model sits on that second side.
What “max output tokens” actually controls
The max-output-tokens setting caps how many tokens a single model response may contain. It is applied per request through the API rather than advertised as one fixed number for the model — check the API docs; our reference is the official limit. Treat any single figure floating around as the default for a given call, not as a law of the model.
It is also independent of the input window. Luna carries a 1,000,000-token context window (Artificial Analysis’ spec), which describes how much the model can read; the output ceiling describes how much it can write back. The two budgets do not share: a model can read a million tokens and still be stopped at the output line. That separation is where integration mistakes happen, because teams size the prompt and forget to size the response.
Output is the expensive direction
After OpenAI’s price cut, Luna lists at $0.20 per million input tokens and $1.20 per million output tokens — about 80% below its launch price of $1 and $6, as tracked on OrcaRouter’s model page. Output costs six times input, and that ratio is the real story: every token the model emits is six times as expensive as one it reads. A 5,000-token answer costs about half a cent of output spend at the post-cut rate, while the same content read back as input costs a tenth of that — which is why the direction you generate in matters more than the volume you feed in.
Still cheap, and this is where independent evidence matters. Artificial Analysis puts Luna’s cost at $0.05 per Intelligence Index task, the cheapest figure on its board — against $1.23 for GPT-5.6 Sol and $2.34 for Claude Opus 5. Completing the full index cost roughly $172.17 on 130 million output tokens (the tier median is 60 million), ranking Luna #21 of 172 for cost.
| Model | Input after cut | Output after cut | Median output speed |
| GPT-5.6 Sol | $5 / 1M | $30 / 1M | 73.7 tok/s |
| GPT-5.6 Terra | $2 / 1M | $12 / 1M | — |
| GPT-5.6 Luna | $0.20 / 1M | $1.20 / 1M | 156.6 tok/s |
Prices after the cut are from OrcaRouter’s catalog; speeds are Artificial Analysis measurements.
Where the ceiling bites: long-form, codegen and agents
Long-form generation. Luna is the family’s volume workhorse — OrcaRouter’s seven-day telemetry shows 21,271.6 million tokens of traffic, by far the highest in the set — and much of that is long-form work: documentation, translation, summarisation pipelines where one complete response beats stitching many together. Artificial Analysis also flags Luna as multimodal with text and image input, which pushes long-form work toward visual specs and design reviews. For all of it, the output ceiling decides whether the job is a single call or several.
Code generation. A response that can hold a whole file — imports, implementation, tests — survives as a unit. When the ceiling cuts a codegen response short, the model stops mid-function, and the cost of repairing a truncated file is usually larger than the token cost that would have avoided it. Code agents in particular care about this: a finished patch is worth more than twice a half patch, because the second half has to be regenerated anyway.
Agents. Agent loops accumulate output: tool calls, intermediate reasoning, draft answers that later become input. Every round trip writes more output tokens, and because input costs a sixth of output, the cheapest pattern is to write once and reuse the result rather than rewrite it. A long agent run is not one long answer; it is hundreds of short ones, and each of those is subject to the same ceiling.
How reasoning burns output budget
Reasoning models spend part of the response budget before they answer. The thinking tokens Luna generates internally come out of the same output ceiling as the final text, which is why the effort dial matters. Artificial Analysis measures Luna’s Intelligence Index at 52.32 on its max-effort config — well above the tier median of 17 — dropping to 50.06 at xhigh and 46.96 at high. The score you buy with effort is paid in output tokens: crank the dial and a question that looked cheap can quietly consume a large share of the ceiling.
The practical rule is to set effort to what the task deserves. Short factual answers do not need max effort; long synthesis tasks benefit from it, but only if the output budget actually fits the answer. The ceiling and the effort dial interact — max effort plus a big ask is exactly how you run out of room mid-answer, not because the model is broken but because the response budget is spent on thinking before writing.
Practical patterns: chunking and streaming
Stream what you can. Luna’s median output speed is 156.6 tokens per second (Artificial Analysis), among the fastest on its board — versus 61.8 for Claude Opus 5 and 73.7 for GPT-5.6 Sol — and its first token arrives at about 102 ms (Artificial Analysis), with OrcaRouter’s own seven-day telemetry showing a p50 first token of 1.33 seconds. With streaming, the first text appears while the rest is still generating, which turns a long answer into a reading experience instead of a wait, and lets you cut a response early when it is clearly heading the wrong way.
Chunk deliberately. For genuinely huge outputs, split the job into stages and feed each stage’s output back in as input on the next call. At $0.20 per million input tokens, the round-trip is the cheap direction. This mirrors context engineering: instead of shrinking the prompt to fit the window, you size the response to fit the ceiling, and let the model’s own earlier output become the next prompt.
Don’t request max by default. Set the output ceiling to what the task needs rather than always asking for the limit, and keep a fallback for long requests — long outputs are where timeouts concentrate, so running through a router like OrcaRouter, which passes the vendor’s list price through at 0% markup and carries alternatives behind the same key, means a stalled request degrades to a retry rather than an incident.
The takeaway
The max-output-token setting is the quiet half of Luna’s budget. The input side gets the headlines with a million-token window, but the output ceiling is where long-form, codegen and agent workloads actually live or die — and at six times the per-token price of input, it is where the cost is too. The model stays cheap because its per-task cost is the lowest on the independent board, so the winning pattern is simple: stream long answers, chunk the very long ones, set effort to the task, and never let a truncated response become the bottleneck. Budget the output side and the long answers come almost free.
Sourcing note: context window, Intelligence Index scores, effort-ladder figures, output speed, first-token latency and cost-per-task figures are Artificial Analysis measurements, checked August 22, 2026. Post-cut pricing and the size of the price cut are OrcaRouter’s catalog and blog data. First-token latency and traffic figures are OrcaRouter’s own seven-day production telemetry. The max-output-token ceiling is a per-request API setting; see the official API docs for the current value.
