GPT-5.6 Fast Mode: The Real Cost of 2.5× Speed

OpenAI cut GPT‑5.6 Luna’s API price by 80% and Terra’s by 20%, while offering Sol at up to 2.5× Standard processing speed for twice the token price. The headline is compelling. The routing decision requires more care.

OpenAI’s latest GPT‑5.6 update changes both ends of the price-performance curve. Luna is dramatically cheaper. Terra gets a meaningful reduction. At the frontier end, GPT‑5.6 Sol can now use API Fast mode, which OpenAI says delivers up to 2.5× Standard processing speed at 2× the price, without changing the model’s intelligence.

That last claim deserves precise interpretation. If a Sol request really receives the maximum stated speedup, the affected processing time falls to 40% of Standard—a reduction of as much as 60%. Because the request costs twice as much, the theoretical speed delivered per dollar improves by 25%.

But those are upper-bound calculations. OpenAI has not published enough detail in the announcement to turn “2.5× speed” into a universal end-to-end latency promise. Tool calls, network delays, prompt processing, time to first token and serial agent steps can all reduce the benefit a user actually feels.

The short version

• GPT‑5.6 Luna is now exceptionally cheap: $0.20 per million input tokens and $1.20 per million output tokens, down 80%.
• Terra is 20% cheaper: $2 per million input tokens and $12 per million output tokens.
• Sol Standard remains $5 input and $30 output per million tokens.
• Sol API Fast mode costs 2× Standard and promises up to 2.5× Standard processing speed, with no claimed intelligence reduction.
• At the maximum claim, Fast mode implies up to 60% less affected processing time and 25% more speed per dollar. It does not make a fixed-token request cheaper.
• API Fast mode and Codex /fast are not the same commercial product. Codex documentation says 1.5× speed and 2.5× ChatGPT-credit consumption for GPT‑5.6.
• Existing API requests using service_tier: "priority" should continue working. OpenAI says those requests will automatically receive Fast mode.
• The sensible deployment pattern is routing: use Luna for inexpensive volume, Terra for everyday agent work, Sol Standard for difficult work, and Sol Fast only when latency has measurable value.

What OpenAI changed

OpenAI launched the three-tier GPT‑5.6 family on July 9. Sol is the frontier model; Terra occupies the balanced middle; Luna is built for high-volume, cost-sensitive work. Three weeks later, OpenAI passed further serving-efficiency gains into prices for the two smaller tiers and speed for Sol.

The current model documentation also carries two pricing details that matter in production. Cache writes cost 1.25× the uncached input rate. Requests containing more than 272,000 input tokens are charged at 2× input and 1.5× output rates for the entire request.

Those rules can matter more than a headline token price in long-running agents. A workflow that preserves stable prefixes and generates restrained outputs may cost far less than one that repeatedly reconstructs large contexts, even when both use the same model.

How much faster is GPT‑5.6 Fast mode?

OpenAI’s exact public claim is “up to 2.5× faster speeds than Standard processing” for GPT‑5.6 Sol in the API. The company says Fast mode costs twice the Standard price and does not change intelligence.

The cleanest way to understand the upper bound is to normalize Standard processing:

The arithmetic is straightforward:

Time ratio: 1 ÷ 2.5 = 0.40

Maximum affected-time reduction: 1 − 0.40 = 0.60, or 60%

Maximum speed per dollar: 2.5 ÷ 2 = 1.25

This does not mean every request will finish 60% sooner. The announcement does not define whether the 2.5× figure refers to output-token throughput, a broader processing measure, or an observed latency distribution. It also does not publish a service-level guarantee for time to first token or total task completion.

If a workflow spends most of its time waiting for a database, browser, hosted tool or third-party API, accelerating model inference will move only one part of the critical path. A long answer dominated by token generation may approach the advertised benefit more closely than a tool-heavy agent with short model turns.

The price of lower latency

Fast mode is not a token discount. A fixed-token Sol request costs twice as much.

At current Standard rates, one million uncached input tokens plus one million output tokens costs $35. The same token mix in Fast mode would cost $70 if the 2× multiplier applies uniformly. The value proposition is time, not cheaper computation.

That makes the decision operational:

Fast mode is justified when the value of the time saved exceeds the incremental processing cost.

For a customer-facing research product, cutting a minute from a response may improve completion rates or paid conversion. For an overnight batch job, the same minute may have almost no value. A model-routing policy should reflect that difference instead of enabling Fast globally.

API Fast mode is not Codex /fast

OpenAI uses similar language for two experiences with different speed and billing descriptions.

