The GPT-5.6 Luna API model supports configurable reasoning effort, which means you control how much thinking each request gets. For a model whose identity is cost-efficiency, that setting is not a detail — it is the mechanism that keeps the cheap tier cheap. This GPT-5.6 pricing walkthrough covers the economics it sits within.
Reasoning effort is a dial between two costs: the token cost of thinking, and the cost of a wrong answer. On a cheap model, the dial matters in both directions — you can push it low to keep the routine bulk fast and nearly free, and you can raise it on the requests where a wrong answer is expensive.
What the setting controls
Reasoning effort controls how much computation the model invests before answering. At a low setting, it responds more directly; at a high setting, it reasons longer, which tends to improve correctness on harder problems at the cost of more tokens and more latency. The setting is guidance rather than a fixed script — the model uses it to decide how careful to be. The supported parameters on the model page include reasoning effort, which means the control is available per request rather than fixed per model.
The cost interaction
On Luna, the reasoning-effort setting interacts directly with the $1.20 output price. Thinking is output tokens, and output tokens are the expensive direction. A request at high effort that reasons for a few hundred tokens before answering spends real output tokens on the thinking. On a workload of millions of requests, the difference between a mostly-low-effort policy and a mostly-high-effort policy is the difference between a tiny bill and a meaningful one. The dial is the cost control that works without changing models.
The latency interaction
The setting also interacts with the model’s latency. Lower effort means a faster first token, which matters for the interactive products that chose Luna for its ~1.5-second response. For a chat request where a quick answer is the product, low effort keeps the response snappy. For a request where the answer is worth waiting for, higher effort buys accuracy at the cost of that latency. The dial lets one model span both product needs — the fast routine majority and the careful hard tail.
Setting it per request
The useful pattern is a per-request mapping, not a single global setting. Define the request types your application sends, and assign an effort level to each based on how hard the task is and how expensive a wrong answer would be. A classification of a routine field gets low effort; a complex extraction from an ambiguous document gets high effort; everything between gets a level that matches its stakes. Implement the mapping where routing decisions already live, so the effort travels with the request.
The interplay with tiering
Effort and model tier are two levers on the same problem, and the sensible design uses both. The routine bulk runs on Luna at low-to-medium effort, which is the cheapest possible configuration. The hard tail escalates to a stronger model at higher effort, where the capability justifies the cost. The two levers together span the full difficulty curve: tier selects the capability, effort selects the investment within that tier. On Luna specifically, the effort dial is what keeps the “easy majority” of the family’s pricing advice actually cheap.
Effort and the interactive threshold
The effort setting is what keeps Luna’s latency advantage for the requests that need it. Luna’s ~1.5-second median first token already fits interactive products, and lowering effort on the routine requests keeps the first token closer to the fast end of that range. The opposite direction also matters: a request that raises effort to improve accuracy spends more tokens and waits longer, which is the right trade for a high-stakes answer and the wrong trade for a routine one. The effort policy should therefore mirror the product’s own stakes — the requests where a quick answer is the product get low effort, the requests where a right answer is the product get higher effort. The dial is the mechanism that lets a single model span both needs without changing the model or the endpoint, and it is one of the reasons Luna can serve the whole range of an interactive product rather than only its routine bulk.
The takeaway
GPT-5.6 Luna’s configurable reasoning effort is the per-request control over cost and speed: lower effort keeps the routine bulk fast and nearly free, higher effort spends output tokens for better answers on the requests where a wrong answer is expensive. It interacts with the $1.20 output price and the ~1.5-second latency, so set it per request — low for the easy majority, higher for the hard tail — and use it together with model tiering to span the whole difficulty curve at the lowest blended cost.
Sourcing note: The reasoning-effort parameter and pricing for GPT-5.6 Luna are from the OrcaRouter model page (checked August 2026).
