OpenAI GPT-5.6 Sol, Terra, and Luna: Performance, Pricing, and Efficiency Explained

Introduction

OpenAI’s GPT-5.6 family is built around three model tiers: Sol, Terra, and Luna.

Rather than offering one model for every workload, OpenAI is separating the family by capability, cost, and throughput:

• GPT-5.6 Sol is the flagship model for complex professional work, coding, research, cybersecurity, and long-horizon agent tasks.
• GPT-5.6 Terra targets workloads that still need strong intelligence but have tighter cost requirements.
• GPT-5.6 Luna is the fastest and least expensive member of the family, intended for cost-sensitive and high-volume workloads.

OpenAI first previewed the family in June 2026 and moved it to general availability on July 9. The AIBase source article, published on July 30, focuses on the efficiency gains behind the release: better performance per token, lower-cost model tiers, and infrastructure and agent-loop optimizations intended to reduce the total cost of completing real work.

That focus matters. For production AI systems, the relevant metric is increasingly not just how intelligent a model appears in isolation, but how much useful work it can complete for a given amount of time, compute, and money.

Three GPT-5.6 Models for Different Workloads

OpenAI describes Sol, Terra, and Luna as durable capability tiers rather than temporary suffixes.

The generation number identifies the GPT-5.6 family, while the names distinguish the intended performance and cost level.

Model	Positioning	API Input Price	API Output Price	Context Window	Max Output
GPT-5.6 Sol	Flagship model for complex professional work	$5 / 1M tokens	$30 / 1M tokens	1,050,000 tokens	128,000 tokens
GPT-5.6 Terra	Balance of intelligence and cost	$2.50 / 1M tokens	$15 / 1M tokens	1,050,000 tokens	128,000 tokens
GPT-5.6 Luna	Cost-sensitive, high-volume workloads	$1 / 1M tokens	$6 / 1M tokens	1,050,000 tokens	128,000 tokens

All three model pages list a February 16, 2026 knowledge cutoff and support text plus image input with text output.

The gpt-5.6 API alias routes to GPT-5.6 Sol.

GPT-5.6 Sol: The Flagship

Sol is OpenAI’s highest-capability GPT-5.6 tier.

OpenAI positions it for:

• Complex coding
• Long-horizon agent workflows
• Professional knowledge work
• Scientific research
• Cybersecurity
• Computer use
• Multimodal analysis
• High-value reasoning tasks

On the Artificial Analysis Coding Agent Index v1.1, OpenAI reports a score of 80 for GPT-5.6 Sol at max reasoning, compared with 77.2 for Claude Fable 5 in the same table.

OpenAI also says Sol uses less than half as many output tokens and less than half as much time in that comparison, while its estimated task cost is lower.

That does not mean Sol is universally better on every benchmark. OpenAI’s own launch table shows competing models ahead on some evaluations. The more consistent GPT-5.6 claim is performance per token and per dollar, not a clean sweep across every task category.

GPT-5.6 Terra: The Balanced Tier

Terra is the middle model in the family.

OpenAI describes its capability as competitive with GPT-5.5 while charging:

• $2.50 per million input tokens
• $15 per million output tokens

That is half the corresponding $5 / $30 pricing associated with the previous flagship-class tier.

Terra is therefore aimed at workloads where a team wants strong reasoning and agent capability but does not need Sol for every request.

Typical examples include:

• Internal enterprise agents
• Coding subagents
• Document analysis
• Research workflows
• Tool-heavy automation
• High-volume professional tasks

The model supports the same 1.05-million-token context window and 128,000-token maximum output as Sol.

GPT-5.6 Luna: The Lowest-Cost GPT-5.6 Tier

Luna is designed for workloads where throughput and cost matter most.

Its API price is:

• $1 per million input tokens
• $6 per million output tokens

That makes both input and output pricing 80% lower than Sol.

OpenAI describes Luna as its fastest and most affordable GPT-5.6 model. It is suitable for workloads such as:

• Classification
• Extraction
• Routing
• High-volume processing
• Lightweight subagents
• Repetitive structured tasks
• Applications that can escalate difficult cases to Terra or Sol

The lower price does not mean Luna is simply a non-reasoning utility model. It still supports GPT-5.6 reasoning features and OpenAI’s tool ecosystem, but its capability ceiling is lower than Sol’s.

Efficiency Is the Main Theme of GPT-5.6

The AIBase article emphasizes that GPT-5.6 is not only a model-quality upgrade.

The larger engineering goal is to increase the amount of useful work produced by each token and reduce the overhead around agent execution.

OpenAI’s official launch material supports that broader direction.

The company says GPT-5.6 was trained to complete useful work with fewer output tokens, and its developer guidance recommends testing the same reasoning effort—and often one level lower—when migrating from GPT-5.5 or GPT-5.4.

