GPT-5.6 Three-Model Deep Dive: Sol, Terra, and Luna Benchmarked and Compared

OpenAI Launches the GPT-5.6 Model Family

On June 26, OpenAI officially previewed the GPT-5.6 series — and this time, it's not a single model. Instead, they're launching three products with distinct positioning simultaneously: the flagship Sol, the balanced everyday workhorse Terra, and the fast, affordable Luna.

The naming logic is worth noting. OpenAI explicitly states that the number (5.6) represents the generation, while Sol, Terra, and Luna are "durable capability tiers" that can evolve independently at their own pace. This naming system is intended to stick around for the long haul.

Defining Sol/Terra/Luna as "durable capability tiers" rather than version numbers is essentially the construction of a brand architecture akin to the semiconductor industry's "product line" model: different tiers target users with different price sensitivities and performance needs, and each can iterate without being tied to the others. This is structurally identical to Anthropic's Haiku/Sonnet/Opus tiers and Google's Gemini Flash/Pro/Ultra lineup — the industry is converging on a shared "flagship-balanced-economy" three-tier market segmentation consensus. Using a numeric generation (5.6) avoids forcing users to re-evaluate the entire product line every time one tier is updated, while also leaving room for future sub-brand premium pricing. This tiering strategy has already proven effective in the chip industry (e.g., Intel Core i3/i5/i7, Qualcomm Snapdragon 7/8 series) as a tool for maximizing market coverage across different consumer segments while maintaining brand cohesion.

Currently, the series is available only as a limited preview to select partners via the API and Codex. General availability (GA) is expected within the coming weeks. This article analyzes the complete benchmark results from an evaluator who received early access to all three models.

Worth Noting: What the Phased Release Signals

Before the public announcement, OpenAI previewed the models' capabilities to the U.S. government, which requested a "phased release" — a first in OpenAI's product history. This suggests that these models have reached a notably sensitive level of capability, particularly in the cybersecurity domain.

This reflects the evolving landscape of AI safety governance. Government scrutiny of AI models is becoming increasingly institutionalized in the U.S. — NIST's AI Risk Management Framework (AI RMF), published in 2023, and a Biden-era executive order both require that high-capability models submit safety reports to relevant agencies before public release. In cybersecurity, models capable of autonomously discovering vulnerabilities or generating functional exploits are classified as high-risk capabilities, requiring stricter access controls. Notably, this "government-first preview" mechanism closely mirrors the dual-use research oversight logic applied to nuclear and biotechnology sectors — when a technology carries both civilian value and potential for weaponization, government evaluation typically precedes public release. The phased rollout is not just a regulatory compliance measure; it's also a strategic move by OpenAI to proactively build policy-level trust and credibility.

GPT-5.6 Capability Claims and Pricing Strategy

OpenAI is touting several state-of-the-art (SOTA) results for GPT-5.6:

• Terminal Bench 2.1: Tests planning, iteration, and tool coordination in command-line workflows — claimed to be best-in-class
• GeneBench: Strong performance on long-horizon biology tasks
• ExploitBench: Sol performs on par with Anthropic's Mythos Preview while consuming roughly one-third the output tokens

Terminal Bench and ExploitBench are emerging AI capability benchmarks designed to measure model performance in real-world engineering and security scenarios, rather than traditional knowledge Q&A or reasoning puzzles. ExploitBench requires models to autonomously understand target system vulnerabilities and generate executable attack chains — a fundamentally different challenge from earlier evaluations that only tested whether a model could identify a vulnerability type. The latter tests knowledge recall; the former tests real-world attack planning ability, encompassing full penetration testing workflows including reconnaissance, exploitation, and privilege escalation. The token efficiency metric (Sol using only one-third the output tokens of Mythos) is critical in security contexts: fewer reasoning steps mean lower latency and cost, and signal that the model has a more precise internal understanding of the problem rather than relying on brute-force path enumeration. In real-time scenarios like automated penetration testing, token efficiency is a direct determinant of practical usability.

