GPT-5.6 Three-Model Architecture Explained: Sol/Terra/Luna Pricing and Performance Overview

GPT-5.6: From a Single Model to a Three-Model Architecture

Based on publicly available information and a summary analysis by Bilibili creator DP, OpenAI has officially announced the release of GPT-5.6. Worth noting: many details in this article — including pricing and model names — are drawn from rumors and personal speculation, and the official documentation should be treated as the final authority.

Unlike previous single-model releases, the biggest change with GPT-5.6 is that it's not one model — it's a combination of three models named Sol (Sun), Terra (Earth), and Luna (Moon). This celestial naming scheme implies a gradient of capability and positioning: Sol as the flagship, Terra for everyday use, and Luna for lightweight tasks.

This multi-model architecture reflects a broader trend among large model vendors: rather than chasing a "one model to rule them all" approach, they're using differentiated tiers so users can match compute to task complexity, balancing performance against cost. In fact, Anthropic's Claude series (Haiku/Sonnet/Opus) and Google's Gemini series (Flash/Pro/Ultra) have already adopted similar designs.

The core engineering logic behind this architecture is Model Distillation. Distillation was systematically introduced by Geoffrey Hinton et al. in their 2015 paper Distilling the Knowledge in a Neural Network. The key insight is that the probability distribution of a neural network's output layer — not just the final one-hot label — contains rich implicit information about inter-class relationships. For example, in a handwritten digit recognition task, a teacher model's prediction for "7" tends to assign higher probabilities to "1" and "9" than to other digits. These subtle probability differences encode the structural knowledge that "7 resembles 1 and 9" — what Hinton calls Dark Knowledge.

In the LLM era, distillation has evolved into multiple forms: Sequence-Level KD, Feature-Level KD, and RLHF-based preference distillation. The basic idea is to train a smaller "Student Model" using soft labels or intermediate features generated by a larger "Teacher Model." Compared to training a small model from scratch, a distilled student model can absorb the teacher's dark knowledge — the inter-class similarity information encoded in probability distributions — maintaining strong performance despite a dramatically reduced parameter count. In LLMs, distillation is typically combined with RLHF and synthetic data generation: the flagship model generates large volumes of high-quality reasoning traces and answers, which are then used as supervised signals to fine-tune the smaller model. This is the technical foundation that allows Terra to deliver near-flagship capability at 50% of the price — it's essentially a highly efficient compressed version standing on Sol's shoulders.

Reasoning Effort: New Max and Ultra Tiers Added

Beyond the expanded model count, GPT-5.6 also extends the Reasoning Effort dimension. The existing four tiers — Low, Medium, High, and X-High — are retained, with two new tiers, Max and Ultra, added on top.

Reasoning Effort is essentially a parameter that controls the depth of the model's Chain of Thought (CoT). CoT reasoning was formally introduced by Wei et al. in their 2022 paper Chain-of-Thought Prompting Elicits Reasoning in Large Language Models, with the core finding that having a model output intermediate reasoning steps before its final answer significantly improves accuracy on complex math and logic problems. Notably, the researchers also identified a critical "emergent ability" threshold: CoT reasoning only emerges spontaneously in models exceeding roughly 100B parameters — smaller models see almost no benefit even with identical prompting formats. This partly explains why you need a powerful flagship model first, then distill its reasoning ability into lighter models.

OpenAI's o-series models (starting with o1) internalized this idea as a training objective, using reinforcement learning to teach the model when to reason deeply and when to respond quickly — enabling dynamic allocation of a reasoning budget. This is fundamentally different from early "fixed-step CoT prompting" and gives rise to the Thinking Tokens mechanism: before replying, the model performs extensive internal reasoning that's invisible to the user but consumes real compute. The Reasoning Effort parameter is essentially a knob controlling this internal reasoning budget. Higher tiers allow the model to consume more thinking tokens, boosting performance on tasks like long mathematical proofs or multi-step debugging — but latency and token costs grow linearly or even super-linearly per request.

The addition of Max and Ultra means developers now have a larger "compute dial" to turn for extremely complex reasoning tasks, and signals that OpenAI is opening up extreme-compute reasoning as a standalone product dimension.

This isn't speculation without basis. According to DP's research, Codex CLI version 0.143.0 on the official GitHub explicitly references the three GPT-5.6 models and a Max reasoning tier. Separately, an article indicates Ultra mode will appear in Codex. A screenshot purportedly from Codex shows the combination "5.6 + Sol + Ultra," corroborating these leads.

For developers, higher reasoning effort means the model can invest more compute in complex reasoning tasks — but it comes with higher latency and cost, requiring careful tradeoffs based on actual use cases.

Pricing Strategy: Effectively Half Price, with Cache Write Cost Increases

Pricing is the most closely watched part of this update. Using GPT-5.5 as the baseline (roughly $5 input / $30 output), the three GPT-5.6 models present a clear pricing gradient:

• Sol: Identical to 5.5, approximately $5/$30 — the flagship
• Terra: Roughly half of Sol, ~$2.5/$15
• Luna: Roughly 17% of Sol, ~$1/$6 — optimized for lightweight tasks

There's a key insight here: Terra reportedly delivers performance close to GPT-5.5 at half the price. If true, this effectively gives the primary model a 50% discount — users get performance comparable to the old flagship at half the cost, which is extremely attractive for cost-sensitive developers.