This distinction explains why “Fast is 2.5× faster” and “Fast is 1.5× faster” can both appear in current OpenAI material. The former is the July 30 API claim for Sol. The latter is the current Codex product documentation.

There is also a small documentation transition underway. OpenAI says Fast mode replaces API Priority Processing and that priority requests will automatically use Fast mode. At the time of this review, however, the live Responses API reference still lists priority as the supported service-tier value and does not list fast.

For existing integrations, the conservative move is to keep the documented priority value while confirming the response’s returned service_tier. Do not change production payloads to an undocumented enum merely because the marketing name changed.

Sol versus Terra versus Luna

The update makes model selection less about finding one universal default and more about matching intelligence to the consequence of error.

OpenAI positions the family as durable capability tiers rather than three models that must always be used separately. A strong architecture can use all three in one workflow: Sol resolves ambiguity and creates a plan; Terra handles demanding but scoped execution; Luna performs repetitive transformations and checks; Sol Fast is reserved for latency-critical escalations.

That approach also protects quality. Moving an entire workload to Luna because it is cheap is as blunt as routing every request to Sol. The correct unit of optimization is the step with a defined outcome and an evaluation that says whether the cheaper model clears the bar.

Worked cost examples

The following examples use current list prices and exclude built-in tool fees, storage, networking, taxes, discounts and the long-context surcharge. They are cost illustrations, not measured workloads.

1. High-volume extraction on Luna

Assume a daily job uses 20 million uncached input tokens and produces two million output tokens.

Current Luna cost

• Input: 20 × $0.20 = $4.00
• Output: 2 × $1.20 = $2.40
• Total: $6.40

At Luna’s launch price, the same token mix cost:

• Input: 20 × $1 = $20
• Output: 2 × $6 = $12
• Previous total: $32

The reduction is exactly 80%. At 30 identical daily runs, the illustrative monthly spend falls from $960 to $192.

2. A cache-heavy coding workflow on Terra

Assume a workflow uses two million uncached input tokens, reads eight million cached input tokens and produces one million output tokens.

Current Terra cost

• Uncached input: 2 × $2 = $4
• Cached input: 8 × $0.20 = $1.60
• Output: 1 × $12 = $12
• Total: $17.60

At Terra’s original rates, the same mix cost $22. The new price saves $4.40, or 20%.

The larger lesson is the cache. Without cached-input pricing, the eight million repeated input tokens alone would cost $16 at current rates instead of $1.60. Preserving exact reusable prefixes can outweigh minor prompt trimming.

3. A latency-sensitive Sol request

Assume a Sol request consumes 500,000 uncached input tokens and 100,000 output tokens.

Sol Standard

• Input: 0.5 × $5 = $2.50
• Output: 0.1 × $30 = $3
• Total: $5.50

Sol Fast, using the published 2× multiplier

• Total: $11
• Incremental cost: $5.50

Now assume, purely for illustration, that Standard spends 100 seconds in the processing affected by the speed claim. At the maximum 2.5× rate, that portion could fall to 40 seconds, saving 60 seconds.

In that hypothetical, Fast mode breaks even only when the business values the saved minute at more than $5.50 for that request. If tools and external systems account for half of the total wall time, the real saving would be materially smaller.

Where the evidence is strong—and where caution is warranted

The price evidence is strong. Current model pages confirm the new token rates, cached-input prices, context limits and long-input surcharge. The Fast-mode commercial claim is also explicit: up to 2.5× processing speed for 2× price, with no change in intelligence.

The latency evidence is thinner. OpenAI’s announcement does not provide a benchmark distribution, workload mix, tokens-per-second table, time-to-first-token result or service-level commitment. “Up to” describes a ceiling, not an expectation.

Customer examples provide useful clues but remain workload-specific. OpenAI reports that Notion found Terra comparable in quality to GPT‑5.5 at half the cost per task and in 60% less time. Dust says Luna was 40% faster and 40% cheaper than its prior default. Blitzy reports large reductions in output tokens and cost alongside better prompt-cache reuse. Those findings demonstrate that system design and model behavior can compound the list-price change. They do not establish a universal result.

The same caution applies to OpenAI’s broader claim that Luna delivers year-ago frontier-class performance at roughly six cents on the dollar per task and nearly nine times the speed. The comparison is useful positioning, but readers should not treat it as a substitute for an evaluation on their own prompts, tools and error costs.

Who should switch now?

Move volume work to Luna now if the workflow has a reliable evaluation suite, errors are recoverable, and the current model is materially more expensive. An 80% list-price reduction is large enough to justify a fresh routing test even if Luna was previously uneconomic or underpowered for the role.

