OpenAI Cuts GPT-5.6 Luna Pricing by 80% and Launches Faster Sol API Mode

Introduction

OpenAI has made a major pricing adjustment across the GPT-5.6 family.

Starting July 30, 2026, the company cut the API price of GPT-5.6 Luna by 80% and GPT-5.6 Terra by 20%. The standard price of flagship GPT-5.6 Sol remains unchanged, but OpenAI has introduced Fast mode, which can deliver up to 2.5× the speed of Standard processing while keeping the same model intelligence.

The change arrives immediately after OpenAI published an engineering breakdown showing how GPT-5.6 Sol helped optimize the systems used to serve GPT-5.6 itself. According to OpenAI, production GPU-kernel improvements lowered end-to-end serving cost by 20%, while improvements to speculative decoding increased token-generation efficiency by more than 15%.

The result is a more aggressive push on what OpenAI describes as the price-performance frontier: matching the amount of intelligence used to the economic value of the task.

For developers, the most important change is straightforward: Luna is now dramatically cheaper for high-volume agent workloads, Terra costs less for everyday work, and Sol can be purchased at a higher service tier when latency matters more than price.

1. Luna Drops 80%, Terra Falls 20%, and Sol Gets Fast Mode

The July 30 pricing update covers the entire GPT-5.6 family, but the changes are not identical across models.

GPT-5.6 Luna: The Largest Price Cut

Luna received the most aggressive reduction.

Its Standard API price changed from:

Token Type	Previous Price	New Price	Change
Input	$1.00 / 1M tokens	$0.20 / 1M tokens	-80%
Output	$6.00 / 1M tokens	$1.20 / 1M tokens	-80%

OpenAI describes Luna as the fastest and most affordable GPT-5.6 model and positions it for cost-sensitive, high-volume workloads.

That includes tasks such as:

• Classification
• Extraction
• Background agents
• Routine coding work
• Test generation
• Structured-output workflows
• Tool-using subagents
• Large-scale document processing

The lower price changes the economics of agent loops in particular, because one user request can involve many model calls rather than one simple completion.

OpenAI says Luna can use tools and complete multi-step workflows, making it practical to assign more work to a lower-cost model instead of reserving agentic behavior for higher-priced frontier tiers.

GPT-5.6 Terra: A Smaller but Meaningful Reduction

Terra’s Standard API price is now:

Token Type	Previous Price	New Price	Change
Input	$2.50 / 1M tokens	$2.00 / 1M tokens	-20%
Output	$15.00 / 1M tokens	$12.00 / 1M tokens	-20%

Terra remains the middle tier in the GPT-5.6 family.

It is designed for workloads that need stronger reasoning than Luna but do not necessarily justify Sol’s higher cost.

Typical applications include:

• Everyday enterprise agents
• Coding assistance
• Workspace Q&A
• Document analysis
• Scoped research
• Multi-step professional workflows

OpenAI cites Notion as one customer using Terra for personal-agent workloads such as workspace Q&A and scoped tasks where latency matters.

GPT-5.6 Sol Keeps Its Standard Price

Sol’s Standard API pricing remains:

Token Type	Standard Price
Input	$5.00 / 1M tokens
Output	$30.00 / 1M tokens

The change for Sol is not a price reduction.

Instead, OpenAI has introduced Fast mode.

Sol Fast Mode: Up to 2.5× Faster

Fast mode replaces OpenAI’s previous Priority Processing terminology.

For GPT-5.6 Sol, OpenAI says Fast mode provides up to 2.5× faster speeds than Standard processing with no change in model intelligence.

The trade-off is price.

Fast mode costs twice as much as Standard processing.

For Sol, that means:

Token Type	Standard	Fast Mode
Input	$5.00 / 1M	$10.00 / 1M
Cached input	$0.50 / 1M	$1.00 / 1M
Output	$30.00 / 1M	$60.00 / 1M

Existing API requests using:

service_tier="priority"

remain backward compatible and are routed through Fast mode.

OpenAI also supports:

service_tier="fast"

for the renamed service.

Fast mode is useful when the cost of waiting is greater than the cost of faster inference.

Examples include:

• Interactive coding agents
• Time-sensitive production workflows
• Real-time analyst assistance
• High-value customer operations
• Complex agent tasks where latency compounds across many steps

A workflow that makes 20 or 30 model calls can feel much slower than a single chat response, even if each individual call has only modest latency. Faster processing can therefore matter disproportionately in agentic systems.

ChatGPT Work and Codex Usage Also Changes

The lower Luna and Terra prices are also reflected in how usage is counted in ChatGPT Work and Codex.