However, DP flags a detail that's easy to overlook: Cache Write pricing has increased from 100% to 125% compared to GPT-5.5 — for Sol, that's a jump from $5 to $6.25.

To understand the impact of this change, it helps to understand how Prompt Caching works under the hood. The KV Cache (Key-Value Cache) is a core engineering optimization in the Transformer architecture that addresses inference efficiency bottlenecks. In standard self-attention, generating each new token requires recomputing the Key and Value matrices for all previous tokens, with complexity growing quadratically with sequence length. KV caching persists these intermediate results, reducing incremental generation complexity to linear. In cloud services, cross-request Prompt Caching extends this optimization beyond session boundaries — when users repeatedly send requests with the same prefix (e.g., a System Prompt), the server can persist the KV matrices so subsequent requests read from cache (a "cache hit") at roughly a 50% discount. It's worth noting that the cache write price increase also reflects a real engineering pressure: in new models supporting ultra-long contexts (e.g., 128K tokens), a single cache write can consume tens of times more storage than in earlier models, significantly raising server-side storage and memory management costs.

Cache writes refer to the overhead of initially writing prefix content into cache storage, involving additional storage operations and memory usage. In Agentic workflows, System Prompts often contain large amounts of tool definitions, role descriptions, and task context, making individual write operations very large. And in each iteration of an Agent loop, as conversation history grows, cache writes are continuously triggered. The increase from 100% to 125% therefore has a far more significant cost impact on Agent developers and high-frequency API users than on typical conversational use cases — which is precisely the usage pattern most common among heavy API users. Other items such as cache reads remain unchanged. For workflows with frequent cache writes, this change still warrants careful cost accounting.

Use Case Predictions and Codex Integration

The tiered pricing naturally suggests clear use cases for each model. The following are DP's personal predictions for reference only.

Sol: The Flagship for Heavy-Duty Tasks

Sol is priced at 100% of GPT-5.5 and is suited for framework-level architecture design, security audits, and difficult problems that are hard to crack. These tasks demand the highest accuracy and justify investing top-tier compute.

Terra: The Cost-Effective Workhorse for Everyday Development

Terra covers everyday development tasks at 50% of the cost, making it the optimal choice for most scenarios. Its positioning is essentially "GPT-5.5 capability powered by GPT-5.6 technology, at half the price." This directly reflects the growing maturity of model distillation — when the distillation pipeline is refined enough, student models can even surpass earlier versions of their teacher models on specific tasks, rather than merely "approaching" them.

Luna: Purpose-Built for Lightweight and Batch Tasks

Luna handles lightweight tasks at roughly 17% of Sol's cost — think running tests with a Subagent or other high-frequency, low-complexity workloads — significantly reducing overall API call costs.

On Codex integration: a screenshot purportedly from the top-tier Pro version shows a comprehensive model list running from GPT-5.3 Codex and 5.4 Mini through 5.4 and 5.5, all the way to the three GPT-5.6 models (Sol, Terra, Luna). Models starting from 5.4 carry a Fast tag and can enable Fast mode. In the screenshot, GPT-5.6 Sol shows Ultra as an option alongside Low/Medium/High/X-High, again confirming predictions that Ultra will be available in Codex.

The Compute Question: A Hidden Concern Behind the Performance Praise

Amid the excitement over pricing and performance, there's one practical issue that can't be ignored — the stability of compute supply. According to DP, GPT-5.5 was "nearly unusable" for stretches due to compute constraints and degraded performance, with many users halting work specifically to wait for 5.6.

There's a clear fork in the road here: if compute holds up after GPT-5.6 launches, the combination of lower prices and stronger performance will almost certainly generate glowing reviews. But if compute constraints and performance degradation recur, even the best model can't deliver its value. DP admits there's no way to know whether compute will recover, or when the next crunch might arrive.

It's worth noting that the three-model architecture does help ease compute pressure to some extent — by directing low-complexity requests to Luna and medium-complexity requests to Terra, Sol's compute resources can be concentrated on tasks that genuinely need flagship capability. This demand-side load balancing is itself part of the engineering value of a multi-tier architecture, though its ultimate effectiveness still depends on the total supply capacity of the underlying GPU cluster.

Evaluating a large model can't stop at price and performance numbers on paper. The stability of the actual service is equally critical to real-world productivity. For teams relying on the API for critical work, the risk posed by compute volatility should not be underestimated.

Summary

All in all, GPT-5.6's core value proposition can be summed up as "better performance at lower prices." The Sol/Terra/Luna three-model architecture, combined with the new Max and Ultra reasoning tiers, provides finer-grained options for different tasks. Terra's "effectively half-price" strategy is especially noteworthy — it's a direct reflection of the maturing distillation pipeline. From Hinton's 2015 introduction of the "dark knowledge" concept, to today's ability to efficiently compress the reasoning capability of hundred-billion-parameter flagship models and bring it to market at scale, advances in distillation engineering are reshaping the cost structure of large language models.

That said, a clear-eyed view is warranted: much of the information in this article is drawn from rumors and personal speculation — treat the official documentation as the final word. The cache write price increase (with its outsized impact on Agentic workflows in particular) and, most critically, compute stability are all factors to weigh carefully before committing to production use. No matter how capable a model is, it needs sufficient and stable compute behind it to translate into real productivity.