Re-evaluate Terra as the everyday default when GPT‑5.5-level quality has been the target. Terra’s new price makes it a stronger middle tier, particularly for agents whose output volume makes Luna’s quality floor too risky.

Enable Sol Fast selectively when users are waiting, the request is valuable, and the model itself dominates latency. Good candidates include live debugging, interactive research, high-value document production and time-sensitive decision support.

Wait or stay on Standard for batch enrichment, overnight evaluation, background agents, long tool chains and workloads with weak observability. Paying twice the token price before measuring the bottleneck is not optimization.

Migration and implementation checklist

1. Preserve current Priority Processing integrations. OpenAI says requests tagged priority automatically use Fast mode. The live API reference still documents priority.
2. Log the returned service_tier. OpenAI notes that the tier returned in a response may differ from the requested value.
3. Benchmark the whole task, not only token throughput. Track time to first token, output rate, total wall time, tool wait, p50, p95 and failure rate.
4. Hold quality constant. Compare modes with the same model, effort, prompt, tool configuration and output requirements.
5. Measure cost per successful task. Token price alone misses retries, longer outputs, tool calls and failed runs.
6. Route Fast mode, do not blanket-enable it. Use a latency-value rule, a request class or an explicit user choice.
7. Reprice very long prompts. Above 272,000 input tokens, the full request receives the documented input and output multipliers.
8. Protect cacheability. Keep stable prompt prefixes byte-for-byte consistent and monitor cached-token usage.
9. Recheck documentation before changing enums. The product name has changed faster than the API reference.
10. Run a controlled rollout. Start with a small traffic share, define a rollback threshold, and compare quality, latency and cost against Standard.

Final verdict

The most consequential part of OpenAI’s July 30 update is not a single new default. It is a wider routing envelope.

Luna’s 80% cut changes the economics of high-volume agent work. Terra’s 20% reduction strengthens its case as the practical everyday model. Sol Fast offers a credible premium path when the delay itself is expensive.

The Fast-mode headline is mathematically attractive: at OpenAI’s stated maximum, 2.5× processing speed for 2× price produces up to 60% less affected processing time and 25% more speed per dollar. But the value survives only when model processing is the bottleneck and the saved time matters.

Use Luna to make routine intelligence abundant. Use Terra where a stronger quality floor pays for itself. Use Sol for ambiguity and consequence. Pay for Sol Fast when you can put a number on waiting.

FAQ

Is GPT‑5.6 Fast mode really 2.5× faster?

OpenAI says GPT‑5.6 Sol’s API Fast mode delivers up to 2.5× Standard processing speed. That is a ceiling, not a guarantee for every request. The announcement does not publish enough measurement detail to equate the claim with 2.5× lower end-to-end latency.

Does 2.5× speed mean requests take 2.5× less time?

No. If processing rate is 2.5× higher, the affected work takes 1 ÷ 2.5, or 40%, as long. That is a maximum 60% time reduction.

Does Fast mode make Sol more intelligent?

OpenAI says there is no change in intelligence. Fast mode changes processing speed and price, not the underlying model capability.

How much does GPT‑5.6 Sol Fast mode cost?

OpenAI says it costs 2× Standard API pricing. With Standard Sol at $5 per million input tokens, $0.50 per million cached input tokens and $30 per million output tokens, the derived Fast rates are $10, $1 and $60 respectively. Confirm current billing documentation before production deployment.

Is API Fast mode the same as Codex /fast?

No. The API announcement says Sol Fast is up to 2.5× Standard speed at 2× the API price. Codex documentation says /fast provides 1.5× speed and GPT‑5.6 consumes ChatGPT credits at 2.5× the Standard rate. Codex used with an API key follows API token billing.

Should API requests use fast or priority as the service tier?

OpenAI says existing priority requests will automatically use Fast mode. At the research cutoff, the Responses API reference still lists priority and does not list fast. Keep the documented value until OpenAI updates the schema or provides explicit migration instructions.

Which GPT‑5.6 model is cheapest?

Luna. It currently costs $0.20 per million input tokens, $0.02 per million cached input tokens and $1.20 per million output tokens.

When is Fast mode worth paying for?

When the model is a meaningful part of the critical path and the value of time saved exceeds the extra token cost. It is less attractive for asynchronous, tool-bound or cost-sensitive work.

Official sources

• OpenAI: Advancing the price-performance frontier with GPT-5.6
• OpenAI: GPT-5.6 launch announcement
• OpenAI: GPT-5.6 frontier intelligence and efficiency
• OpenAI API: GPT-5.6 Sol
• OpenAI API: GPT-5.6 Terra
• OpenAI API: GPT-5.6 Luna
• OpenAI API: Create a model response
• OpenAI Codex: Fast mode