OpenAI says:

• Free and Go users can access Terra.
• Plus, Pro, Business, and Enterprise users can choose Terra and Luna.
• Subscription prices and quota budgets remain unchanged.
• Because Luna and Terra are cheaper, using them now consumes fewer credits.

This does not mean paid subscriptions themselves became cheaper.

The change means the same quota can go further when a user selects Luna or Terra.

Price-Performance Is Becoming a More Important Model Metric

OpenAI published a price-versus-intelligence chart based on the Artificial Analysis Intelligence Index v4.1 to illustrate Luna’s new position.

The chart places GPT-5.6 Luna above 50 on the Intelligence Index while showing an estimated task cost of roughly $0.05 for one of the plotted Luna configurations after the price change.

This figure should not be confused with the price of one arbitrary API call.

Artificial Analysis calculates cost per Intelligence Index task from model token usage and the benchmark’s weighting methodology. The cost of a real production request depends on:

• Input size
• Output size
• Reasoning effort
• Prompt-cache hits
• Tool calls
• Number of agent turns
• Long-context pricing
• Retry behavior

Before the July 30 price reduction, Artificial Analysis reported GPT-5.6 Luna at approximately 51 on its Intelligence Index in the max-reasoning configuration.

The new lower token price pushes Luna farther toward the low-cost side of the intelligence-versus-cost curve.

The broader message from OpenAI is that businesses should not use the most expensive model for every step.

A workflow might use Sol to resolve ambiguity and build a plan, then assign well-defined implementation, testing, or repetitive work to Luna.

That kind of model routing becomes more attractive when the lower tier is capable enough to use tools and complete multi-step workflows.

2. GPT-5.6 Helped Optimize the Infrastructure Running GPT-5.6

The price reduction came one day after OpenAI published a detailed engineering post on how GPT-5.6 became more efficient to serve.

The most unusual part of that story is that GPT-5.6 Sol itself participated in the optimization process.

OpenAI says its engineers used Sol through Codex to analyze production systems, write performance code, test alternatives, and monitor experiments.

The company describes optimization across three broad layers:

1. The agent harness
2. API and request orchestration
3. Model inference on GPU infrastructure

Sol Helped Optimize Production GPU Kernels

At the inference layer, OpenAI says GPT-5.6 Sol autonomously rewrote and optimized production kernels.

GPU kernels are low-level programs responsible for executing mathematical operations efficiently on accelerator hardware.

Even when the underlying model architecture is unchanged, inefficient memory movement, synchronization, scheduling, or data layouts can leave expensive GPU resources underutilized.

OpenAI says Sol helped identify computations that could be:

• Precomputed
• Avoided
• Parallelized
• Reordered
• Implemented with more efficient kernels

The company specifically mentions Triton and Gluon as GPU-programming technologies involved in this work.

According to OpenAI, the kernel improvements and related serving work reduced the end-to-end cost of serving GPT-5.6 by 20%.

Sol Also Improved Speculative Decoding

Another major optimization came from speculative decoding.

In a simplified version of speculative decoding:

1. A smaller draft model predicts several likely next tokens.
2. The main model evaluates those proposed tokens in parallel.
3. Accepted tokens can be emitted without requiring the same amount of sequential generation work.

The quality of the draft model therefore matters.

OpenAI says GPT-5.6 Sol designed and ran hundreds of experiments on the speculative model’s architecture, including changes in:

• Size
• Structure
• Features
• Training configuration

Sol also monitored the training process and intervened when hardware failures or training instability appeared.

OpenAI says the resulting changes improved token-generation efficiency by more than 15%.

Load Balancing Matters Too

Model cost is not determined only by the code running inside one GPU.

Requests have to be routed across:

• Regions
• Data centers
• Accelerator types
• Clusters
• Model instances
• Model sub-networks
• Computing cores

A powerful accelerator can still be expensive if work is distributed poorly and some hardware sits idle.

OpenAI says Sol helped analyze production traffic, find sources of imbalance, test alternative routing strategies, and tune the heuristics used to distribute requests.

This type of operational improvement can increase total throughput without requiring an equivalent increase in hardware.

Context Management Reduces Repeated Work

OpenAI also optimized the agent harness used by systems including Codex and ChatGPT Work.

An agent can make many model and tool calls before returning one final result.

For example, Codex might:

1. Inspect source code.
2. Search deployment history.
3. Read an incident report.
4. Edit a file.
5. Run tests.
6. Inspect errors.
7. Revise the code.
8. Re-run the tests.

Every loop can carry context, tool definitions, previous results, and environment information.