This matters because the advertised token price is only one part of the cost of an agent.

A multi-step workflow can consume money through:

• Large prompts
• Repeated context
• Reasoning tokens
• Tool definitions
• Tool outputs
• Retry loops
• Multiple model turns
• Subagents
• Long final responses

A model that needs fewer steps can therefore be cheaper in practice even when its headline per-token rate looks similar.

Sol’s Coding Performance Improves the Performance-per-Dollar Trade-Off

The source article highlights Sol’s coding-agent performance.

OpenAI’s current benchmark table reports:

Coding Evaluation	GPT-5.6 Sol	GPT-5.6 Terra	GPT-5.6 Luna	GPT-5.5
Artificial Analysis Coding Agent Index v1.1	80	77.4	74.6	76.4
SWE-Bench Pro	64.6%	63.4%	62.7%	59.4%
DeepSWE v1.1	72.7%	69.6%	67.2%	67.0%
Terminal-Bench 2.1	88.8%	87.4%	84.7%	85.6%

These numbers come from OpenAI’s published launch table and should be read in the context of the specific evaluation harnesses and settings.

For example, benchmark results can change depending on:

• Reasoning effort
• Agent harness
• Tool availability
• Time limits
• Number of evaluation seeds
• Model snapshot
• Prompt format

OpenAI also notes that some of its cost and latency comparisons are offline estimates based on production behavior rather than direct invoices from every competing service.

The practical lesson is to test models on representative production work rather than selecting them only from a leaderboard.

The Inference Stack Is Being Optimized, Not Just the Model

The AIBase source describes optimization across the serving stack, including:

• Load balancing
• Speculative decoding
• Cache optimization
• Optimized GPU kernels

It also reports a gain of more than 15% in token-generation efficiency from the inference work.

Those low-level serving details are presented in the AIBase report. OpenAI’s current public GPT-5.6 launch page confirms a broader effort to improve serving and research efficiency, but the exact low-level figure should be treated as source-reported unless it is reproduced in an OpenAI technical publication or benchmark with a fully documented method.

What is independently clear from OpenAI’s documentation is that GPT-5.6 adds several mechanisms intended to reduce unnecessary model work.

These include:

• More token-efficient generation
• Explicit prompt caching
• Persisted reasoning
• Programmatic Tool Calling
• Multi-agent execution for suitable workloads
• Configurable reasoning effort

The engineering direction is consistent: do less redundant work around each successful task.

Prompt Caching Becomes More Explicit

GPT-5.6 introduces more predictable prompt caching.

OpenAI documents support for explicit cache breakpoints, allowing developers to decide which reusable prompt prefixes should be cached.

For GPT-5.6 models:

• Cache writes are billed at 1.25× the normal uncached input rate.
• Cache reads receive a 90% cached-input discount.
• OpenAI documents a 30-minute minimum cache life for the new caching behavior.

This changes how developers should think about long-running agents.

A large system prompt, tool catalog, policy section, or stable project context can be expensive if it is repeatedly sent as uncached input.

Caching can reduce that cost when the reusable prefix stays stable.

At the same time, unnecessary cache writes can increase cost. OpenAI therefore recommends tracking both cached-token and cache-write-token usage instead of assuming that caching is always cheaper.

Tool Orchestration Can Reduce Model Round Trips

The second major efficiency area is the agent harness.

A conventional tool loop often looks like this:

1. The model decides to call a tool.
2. The application executes the tool.
3. The complete tool result is returned to the model.
4. The model reads it and decides what to do next.
5. Another tool is called.
6. The loop repeats.

That approach is flexible, but it can become expensive.

Large intermediate tool outputs may repeatedly enter the model context even when only a small fraction of the data is needed.

GPT-5.6’s Programmatic Tool Calling provides another option.

OpenAI documents that GPT-5.6 can write JavaScript inside a hosted runtime to:

• Call eligible tools
• Pass results between calls
• Filter intermediate data
• Join records
• Rank results
• Deduplicate data
• Validate data
• Return a smaller structured result to the model

For bounded workflows, that can reduce:

• Model turns
• Prompt growth
• Intermediate tokens
• Network round trips

OpenAI says this pattern is particularly useful when code can process several predictable tool results without requiring new semantic judgment after every call.

It is not appropriate for every agent task.

Direct model-tool interaction is still preferable when:

• One tool call is enough
• Each result can materially change the next reasoning step
• Human approval is required
• The intermediate result is already small
• The final answer must preserve native citations or artifacts

The goal is not to minimize calls at all costs. It is to avoid sending unnecessary information through the model.

Conversation History and Reasoning Can Be Managed More Carefully

