Full text · 18,211 chars
GPT 5.6 Luna Is 80% Cheaper. The Real Story Is the Price of Thinking
What matters more to you: a cheaper API model, or a local model you can inspect and control?
OpenAI just cut Luna’s API price by 80%, but the more interesting contest is how much reasoning a model can buy with each token, and whether a local 27B model can close the gap.
OpenAI’s GPT 5.6 Luna has become a much more consequential model overnight. On July 30, OpenAI announced an 80% price reduction for Luna and a 20% reduction for Terra. Luna now costs $0.20 per million input tokens and $1.20 per million output tokens. At launch, the official GPT 5.6 announcement listed Luna at $1 per million input tokens and $6 per million output tokens.
That is the headline. The deeper story is that Luna is not one fixed capability number. It has an inference-time effort curve. The model can answer quickly with no reasoning, or spend far more tokens exploring, checking, and revising before it returns an answer. The quality gain can be substantial, but so can the effective cost and latency.
That creates a useful comparison with Qwen3.6 27B, an open-weight model that can run locally on consumer hardware. The current public data does not show Qwen3.6 27B beating Luna Max. It does show something more interesting: Qwen’s no-reasoning baseline is ahead of Luna’s no-reasoning baseline on the current Artificial Analysis index, while Luna gets much more from its higher reasoning settings.
That gap is the hypothesis I am testing with Hermes Agent and a local Qwen server on my Nvidia RTX 5090. If a future 27B model preserves the Qwen baseline and develops a steeper reasoning curve, it could become far more competitive with proprietary frontier systems than its parameter count suggests. That is a testable possibility, not a result we have earned yet.
The price cut changes the starting point
OpenAI’s current developer documentation lists GPT 5.6 Luna at $0.20 per million input tokens, $0.02 per million cached input tokens, and $1.20 per million output tokens. These are the standard short-context rates. The model supports reasoning tokens, a context window of 1,050,000 tokens, a maximum input of 922,000 tokens, and up to 128,000 output tokens.
The pricing page also lists $0.40 input and $1.80 output for long-context Luna requests, with the higher rate applying to the full request. Batch pricing is $0.10 input and $0.60 output for short-context Luna, while Fast mode and regional data-residency processing have their own pricing rules. The headline $0.20 and $1.20 numbers are therefore a specific standard-tier reference point, not a universal price for every request.
OpenAI’s reasoning guide says GPT 5.6 defaults to medium effort when the effort parameter is omitted, and standard mode is the default reasoning mode. Effort and service tier should be recorded separately in any serious cost comparison.
The important practical change is not only the API invoice. OpenAI says the lower Luna and Terra prices are also reflected in how usage is counted against paid subscriptions in Codex and ChatGPT Work. Subscription prices and quota budgets remain unchanged, but the same amount of work consumes fewer credits. For people using Codex as an agent rather than making isolated chat requests, that changes which tasks are economical to delegate.
Verified pricing
Luna launch price: $1 input and $6 output per million tokens. Current standard price: $0.20 input and $1.20 output. The reduction is 80% for both token types. Terra is now $2 input and $12 output. Sol remains at $5 input and $30 output.
OpenAI presents the cut as a price-performance move, not a capability downgrade. The company’s own launch material claims that Luna and Terra deliver performance competitive with older frontier systems at a fraction of the estimated cost. Those are vendor claims, so I do not use them as the core of this comparison. The more useful question is what happens when we hold the model family constant and look at the public effort settings directly.
Luna’s capability is a curve, not a point
Artificial Analysis publishes separate pages for GPT 5.6 Luna with no reasoning, low, medium, high, xhigh, and max effort. The table below is a snapshot retrieved on July 31, 2026. The Intelligence Index is a composite score across nine evaluations. It is not an IQ score and should not be treated as a complete measure of intelligence.
Artificial Analysis defines the cost column as the cost of running the full Intelligence Index, not the price of one ordinary user request. The output-token column is a weighted average per index task. The speed column is median output speed on the evaluated provider path.
The curve is clear. Luna moves from 26.6 without reasoning to 51.2 at max, a gain of about 24.7 index points. The full-index evaluation cost rises by roughly 13.5 times, and weighted output tokens rise by roughly 8.9 times. The price per token did not change between these rows. The effective cost changed because the model used more tokens and more time.
This is what I mean by the price of thinking. A reasoning setting is not simply a quality toggle. It is a compute allocation. For an easy task, max may be wasteful. For a difficult task, no reasoning may be cheap but unreliable. The economic decision is not “Which model is best?” It is “Which amount of test-time computation produces a verified result at an acceptable cost and delay?”
In the current session, the active runtime is GPT 5.6 Luna through the OpenAI Codex provider. That tells us which model is answering, not which effort setting every response used. The AA table is therefore more useful than pretending that the model name alone describes the entire behavior.
Qwen3.6 27B is a different kind of competitor
Qwen3.6 27B is published as an open-weight model with an Apache 2.0 license on its model repository. The official model card describes a 27B language model with a vision encoder, 64 layers, a native 262,144-token context, and an extension path to roughly 1.01 million tokens. It calls the model a dense 27B model, which is important for local inference: the parameter count is not hiding a much larger mixture-of-experts total.
Qwen also exposes a different reasoning interface from the GPT family. The model thinks by default. The official card says that Qwen3.6 does not officially support the older soft switches /think and /nothink. Instead, direct response mode is enabled through an API parameter such as chat_template_kwargs.enable_thinking: false. Qwen also adds a preserve_thinking option that can retain reasoning context from historical messages, which is particularly relevant to agents working over multiple turns.
Those details sound like implementation trivia until a benchmark quietly sends the wrong field. Then “high reasoning” may be a label in the agent interface rather than native thinking in the model. That is exactly the kind of boundary this experiment is trying to make visible.
These are separate Artificial Analysis pages for Qwen3.6 27B non-reasoning and reasoning variants. The evaluation cost is hosted evaluation accounting, not the electricity or hardware cost of running a local quantized checkpoint.
On Artificial Analysis Coding Index, t the no-reasoning baseline, Qwen scores about 7.3 points above Luna. With reasoning enabled, Qwen reaches 53.7, Luna at medium reaches 50.7 but Luna at max reaches 71.4. Luna’s measured gain from effort is about 32.1 points, while Qwen’s is about 7.1 points in this public comparison.
That does not mean Qwen is simply “worse.” It means the two systems are spending inference-time computation differently, and the public evaluation is not a controlled equal-budget experiment. Qwen consumes many more output tokens even in its non-reasoning row and runs at roughly one-third of Luna’s measured output speed. Provider, prompt, harness, token accounting, and evaluation implementation all matter.
One finding is still useful despite those caveats: the Qwen baseline is not far below Luna. The present gap appears after the models are allowed to think, not before. That makes the slope of the curve a more interesting research question than a static leaderboard position.
The first local smoke test
I am running Qwen3.6 27B locally as Qwen3.6-27B-UD-Q6_K_XL through a llama.cpp OpenAI-compatible server. The local setup uses Q6 quantization on an RTX 5090 with 32GB of VRAM getting 100-110 token per socond. The serving context in this experiment is 131,072 tokens, which is lower than the model card’s native 262,144-token context. This distinction matters: the local runtime is not identical to the official model specification or a hosted provider.
The first Hermes problem was not model quality. It was wire correctness. Hermes’ generic custom provider was emitting fields such as reasoning_effort and a generic think flag. The local Qwen chat template needs the explicit chat_template_kwargs.enable_thinking field. I built a Qwen-specific provider plugin rather than changing the generic provider for every OpenAI-compatible endpoint.
In the isolated test profile, the plugin mapped no reasoning to enable_thinking: false and enabled reasoning to enable_thinking: true. Four focused unit tests passed. Hermes discovery loaded the Qwen-aware provider. Two exact-response probes also returned successfully through Hermes.
Then came a deliberately small direct smoke run: three arithmetic tasks, one sample per condition, temperature 0.0, with a 4K no-thinking cap and an 8K thinking cap.
The two multiplication tasks were correct in both conditions. The difference came from the Chinese remainder theorem task: no thinking returned 67, while the thinking condition returned 486. The thinking run took roughly 374 times longer on that one task and used 7,688 reported output tokens. The API did not expose a provider reasoning_tokens field, so visible reasoning characters were recorded separately and not treated as token accounting.
What this smoke test proves
It proves that the explicit Qwen thinking control reaches the local server and that, in this three-task sample, additional inference budget changed one answer from wrong to correct. It does not prove that Qwen matches Luna, that 8K is optimal, or that the gain generalizes beyond these arithmetic prompts.
Hermes also exposed a separate finalization anomaly. A harder CRT prompt that requested a prose verification returned exit 255 with no final text even though the usage record marked the run completed. Repeating the task with an exact-integer-only instruction returned 486 successfully. I am treating that as a framework finalization issue, not as a Qwen capability result, and it is not counted as a benchmark sample.
Can a future 27B model beat Luna Max?
First, the name needs a small clarification. “Luna Max” is not a separate model family in this comparison. It means GPT 5.6 Luna with the max reasoning setting.
Using the current Artificial Analysis numbers, Qwen3.6 27B’s no-reasoning score is 30.5 and Luna Max is 51.2. Qwen would need roughly 20.8 additional index points just to reach the current Luna Max score. Qwen’s current public reasoning row adds about 6.6 points, leaving a gap of about 14.2 points.
That is a large gap. It would be irresponsible to turn the local smoke test into a prediction that Qwen3.7 or Qwen3.8 at 27B will beat Luna. There is no verified open-weight Qwen3.7 or Qwen3.8 27B checkpoint in the evidence used for this article. A future release may improve the base model, the reasoning policy, the training data, the post-training recipe, the tool interface, or all of them. We do not know the slope in advance.
The hypothesis is still worth testing because a model’s final performance is a stack:
- Base capability from the weights and training.
- Native inference-time reasoning from the model’s thinking policy.
- External scaffolding such as decomposition, tool use, reflection, and branching.
- Verification from tests, compilers, solvers, schemas, or other objective checks.
A better scaffold can produce a better system, but it does not mean the underlying 27B model has become a larger model. It also costs more inference time, more GPU occupancy, and more engineering. The correct comparison is therefore not “27B versus frontier.” It is “local model plus a defined compute and verification budget versus hosted model at a defined effort setting.”
What we can improve today
The most valuable work is not adding a giant Tree-of-Thought engine. It is removing avoidable uncertainty from the current stack.
1. Make the native thinking wire correct
Before measuring reasoning, confirm that the model is actually in reasoning mode. For Qwen3.6, this means sending the documented chat-template parameter, recording the full request body, and testing both enabled and disabled states. A global Hermes setting called high is not proof that Qwen received a native high-effort instruction.
2. Measure a native budget curve before adding agents
The next local run uses a held-out manifest and these conditions: Qwen no-thinking at 4K, thinking at 4K, thinking at 8K, and, if the result is still compute-limited, thinking at 16K and 32K. The current pilot manifest contains 17 exact-answer tasks across arithmetic, number theory, algebra, counting, and discrete logic. It has been prepared, but results are not yet recorded.
3. Separate deterministic control from capability claims
The initial smoke used temperature 0.0 to make the comparison easier to inspect. Qwen’s official model card recommends different sampling settings for general thinking, precise coding, and non-thinking modes. A serious evaluation should include a controlled deterministic track and a recommended-settings track rather than pretending that one temperature is universally optimal.
4. Replace LLM-only criticism with external verification
For arithmetic, use a Python or symbolic check. For code, run tests or a compiler. For JSON, validate against a schema. For files, inspect the artifact directly. An LLM critic can repeat the same error as the generator, and in the local work an LLM verifier rejected a mathematically correct answer that a deterministic check accepted.
5. Add plan, solve, check, and revise only after the baseline
Hermes already has tools, agent loops, memory, compression, delegation, and multi-agent patterns. The first useful scaffold is deliberately small: define acceptance criteria, make a plan, solve the task, run an independent validator, revise if necessary, and report the evidence. This is more informative than immediately launching a large swarm because it lets us measure where the gain comes from.
6. Treat local cost as a real cost
A local Qwen call does not have an API invoice, but it is not free. It consumes electricity, hardware capacity, time, and attention. The local experiment must record wall time, output tokens, GPU memory, concurrency, speculative decoding, and the opportunity cost of occupying the machine. Until those numbers are measured, “cheaper than Luna” is only an intuition.
Bottom line
GPT 5.6 Luna’s 80% price cut matters because it makes a strong hosted model much easier to use as a default worker. But the public effort curve shows why a single model price is not the whole economic story. Luna’s max setting is materially more capable than its no-reasoning setting, and it achieves that gain by spending far more test-time computation.
Qwen3.6 27B is the compelling local counterpoint. It is open-weight, Apache 2.0 licensed, and small enough to run in a quantized form on consumer hardware with a 24/32GB GPU. Its no-reasoning baseline is ahead of Luna’s no-reasoning baseline in the current Artificial Analysis snapshot. Its public reasoning gain is much smaller than Luna’s, and its local smoke test is only a three-task mechanism check.
So the honest conclusion is neither “Qwen already beats Luna” nor “27B models cannot compete.” The evidence says that Luna currently has the stronger measured reasoning curve, while Qwen gives us a promising baseline, local control, and an experiment we can actually inspect from the wire to the validator.
The next frontier may not be a single larger model. It may be a smaller model with a better reasoning policy, a better harness, and a verifier that knows when the answer is actually correct. The only way to find out is to measure the curve before telling the story about where it leads.
Sources and methodology
- OpenAI: Advancing the price-performance frontier with GPT 5.6. Current price cut, July 30, 2026, current API rates, subscription usage treatment, and OpenAI’s efficiency claims.
- OpenAI: GPT 5.6, frontier intelligence that scales with your ambition. Launch pricing, effort settings, model-family description, and published evaluation tables.
- OpenAI developer documentation: GPT 5.6 Luna. Context limits, modalities, supported features, cached-input price, and model-specific token pricing.
- OpenAI API pricing. Standard, long-context, Batch, Fast mode, and regional-processing pricing distinctions.
- OpenAI reasoning models guide. Effort levels, default medium effort for GPT 5.6, standard and pro modes, and adaptive reasoning guidance.
- Qwen3.6-27B model card on Hugging Face. Architecture, license, context length, thinking controls, thinking preservation, deployment notes, sampling guidance, and recommended output lengths.
- Artificial Analysis: Luna non-reasoning, low, medium, high, xhigh, and max. Intelligence Index scores, token use, evaluation cost, and output speed retrieved July 31, 2026.
- Artificial Analysis: Qwen3.6 27B reasoning and Qwen3.6 27B non-reasoning. Public comparison values retrieved July 31, 2026.
- Hermes Agent source repository. Framework context for the local agent experiments.
- Author’s local Hermes and Qwen experiment log, July 31, 2026. The repository and raw runtime logs are private while the benchmark is being stabilized. The local smoke data in this article reports the committed aggregate record, not an external leaderboard result.
Transparency note: This article was written and reasoned by Manolo Remiddi. The Resonant Augmentor (AI) assisted with research, editing and clarity. The image was also AI-generated.