If that context grows unnecessarily, cost and latency grow with it.

OpenAI says its agent harness uses techniques including deferred discovery, so tools, skills, plugins, and MCP integrations are exposed only when they are needed.

Tool output is capped at 10,000 tokens by default unless the model requests a different limit.

This reduces the chance that a large tool result unnecessarily fills the context window.

Prompt Caching Is Preserved Through Append-Only History

Agent loops often reuse the same instructions and context several times.

Prompt caching can avoid recomputing stable prompt prefixes.

But caching is only effective when the repeated prefix stays exactly the same.

OpenAI says its harness keeps model-visible history append-only:

• New messages are added at the end.
• Tool results are added at the end.
• Environment updates are added at the end.
• Tool ordering is deterministic.
• Runtime approval settings are handled outside the tool definitions.

That design improves prompt-cache reuse in Codex and ChatGPT Work.

The general principle is simple:

A model can be cheaper not only because its tokens cost less, but because the surrounding system avoids generating and processing unnecessary tokens in the first place.

The Efficiency Loop Can Compound

OpenAI describes this as a feedback loop.

A stronger model helps engineers improve:

• GPU kernels
• Routing
• Speculative decoding
• Caching
• Workload configuration
• Agent orchestration

Those improvements reduce cost and latency.

The more efficient infrastructure then makes it cheaper to run stronger models at larger scale.

OpenAI argues that this can shorten the time required to find the next generation of optimization gains.

The July 30 Luna and Terra price reductions are the clearest customer-facing result so far.

3. Developer Reaction: Luna Gets More Attention, and Competitors Face New Price Pressure

The original Chinese report also highlights a lively developer response after the announcement.

Some users focused on the size of the Luna price cut.

An 80% reduction is much larger than the more incremental pricing changes common in frontier APIs.

Others argued that Luna had been underestimated even before the reduction, particularly for agentic workloads where a lower-cost model can handle routine execution under the direction of a stronger planner.

The pricing move also triggered immediate comparisons with other cost-focused models, including Kimi K3.

One viral meme shared in the community framed the situation as Luna suddenly competing for the same users who had been attracted to Kimi K3’s low-cost positioning.

The meme is amusing, but it is not a technical benchmark and is omitted from the main article images.

Developers Immediately Asked Whether Anthropic Would Respond

Another common reaction was to tag Anthropic and ask whether Claude API pricing would move in response.

That reaction reflects a broader change in frontier-model competition.

A year ago, the most visible competition centered on:

• Benchmark scores
• Coding ability
• Context windows
• Multimodal features

Those dimensions still matter.

But developers running production agents increasingly care about:

• Cost per completed task
• Latency
• Output-token use
• Prompt-cache efficiency
• Tool-call count
• Reliability
• Model-routing flexibility

The cheapest token is not always the cheapest workflow.

Likewise, the most intelligent model is not always the best model for every step of a workflow.

Luna’s Price Cut Makes Model Routing More Attractive

Suppose one task consists of five stages:

1. Understand an ambiguous problem.
2. Create a plan.
3. Modify routine files.
4. Write tests.
5. Check the result.

A team might use Sol for stages 1 and 2.

Luna could handle stages 3 through 5 when the work is clearly specified.

The cheaper Luna becomes, the stronger the incentive to route routine agent work away from the flagship model.

This does not mean Luna is close to Sol on every capability.

It means the value of a smaller model depends on whether it is intelligent enough for the specific job assigned to it.

The Important Metric Is Cost per Successful Outcome

OpenAI’s new messaging repeatedly emphasizes outcome per dollar.

That is more useful than looking only at token prices.

A production evaluation should track:

• Task success rate
• Input tokens
• Output tokens
• Cached-input reuse
• Model turns
• Tool calls
• End-to-end latency
• Retry rate
• Human correction time
• Total cost per successful task

A model that costs one-fifth as much per token can still be expensive if it requires many retries.

A more expensive model can be cheaper overall if it completes the work in fewer steps.

The new Luna price makes the calculation more favorable for the smaller model, but developers still need workload-specific evaluation.

Conclusion: Model Competition Is Shifting Toward the Intelligence-to-Cost Ratio

The events of July 29 and July 30 show OpenAI pushing two related ideas at once.

First, GPT-5.6 is increasingly being used to improve the infrastructure that runs GPT-5.6.

Second, the company is passing some of those efficiency gains into lower customer pricing and faster service options.

That changes the competitive question.

The next stage of the model market is not only:

Which model is smartest?

It is also:

How much useful intelligence can a developer buy for each dollar and each second of latency?