OpenAI also introduced a max reasoning effort option and an ultra mode capable of spawning sub-agents for complex tasks.

Pricing: Notably Competitive

The pricing strategy is quite developer-friendly (per million tokens):

Model	Input	Output
Sol	$5	$30
Terra	$2.50	$15
Luna	$1	$6

OpenAI claims Terra delivers GPT-5.5-level capability at half the price. They've also improved the prompt caching mechanism with explicit cache breakpoints and a 30-minute minimum cache lifetime, and plan to deploy Sol on the Cerebras platform in July at speeds of up to 750 tokens/second. The improvements on both cost and speed fronts are substantial.

Prompt caching works by reusing KV (Key-Value) cache from identical prefixes to reduce redundant computation. In Transformer architectures, computing attention for each token requires accessing the Key and Value matrices of all preceding tokens. For fixed prefixes like system instructions and tool definitions, recomputing from scratch on every request wastes enormous compute. In long-context scenarios or multi-turn conversations, such fixed content can account for 30–70% of total tokens. OpenAI's new "explicit cache breakpoints" mean developers can manually specify cache boundaries rather than relying on automatic detection — this is especially valuable for cost control in RAG (Retrieval-Augmented Generation) systems and multi-turn agentic tasks. Developers can set lengthy knowledge base documents as a fixed cached prefix and only pay for the user query portion. The 30-minute minimum cache lifetime ensures cache validity within continuous workflows, preventing extra costs from cache expiration during back-to-back tasks.

It's worth highlighting that the 750 tokens/second inference speed comes from Cerebras's Wafer-Scale Engine (WSE) architecture. Unlike traditional GPU clusters, Cerebras uses an entire silicon wafer as a single processor, eliminating inter-chip communication bottlenecks and boosting memory bandwidth by orders of magnitude. This compresses inference latency from seconds to milliseconds — decisive for agentic applications requiring real-time responsiveness, such as code execution loops and multi-turn tool calls. OpenAI's choice to partner with Cerebras for Sol deployment also signals that leading AI vendors are actively exploring differentiated compute paths beyond GPUs at the inference infrastructure layer.

Benchmark Results: Breaking Down the Scores

The evaluator tested all three models using their custom KingBench 3 suite, covering frontend tasks, Three.js, SVG generation, high-difficulty math problems, and a long-horizon agentic task (requiring the model to autonomously generate a dataset, fine-tune a Gemma model locally, and build an accompanying Web UI).

Final Scores (out of 70):

• Sol: 55 points (78.6%)
• Terra: 44 points (62.9%)
• Luna: 31 points (44.3%)

Agentic Task: All Three Models Score Perfectly

Looking only at total scores risks underestimating the true capability of this model family. The subsection data tells a more compelling story:

• On high-difficulty math problems, both Sol and Terra scored a perfect 10/10 — a question that very few models can answer completely.
• On the agentic fine-tuning task, all three models scored a perfect 10/10. Even the cheapest model, Luna, completed the full pipeline: dataset generation, model fine-tuning, and Web UI construction.

This agentic fine-tuning task is arguably the ultimate test of integrated capability. The model must sequentially complete dataset construction (including data cleaning and formatting), invoke a local fine-tuning framework (such as LoRA/QLoRA for parameter-efficient fine-tuning of Gemma), and build an interactive Web UI — a workflow involving cross-tool invocation, multi-step planning, and self-correction on errors. LoRA (Low-Rank Adaptation) is a parameter-efficient fine-tuning technique that injects trainable low-rank decomposition matrices alongside the original weight matrices, achieving model specialization with a minimal number of trainable parameters, and is currently the dominant approach for local fine-tuning. GPT-5.5 and Opus 4.7 could only score 2–3 points on this task, fundamentally because it requires the model to maintain long-range contextual consistency throughout execution and re-plan when local failures occur — not just generate code. All three GPT-5.6 models scoring perfectly indicates a structural breakthrough in the stability of their "agentic loop": these models don't just generate code — they perceive execution results, identify errors, and autonomously retry. This is fundamentally different from simple single-step code completion.