The AIBase article also points to stricter conversation-history management as a way to improve cache reuse.

OpenAI’s current GPT-5.6 developer guidance provides a related official mechanism: persisted reasoning.

Developers can configure how reasoning from earlier turns remains available.

For long-running workflows, this matters because not every previous thought is equally useful forever.

If the task remains stable, earlier reasoning can improve continuity.

If the objective changes, carrying all previous reasoning forward can add cost and stale assumptions.

OpenAI therefore allows applications to control reasoning.context and recommends preserving required response items correctly when managing history manually.

This gives developers another lever for balancing:

• Continuity
• Cache efficiency
• Context size
• Cost
• Quality

Leaner Prompts Can Also Reduce Agent Cost

OpenAI’s GPT-5.6 developer guide specifically recommends leaner prompts.

In a sample of internal coding-agent evaluation runs, OpenAI reports that simplifying prompts and tool descriptions:

• Improved evaluation scores by roughly 10% to 15%
• Reduced total tokens by 41% to 66%
• Reduced cost by 33% to 67%

OpenAI explicitly describes these figures as directional and says results vary by workload.

The recommendation is not to delete useful constraints.

It is to remove repetition.

A practical migration process is:

1. Start from a prompt and tool set that already works.
2. Remove one group of repeated instructions at a time.
3. Re-run the same evaluation tasks.
4. Keep constraints that improve measured quality.
5. Remove instructions that add tokens without improving outcomes.

This is especially important for agent products where the same system prompt and tool descriptions may be sent thousands of times per day.

Model Choice Should Follow the Workload

The GPT-5.6 family gives developers three main cost-quality points.

Use Sol When Quality Is the Main Constraint

Choose Sol when the task benefits materially from frontier capability.

Examples include:

• Difficult software engineering
• Complex research
• Long-horizon planning
• Cybersecurity work
• High-value professional analysis
• Tasks where a small quality improvement justifies a larger model bill

Use Terra for Strong General Production Work

Terra is a practical choice when the task needs strong reasoning but Sol is unnecessary.

It can be appropriate for:

• Everyday enterprise agents
• Coding assistance
• Document workflows
• Research subagents
• Moderate-complexity tool use
• High-volume professional tasks

Use Luna When Cost and Volume Dominate

Luna is the natural first candidate for:

• Classification
• Extraction
• Routing
• Data transformation
• Lightweight tool workflows
• High-volume background automation

A common architecture is to route normal work to Luna or Terra and escalate only the hardest tasks to Sol.

Pricing Is Only the Starting Point

A simple per-token comparison can be misleading for agent systems.

Consider two models.

Model A costs less per output token but uses:

• Twice as many reasoning tokens
• More tool calls
• More retries
• More context
• More turns

Model B has a higher list price but finishes the task in half as many steps.

The second model may still be cheaper per completed task.

Teams evaluating GPT-5.6 should therefore track:

• Task success rate
• Total input tokens
• Total output tokens
• Cached tokens
• Cache-write tokens
• Number of model turns
• Tool calls
• Latency
• Retry rate
• Human correction time
• Total cost per successful task

This is the practical meaning of “intelligence per token.”

A Useful Migration Test

For teams already using GPT-5.5 or an earlier model, a controlled comparison is more useful than an immediate full migration.

Step 1: Build a Representative Evaluation Set

Include:

• Easy requests
• Difficult requests
• Long-context tasks
• Tool-heavy workflows
• Known failure cases
• Production examples

Step 2: Keep the Current Reasoning Effort as the Baseline

OpenAI recommends beginning with the same reasoning effort used on the previous model.

Then test one level lower.

GPT-5.6 may preserve quality with fewer reasoning tokens, but that needs to be confirmed on your workload.

Step 3: Compare Sol, Terra, and Luna

Do not assume the flagship model is automatically the best production choice.

Measure whether Terra or Luna can satisfy the same acceptance criteria at lower cost.

Step 4: Test Prompt Caching

Track cache reads and writes.

Stable context can become significantly cheaper when reuse is high, but frequently changing prompt prefixes may not benefit as much.

Step 5: Test Programmatic Tool Calling Where Appropriate

Use it on bounded processing stages such as:

• Filtering
• Aggregation
• Ranking
• Joining
• Deduplication

Compare the result with ordinary direct tool calls.

Step 6: Measure Completed-Task Economics

A lower token bill is useful only if the final task still passes the quality bar.

The correct optimization target is not the fewest tokens.

It is the lowest reliable cost for a successful outcome.

Why GPT-5.6 Reflects a Broader Shift Toward Efficiency

For several years, frontier-model competition was dominated by one question: which model is more capable?

That question remains important.

