GPT-5.6 Luna API is OpenAI’s economy-tier reasoning model, and for coding it is not the smartest option on the board — it is the smartest value: fast, cheap, and built for the mechanical 80% of software work that never makes a launch demo. Its lane is the unglamorous middle of your day: autocomplete, mechanical refactors, test scaffolding, boilerplate, and whole-repository reads against a 1,000,000-token context window, at a speed and a price no frontier model can touch. Where it genuinely stops is the hard 20% — architecture and deep agentic debugging — and GPT-5.6 Luna carries the live spec sheet and telemetry that mark where that boundary sits.
The trap is measuring a coding model by its hardest trick. Every launch headline and every demo video is about the hero solve — the impossible refactor, the marathon debugging session. But look at what actually flows through a real engineering org and the distribution inverts. The overwhelming majority of tokens are spent writing tests that follow a template, extracting a method, renaming a field, filling in a module skeleton, and re-reading a large repository to answer a question. That work is not intelligence-bound. It is speed-bound, volume-bound and cost-bound — which are precisely the three properties Luna was tuned for.
The coding work Luna is actually built for
Luna is the economy tier of the GPT-5.6 family (Sol is the flagship, Terra the balanced default), released July 9, 2026, per Artificial Analysis’ independent model record, with a 1,000,000-token context window confirmed independently on the same board. That context number is the whole story for repo work: a million tokens is the difference between feeding Luna a directory tree and feeding it a single file. A model you can point at the full codebase and ask “where is this handled, and what touches it?” is a different tool from a model you have to spoon-feed.
The latency profile is what makes it feel right in an interactive loop. Artificial Analysis measures Luna’s median output speed at 156.6 tokens/s — among the fastest on its live board, against 61.8 for Claude Opus 5 and 73.7 for GPT-5.6 Sol (independent) — with a time-to-first-token around 102 ms per AA. Fast first token, fast steady stream: that is what autocomplete, boilerplate generation and rapid iteration loops actually need. And the independent cost figures make the trade explicit: Luna costs $0.05 per Intelligence Index task, the cheapest on the board, where Claude Opus 5 runs $2.34 and Sol $1.23 (AA, independent).
Where the cheap model is genuinely good
The price is the point. OpenAI cut Luna’s rates roughly 80% from the launch price of $1 input / $6 output to $0.20 input / $1.20 output per million tokens — vendor-reported, as reflected in OrcaRouter’s catalog after the cut. That arithmetic changes the economics of running a cheap worker across every repo in the org: the full Artificial Analysis Intelligence Index evaluation costs $172.17 on 130M output tokens (against a tier median of 60M), and Luna’s cost rank is #21 of 172 — cheap in a field where being cheap is a feature.
OrcaRouter’s own seven-day telemetry (our data, checked August 22, 2026) shows where that pricing lands in production: 21,271.6M tokens moved in a week — by far the highest-volume model in the telemetry set — with a p50 time-to-first-token of 1.33 seconds and a p95 of 7.32 seconds. For scale, Claude Opus 5 moved 491.5M tokens in the same window. Luna is the volume workhorse of the catalog, and the deployments confirm it: Replit’s Free Mode now runs on Luna, per our pricing analysis — exactly the kind of high-traffic, cost-sensitive workload an economy tier exists for.
Where it breaks
Be honest about the ceiling. On Artificial Analysis’ live board, checked August 22, 2026 (independent), Luna’s Intelligence Index is 52.32 at max effort — well above the tier median of 17, but behind Claude Opus 5 at 63.05 and GPT-5.6 Sol at 60.93, with Terra at 56.58 in between. The effort ladder runs max (52.32) through xhigh (50.06) to high (46.96), so the published number is the top of a dial you have to deliberately turn. Luna is a strong workhorse and not a frontier reasoner, and the difference shows up exactly where you’d expect it: on tasks where the destination is ambiguous.
The Codex playbook’s field evidence maps that ceiling in detail. Practitioners running Luna Max inside Codex report instruction drift when the brief is a procedure rather than an outcome; a wall-clock slow cold start at max effort that makes interactive debugging feel broken; and a model that Codex’s native subagent system filters out entirely, forcing it into its own thread with manual coordination. Hard architecture, deep agentic debugging, anything exploratory — that is a Sol or Opus 5 job. Trying to save the money there is how a $1.20 session becomes an afternoon of rewriting output by hand.
The split pattern: cheap model for the bulk, strong model for the hard step
The playbook’s evidence converges on one shape, and it is not “Luna does everything” — that version was tried and publicly retracted within a week. The pattern that survived is a three-layer split:
| Layer | Model | Why it fits |
| Plan & architecture | Sol (or Opus 5) | Index 60.93 / 63.05 — owns requirements, decomposition and acceptance |
| Bulk implementation | Luna at max effort | 156.6 tok/s and $0.05 per index task — bounded, mechanical work |
| Review | a fresh Sol / Opus 5 instance | read-only check of the final diff, unclouded by the implementation |
The orchestrator plans and accepts, the cheap model implements, and a fresh strong instance reviews the diff it never saw being written. Each task handed to Luna is fully specified — the finished state, the files in scope, what must not change, the test that proves completion — so “worse” never gets a chance to matter.
The third leg of the pattern is the fallback, so nothing hard-fails. When the cheap layer degrades or a “bounded” task turns out not to be bounded, the request escalates instead of erroring. On OrcaRouter that is automatic failover: a slow or failed Luna call lands on Sol before the user sees a timeout, routing between the cheap and expensive tiers handled by the gateway itself, one OpenAI-compatible key covering both models, and 0% markup so the price you see is the provider price. The split stops being a plugin and becomes ordinary configuration.
The takeaway
Use Luna for the bulk: autocomplete, refactors, test scaffolding, boilerplate, and repository reads — any coding task that is mechanically specifiable and gated on a named test passing. At $0.20 / $1.20 after the cut, at 156.6 tok/s, it is likely the cheapest correct answer in that lane. Do not use it for architecture, ambiguous investigation, or visual work — those belong to Sol or Opus 5, and the published index gap (52.32 vs 60.93 and 63.05) is the size of the hole you would be routing through.
The decision rule that survives contact with real teams is boring: plan with a strong model, implement with the cheap one, review with a fresh strong model, and wire a fallback so a degraded cheap layer escalates rather than fails. Get the handoff contract right — outcome, scope, off-limits, proof of completion — and Luna carries the volume while your invoice stays an order of magnitude lower.
Sourcing note: Luna’s release date, 1M context window, Intelligence Index (max 52.32, effort ladder to high 46.96), median output speed (156.6 tok/s), time-to-first-token, cost per Intelligence Index task ($0.05), full-index evaluation ($172.17 on 130M output tokens) and cost rank (#21 of 172) are independent measurements from Artificial Analysis, checked August 22, 2026. The comparison indexes for Claude Opus 5 (63.05), GPT-5.6 Sol (60.93) and Terra (56.58) are from the same independent board. Pricing is OpenAI’s vendor-reported figures after the cut, as reflected in OrcaRouter’s catalog ($0.20 / $1.20, down from a launch price of $1 / $6). Time-to-first-token (p50 1.33 s / p95 7.32 s), seven-day token volume (21,271.6M for Luna, 491.5M for Claude Opus 5) and the Replit Free Mode deployment are OrcaRouter’s own data, checked August 22, 2026. The Codex failure modes and the split-pattern wiring are described qualitatively in OrcaRouter’s Luna Max-in-Codex playbook.