For reference, GPT-5.5 and Opus 4.7 previously scored only 2–3 points on this same task, while GPT-5.6 matches the top-tier Fable 5. This demonstrates that for long-horizon, backend, and agentic tasks, this model family has reached a genuinely high level of capability.

Frontend Tasks: Still OpenAI's Weak Spot

Lost points were concentrated in frontend and visual tasks. On tests like the Three.js contact lens case, folding table animation, and SVG panda, Sol scored only 6–7 points, while Fable 5 consistently lands 9–10.

Three.js is a WebGL-based 3D rendering library that requires models to not only generate syntactically correct JavaScript code, but also understand the combined logic of 3D coordinate systems, material and lighting systems, and animation timelines — tasks with extremely high demands on spatial reasoning and multi-system coordination programming. SVG generation similarly tests precise control over coordinate transforms, Bézier curves, and layer compositing — not simple text output. The fundamental reason frontend tasks are a weak point for most LLMs is that visual correctness (pixel-level correctness) lacks a clear text-based loss signal: a Three.js snippet that runs successfully may be completely wrong visually, and this kind of error is difficult for automated scoring systems to catch during the reinforcement learning phase of training. Backend code, by contrast, has explicit unit test outputs as verification signals, making reinforcement signals much cleaner and allowing models to learn from failures more effectively. This structural difference explains why most top models consistently lag on frontend visual tasks compared to their backend capabilities. Some frontier research is exploring the use of visual rendering screenshots as RL reward signals (having the model "see" the rendered output of its generated code), but this direction remains in early exploration and has yet to be deployed at scale in mainstream commercial models.

The evaluator noted that their benchmark suite is heavily weighted toward frontend and visual tasks, which pulled down GPT-5.6's total score somewhat. It's not that the models are weak overall — frontend simply remains a non-strength for OpenAI, and this benchmark weights it heavily.

Head-to-Head: Where GPT-5.6 Sits in the Rankings

On the evaluator's model leaderboard, current scores are as follows:

• Fable 5: 88.57% (top spot)
• Opus 4.8: 87.14%
• GLM 5.2: 81.43%
• Sol: 78.57%

Worth calling out separately: the previous generation GPT-5.5 scored only 38.57%. Sol has essentially doubled the previous generation's score — by any measure, that's a significant generational leap.

Evaluation Verdict: A Strong Increment, Not a Paradigm Shift

The evaluator offered several core takeaways:

First, this is an incremental improvement over GPT-5.5, not a new paradigm. A very impressive increment, but an increment nonetheless. The Sol/Terra/Luna naming is "heavy on marketing" — the evaluator believes this is partly a response to Anthropic positioning Fable as a "new species," with OpenAI wanting this release to feel like "something entirely new." But from a practical capability standpoint, this is the natural next step from 5.5: stronger and cheaper.

Second, has Sol reached Fable-level? Not quite. Fable still holds the overall crown and leads on the majority of subtests, but Sol is very close and even surpasses Fable in some scenarios. Its token efficiency on cybersecurity and agentic benchmarks is particularly impressive, and it ties Fable outright on the agentic task. Fable's biggest drawback, by comparison, is its high price. Sol — and the even cheaper Terra and Luna — offer nearly unbeatable value for money within their respective capability tiers.

GPT-5.6 Model Selection Guide

• Frontend-intensive work: Fable 5 or Opus 4.8 remain the first choice
• Backend, agentic, and long-horizon tasks: Sol is an excellent option at significantly lower cost
• Budget-constrained agentic use cases: Luna ($1/million input tokens) may be the most cost-effective low-price agentic model available right now

One caveat: these conclusions are all based on a preview version and may change before general availability. Overall, this is a solid release — not the paradigm revolution the marketing suggests, but a strong incremental upgrade with competitive pricing that substantially closes the gap with Fable.