But as AI moves into large-scale production, another question matters just as much:

How much useful work can the system deliver for every unit of compute and every dollar spent?

Agent systems amplify this pressure.

A single user request can trigger:

• Multiple reasoning turns
• Search
• Code execution
• External APIs
• Subagents
• Large context windows
• Repeated validation

Without careful orchestration, the total bill grows quickly.

GPT-5.6 reflects a broader shift from simply scaling intelligence toward making intelligence more economical to deploy.

Sol pushes the high end of capability.

Terra reduces the cost of strong general work.

Luna brings the family into high-volume workloads.

Prompt caching and programmatic tool orchestration target the infrastructure overhead around the models themselves.

The result is a model family designed not only around benchmark scores, but around production economics.

FAQ

What is GPT-5.6?

GPT-5.6 is OpenAI’s model family for complex reasoning, coding, professional work, agent workflows, and high-volume AI applications. The family currently includes Sol, Terra, and Luna.

What is the difference between GPT-5.6 Sol, Terra, and Luna?

Sol is the flagship and most capable tier. Terra balances intelligence and cost, while Luna is optimized for lower-cost, high-volume workloads.

How much does GPT-5.6 cost through the API?

OpenAI lists Sol at $5 input / $30 output per million tokens, Terra at $2.50 / $15, and Luna at $1 / $6. Cached-input pricing is lower, and very long prompts may use different pricing rules.

What is the context window of GPT-5.6?

OpenAI’s current API model pages list a 1,050,000-token context window for Sol, Terra, and Luna. Each model supports up to 128,000 output tokens.

Is GPT-5.6 Sol better for coding than GPT-5.5?

OpenAI reports higher results for Sol on several coding-agent evaluations, including the Artificial Analysis Coding Agent Index, SWE-Bench Pro, DeepSWE, and Terminal-Bench 2.1. Real production performance still depends on the repository, agent harness, prompts, and tools.

What is Programmatic Tool Calling?

Programmatic Tool Calling lets GPT-5.6 write code that coordinates eligible tools and processes intermediate results inside a hosted runtime. It can reduce model round trips and token use in bounded workflows such as filtering, joining, ranking, and aggregation.

Does GPT-5.6 support prompt caching?

Yes. GPT-5.6 supports automatic caching and explicit cache breakpoints. OpenAI says cache reads retain a 90% input discount, while new cache writes are billed at 1.25× the uncached input rate.

Should I use Sol for every request?

Usually not. If Terra or Luna passes the same evaluation criteria at a lower cost, using the smaller tier can improve application economics. Route harder tasks to Sol when the additional capability produces a measurable benefit.

Related Tools

• OpenAI API: The official developer platform for accessing GPT-5.6 models and OpenAI tools.
• GPT-5.6 Model Guidance: OpenAI’s migration and optimization guide for the GPT-5.6 family.
• GPT-5.6 Sol: Official model specifications, pricing, context limits, and supported features for Sol.
• GPT-5.6 Terra: Official model page for the balanced GPT-5.6 tier.
• GPT-5.6 Luna: Official model page for the lowest-cost GPT-5.6 tier.
• OpenAI Codex: OpenAI’s agentic coding environment for software-development workflows.

Related Links

• OpenAI GPT-5.6 Launch: OpenAI’s official general-availability announcement, benchmark tables, safety details, pricing, and product availability.
• GPT-5.6 Sol Preview: OpenAI’s earlier preview announcement for Sol, Terra, and Luna.
• OpenAI API Models: The current official catalog of OpenAI models and their headline specifications.
• GPT-5.6 Model Guidance: Official guidance for reasoning effort, prompt caching, persisted reasoning, and Programmatic Tool Calling.
• GPT-5.6 Sol API Page: Current Sol pricing, context window, knowledge cutoff, and supported API features.
• GPT-5.6 Terra API Page: Current Terra pricing and model specifications.
• GPT-5.6 Luna API Page: Current Luna pricing and model specifications.

Summary

GPT-5.6 is a three-tier model family rather than one universal model. Sol targets frontier capability, Terra offers a lower-cost balance for general production work, and Luna is optimized for high-volume workloads.

The biggest theme is efficiency. OpenAI is combining more token-efficient models with explicit prompt caching, persisted reasoning, configurable reasoning effort, and Programmatic Tool Calling to reduce the amount of model work required to finish complex tasks.

The AIBase source also reports additional inference-stack optimizations, including speculative decoding and GPU-kernel work, with a more than 15% gain in token-generation efficiency. Those low-level figures should be treated as source-reported unless reproduced in a fully documented OpenAI technical publication.

GPT-5.6 is best understood not simply as a stronger model release, but as an attempt to improve the economics of intelligence across the entire agent workflow.