GPT-5.6 Luna

Why this oneWhat it is actually for

Luna is for volume: classification, extraction, routing, summarisation, first-pass triage — work where you send a lot of requests and each one is individually cheap to get wrong. It keeps the full 1,050,000-token window and the full effort ladder, so a long document does not force you onto a pricier tier. The throughput headroom is the part people miss: at usage tier 5 OpenAI documents 30,000 requests and 180,000,000 tokens per minute for Luna against 15,000 and 40,000,000 for Sol and Terra. If your constraint is requests per second rather than depth per request, that difference decides the tier before the rate card does.

What it isArchitecture, lineage, training

GPT-5.6 Luna is the efficient tier of the closed-weight GPT-5.6 family, generally available from 9 July 2026 alongside gpt-5.6-sol and gpt-5.6-terra. OpenAI's model page rates it "Reasoning: High, Speed: Fast" and describes it as optimised for cost-sensitive workloads and, in the migration guide, for "efficient, high-volume workloads".

OpenAI discloses no architecture for it. No parameter count, no dense-versus-mixture-of-experts statement, no expert or layer counts, no training-corpus description beyond a knowledge cutoff of 16 February 2026. The vendor also never states how Luna is produced — whether it is distilled from Sol, trained separately, or a smaller model in the same run. Since the weights are not published there is no config.json to check either, so architecture claims about this model from any source are unverifiable.

What is documented is that Luna is a full member of the family rather than a cut-down sibling. It carries the same 1,050,000-token context, the same 128,000-token output ceiling, the same text and image input, the same reasoning-token behaviour, and the same GPT-5.6 features: persisted reasoning via reasoning.context defaulting to all_turns, explicit prompt caching with request-placed breakpoints and a 30-minute minimum TTL, max reasoning effort, and reasoning.mode set to pro. The tool list on its model page is identical to Sol's, down to computer use and remote MCP.

The same real-time cyber and biology misuse classifiers run over Luna's output. They can refuse a request or pause generation mid-stream for several seconds — which matters more on a latency-sensitive tier than it does on a flagship one.

At a glanceSee it

On Luna the bill is set by cache routing, a low effort setting, and whether work can go to batch.

CapacityContext, output and what fits

The parametersEvery knob, and what moving it does

On Luna, cost discipline is the whole game and three settings decide it. reasoning.effort left at the medium default is the most common source of a surprise bill on high-volume traffic — drop to low or none and measure. text.verbosity: "low" attacks the expensive side of the rate card, since output costs 6x input in the short-context band. And prompt_cache_key with a stable prefix turns repeat traffic into $0.02-per-million reads.

SamplingShaping the output distribution

Luna is a reasoning model and OpenAI documents nothing about its output distribution. temperature and top_p are listed as body parameters of POST /v1/responses with ranges 0 to 2 and 0 to 1, and the reference repeats the standing advice to change one but not both — but neither appears anywhere in the GPT-5.6 model pages or guides, and whether Luna applies them could not be confirmed from a primary source as of 2026-07-25. The controls OpenAI actually documents work on a different axis: reasoning.effort governs exploration before the answer, text.verbosity governs length after it, and the model is described as reasoning adaptively, spending fewer tokens on simple inputs. For high-volume work the sensible starting point is effort low, verbosity low, a strict JSON Schema, and no sampling parameters — then raise effort only for the request classes your evals show failing.

ReasoningThinking, effort and budgets

Yes. Luna takes the same reasoning.effort ladder as its tier neighbours — none, low, medium, high, xhigh, max — defaulting to medium, and OpenAI's model page rates its reasoning capability "High". That default is the thing to change first on a cheap tier: reasoning tokens bill as output at $1.20 per million, so a workload left at medium can cost several times the same workload at none. The budget is controllable only through the ladder plus max_output_tokens, which counts thinking and visible text together; overrun returns status: incomplete with reason max_output_tokens, sometimes before any visible output. Thinking is never returned verbatim — you get output_tokens_details.reasoning_tokens and an optional reasoning.summary. reasoning.mode: "pro" is supported but pulls against everything this tier is for.

ToolsFunction calling and server tools

Luna's model page lists the same tool surface as the flagship: function calling, structured outputs, streaming, plus hosted web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use and remote MCP. Parallel calls are on by default and parallel_tool_calls: false pins it to zero or one. Strict schemas need additionalProperties: false, every property in required, and nullable unions for optional fields; on Responses an omitted strict is normalised where possible and falls back silently, reported as strict: false on the returned tool. The failure modes that bite on a high-volume tier specifically: a safety refusal comes back as a refusal item that will not parse against your schema, so a naive pipeline throws; leaving a large tool catalogue in every request inflates the cached prefix and the bill, which is what tool_search with defer_loading: true exists to fix; and hosted tools do not exist on Amazon Bedrock at all.

CostPrice, caching, batching, what drives the bill

List price from OpenAI's pricing page, per million tokens. GPT-5.6 bills in two context bands — OpenAI's model page states that prompts with more than 272,000 input tokens are priced at 2x input and 1.5x output for the full request:

Luna is one tenth of Terra on every line, in both bands and every lane; against Sol there is no single ratio any more — one twentieth on input, cached input and cache write, and 6% on output. Within the tier the bill is driven by four things. Reasoning tokens bill as output at $1.20 per million short-context, so reasoning.effort is a price control — the gap between none and medium can dominate everything else. Context band is a step change: over 272,000 input tokens the whole request reprices at 2x input and 1.5x output, which also flattens the output-to-input ratio from 6x to 4.5x. Caching is 90% off on reads but GPT-5.6 charges 1.25x uncached input for writes, and caching only engages at 1,024 tokens of prefix, so short high-volume prompts may never cache at all; track cached_tokens and cache_write_tokens. Batch is a flat 50% off with a 24-hour completion window, and service_tier: flex gives batch rates synchronously in exchange for slower and occasionally unavailable service. OpenAI states nothing either way about publishing a tokenizer for this family, so treat that as unknown; it does document the input-token endpoint, POST /v1/responses/input_tokens, and recommends it over a local tiktoken estimate because local tokenizers cannot account for images, files, tools and schemas.

Where it runsSurfaces and availability

StrengthsWhat it is good at

• The full 1,050,000-token context and 128,000-token output ceiling at $0.20 in and $1.20 out per million — long-document work does not force an upgrade to a pricier tier.
• Documented tier-5 rate limits of 30,000 requests and 180,000,000 tokens per minute, double the requests and 4.5x the tokens of Sol and Terra.
• Cached input at $0.02 per million, the cheapest read rate in the family, which makes a stable system prompt plus prompt_cache_key unusually effective here.
• Same tool list as the flagship on its model page, including code interpreter, computer use and remote MCP — the cheap tier is not feature-stripped.
• Combines with batch or service_tier: flex for another 50% off, taking effective input to $0.10 per million.

LimitsWhere it falls down

• OpenAI rates it "High" reasoning against Sol's "Highest" but publishes no benchmark, so the actual quality gap on your task is unknown until you measure it.
• The reasoning.effort default is medium, not low — a cheap tier with an expensive default, and the most common cause of a surprise bill on high-volume traffic.
• Prompt caching only engages at 1,024 tokens or more of prefix, so short high-frequency prompts get no discount at all while cache writes still cost 1.25x input.
• Fine-tuning is not supported, so you cannot buy back quality by specialising the model on your data.
• Real-time safety classifiers can pause generation mid-stream for several seconds, which is a larger proportional latency hit on a tier chosen for speed.

Against its neighboursHow it compares

Against gpt-5.6-terra, Luna costs one tenth as much per token and, at usage tier 5, is documented at 30,000 requests and 180,000,000 tokens per minute versus Terra's 15,000 and 40,000,000 — so the choice is often about throughput ceilings rather than unit price. The vendor gives you one word of quality difference, "High" versus "Higher", and no benchmark, so the tier decision has to come from your own evals. A common shape that works: run everything on Luna at reasoning.effort: "low" with top_logprobs enabled, and escalate only low-confidence or high-stakes requests to Terra or Sol with the identical body. Against gpt-5.6-sol, Luna is one twentieth the input price and 6% of the output price, with the same context and the same tools — the gap you are paying for is judgment on hard problems, not capacity.

Getting startedThe smallest call that works

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-luna",
    "input": "Classify this ticket as billing, bug, or feature request.",
    "reasoning": { "effort": "low" },
    "text": { "verbosity": "low" }
  }'

Change reasoning.effort first — try none and see whether accuracy moves, since the medium default is the expensive setting on this tier. Then add a strict text.format JSON Schema so downstream parsing is safe, and a stable prompt_cache_key once the prefix exceeds 1,024 tokens. Move offline work to the Batch endpoint for another 50%.

SourcesWhere every claim above came from

• GPT-5.6 Luna Model | OpenAI API
• Models | OpenAI API
• Pricing | OpenAI API
• Create a model response | OpenAI API Reference
• Using GPT-5.6 | OpenAI API
• Reasoning models | OpenAI API
• API deployment checklist | OpenAI API
• Prompt caching | OpenAI API
• Batch API | OpenAI API
• Flex processing | OpenAI API
• Priority processing | OpenAI API
• Function calling | OpenAI API
• Structured model outputs | OpenAI API
• OpenAI models in Amazon Bedrock | OpenAI API
• Foundry Models sold by Azure | Microsoft Learn
• Could not confirm: openai.com's launch post and consumer pricing page returned HTTP 403 and were not read; all prices come from developers.openai.com/api/docs/pricing. No architecture is disclosed and no weights exist to check, so parameter count, dense-versus-MoE and any distillation relationship to Sol are unknown. No vendor benchmark separates Luna from Terra or Sol. Whether temperature and top_p take effect on this model is not stated. Luna's availability on Amazon Bedrock is not enumerated in OpenAI's Bedrock guide. OpenAI states a 16 February 2026 knowledge cutoff while Microsoft Foundry's table says training data to June 2026. The site row this page was built from listed fine-tuning as available "via API" and the context as "~1M"; the model page says fine-tuning is not supported and the window is 1,050,000, and the vendor page wins.

RelatedGo deeper