Luna’s 80% reduction makes that question especially visible.

Terra becomes cheaper for everyday professional work.

Sol remains the premium model, but Fast mode gives developers a way to pay more when time matters.

As model quality converges across more tasks, the companies that can make the same hardware complete more useful work—and then convert those efficiency gains into better pricing—may gain an increasingly important advantage.

常见问题

What is the new GPT-5.6 Luna API price?

Starting July 30, 2026, OpenAI lists GPT-5.6 Luna at $0.20 per million input tokens and $1.20 per million output tokens in Standard processing. That is an 80% reduction from its original $1 / $6 pricing.

What is the new GPT-5.6 Terra price?

GPT-5.6 Terra now costs $2 per million input tokens and $12 per million output tokens in Standard processing. OpenAI says this is a 20% reduction from its previous $2.50 / $15 pricing.

Did GPT-5.6 Sol become cheaper?

No. Sol’s Standard API price remains $5 per million input tokens and $30 per million output tokens. The main change is the introduction of Fast mode.

What is GPT-5.6 Sol Fast mode?

Fast mode is OpenAI’s faster API processing tier and replaces the previous Priority Processing name. For GPT-5.6 Sol, OpenAI says it can deliver up to 2.5× Standard speed at twice the Standard token price without changing the model’s intelligence.

Do old Priority Processing API requests still work?

Yes. OpenAI says requests using the priority service tier remain backward compatible and automatically use Fast mode. Developers can also use the fast service-tier value.

Did GPT-5.6 really help optimize itself?

OpenAI says GPT-5.6 Sol, used through Codex in a human-led engineering process, helped analyze production traffic, rewrite GPU kernels, run hundreds of speculative-decoding experiments, and monitor training. OpenAI attributes a 20% reduction in end-to-end serving cost and a 15%+ improvement in token-generation efficiency to parts of this work.

Does the price cut change ChatGPT subscriptions?

Subscription prices and quota budgets do not change. OpenAI says Luna and Terra now consume fewer credits in Codex and ChatGPT Work because their underlying prices are lower.

Is Luna now the best model for every agent workload?

No. Luna is much cheaper, but model selection still depends on task difficulty and acceptable error rate. A common strategy is to use a stronger model for ambiguous planning and a cheaper model for well-specified execution.

相关工具

• OpenAI API: OpenAI’s developer platform for accessing GPT-5.6 models and API services.
• GPT-5.6 Sol: Official specifications for the flagship GPT-5.6 model.
• GPT-5.6 Terra: Official model documentation for the balanced GPT-5.6 tier.
• GPT-5.6 Luna: Official documentation for the cost-sensitive GPT-5.6 tier.
• Codex: OpenAI’s agentic coding environment, used internally in some GPT-5.6 optimization work.
• Artificial Analysis: An independent model-analysis platform covering intelligence, speed, token use, and cost per task.

Related Links

• OpenAI: Advancing the Price-Performance Frontier with GPT-5.6: OpenAI’s official July 30 announcement of the Luna and Terra price cuts and Sol Fast mode.
• OpenAI: How GPT-5.6 Fuses Frontier Intelligence With Frontier Efficiency: Engineering details on load balancing, GPU kernels, speculative decoding, context management, and prompt caching.
• OpenAI Fast Mode: Official documentation for faster API processing and Fast mode pricing.
• OpenAI GPT-5.6 Launch: The original general-availability announcement and benchmark context for the GPT-5.6 family.
• Artificial Analysis: GPT-5.6 Benchmarks: Independent analysis of GPT-5.6 intelligence, coding performance, speed, and cost before the July 30 price reduction.
• Artificial Analysis GPT-5.6 Luna: Model-level methodology and Intelligence Index details for Luna.
• OpenAI Model Catalog: Official API model catalog and current model specifications.

Summary

OpenAI has cut GPT-5.6 Luna API pricing by 80% and Terra by 20%, while leaving Sol’s Standard price unchanged. Sol instead gains Fast mode, which can provide up to 2.5× faster API processing at twice the Standard price.

The timing is closely connected to OpenAI’s recent engineering work. The company says GPT-5.6 Sol helped optimize GPU kernels, speculative decoding, load balancing, and agent infrastructure, contributing to a 20% reduction in end-to-end serving cost and more than 15% better token-generation efficiency in parts of the stack.

For developers, the result is a wider price-performance range: Sol for the hardest work, Terra for balanced professional tasks, and Luna for high-volume agent execution at a much lower price.

The GPT-5.6 update shows that frontier-model competition is increasingly about cost per successful outcome—not just raw benchmark intelligence.