GPT 5.6 Three-Version Benchmark: What Makes Sol, Terra, and Luna Worth the Price Difference?

GPT 5.6: The Pricing Logic Behind Three Tiers

GPT 5.6 launched three versions at once — think of them as three siblings, each targeting a different price point and use case:

• Sol (Flagship): The most expensive and most capable. Input at $5, output at $30 per million tokens.
• Terra (Balanced): Priced at exactly half — $2.5 input, $15 output. OpenAI officially describes it as striking "a balance between capability and cost."
• Luna (Lightweight): The budget option — $1 input, $6 output, roughly one-fifth the cost of Sol.

Tokens and Pricing Mechanics: A token is the basic unit of text measurement for large language models. In English, one token is roughly 4 characters; in Chinese, one character typically equals 1–2 tokens. "Per million tokens" is the industry-standard billing unit, with input (prompt) and output (completion) billed separately. Sol's 6× gap between input ($5) and output ($30) directly reflects the cost structure of model inference: autoregressive generation requires a full forward pass per token, while input only needs a single encoding pass.

OpenAI's three-tier strategy isn't new — it's the standard playbook for LLM commercialization. Anthropic's Claude lineup (Haiku/Sonnet/Opus) and Google's Gemini series (Flash/Pro/Ultra) follow the same pattern. Running three tiers simultaneously also serves a subtler purpose: price anchoring makes the middle tier look like the obvious value pick, nudging users toward the balanced option rather than defaulting to the cheapest.

Pricing itself is a signal: a cheaper version must sacrifice something. The real question is — how much? Terra claims near-flagship capability at half the price, but how does it actually hold up in testing? Luna costs one-fifth as much — does engineering completeness take a proportional hit?

Evaluation Method and Overall Scores

This benchmark used a unified "forum community site" project spec, with 108 checks across three modules:

• Backend API and full stack: 65 points
• Frontend pages and real interactions: 25 points
• Build and packaging: 10 points

The core principle: this isn't about whether the code looks right — it's about real clicks, packet capture, state read-back, and full three-platform build artifacts, testing whether the project can actually be delivered.

Why This Method Is Closer to Engineering Reality: Traditional AI benchmarks (like HumanEval or MBPP) primarily assess whether code passes unit tests — not whether a product can actually ship. "Packet capture" here means intercepting HTTP requests via developer tools or a proxy to verify whether frontend controls trigger the correct API calls. "State read-back" checks whether like/bookmark interactions remain consistent between frontend and backend. "Three-platform packaging" covers the completeness of Web, iOS, and Android build artifacts. This approach surfaces "code that looks right but doesn't run" — exactly the kind of hidden engineering risk that pure text similarity scoring can't detect.

Overall scores: Sol leads with 83.95, GLM 5.2 follows at 76.59, Terra comes in third at 75.97 (just 0.62 below GLM), and Luna trails at 68.56.

This piece focuses on Terra and Luna — Sol and GLM were covered in depth in the previous installment.

Luna in Testing: $1 Gets You a Skeleton, Frontend Is Basically Unusable

Let's start with the cheapest option. Luna costs just $1.03 per million tokens — the lowest in the field — and its scorecard is equally blunt.

Backend: 53.74 points — The overall framework is in place and major APIs are present, but pagination and thread-ordering issues are notable. Reply ordering is unstable; like, bookmark, and report state logic has errors; after canceling a like, the state often fails to correctly restore when propagated across the full stack. This is "features exist, but details don't hold up" territory.

Frontend: 7.32 points — This is the biggest weakness. Across notification lists, post creation pages, forum detail views, thread detail pages, and more, the test framework couldn't locate like, bookmark, reply, or follow controls. Real clicks frequently failed to trigger the correct network requests.

To be clear: this isn't a "page looks ugly" problem. It's that clicking something gives you no indication of what, if anything, happened. Packaging also didn't fully pass — only a subset of three-platform build artifacts were produced.

Luna's positioning is therefore crystal clear: $1 gets you a project skeleton, but the frontend is basically non-functional. It's cheap enough for rapid prototype validation; but to deliver something users can actually click through and use, you'll need to move up a tier.

Terra in Testing: Backend Ties the Flagship, Gap Hides in Delivery Completeness

The most surprising finding in this benchmark came from Terra. Its backend score: 56.88 points. The flagship Sol's backend score: also 56.88 points — an exact tie.

Terra is priced at half of Sol, yet its core backend capability shows zero degradation. OpenAI's claim of "balancing capability and cost" turns out — at least on the backend dimension — to mean not a lite version, but a full one: writing endpoints, handling permissions, executing business logic — Terra is on par with the flagship.

Yet Terra's total score is nearly 8 points below Sol. Where does that gap come from? The answer lies in frontend interaction and build packaging. Terra's backend is equally strong, but it clearly drops a tier when it comes to frontend rendering and three-platform packaging.

Why Frontend and Backend Capability Can Diverge: Backend API code (REST endpoints, auth checks, business logic) is highly structured with repetitive patterns and well-represented in training data — mid-size models can reproduce it with high quality. Frontend interaction code, on the other hand, involves DOM event binding, cross-component state management, async request chains, and multi-layer coupling, all of which demand stronger contextual consistency. Cross-platform packaging (e.g., three-platform compilation with React Native or Flutter) also requires handling platform-specific configurations with longer error chains. This explains why "balancing capability and cost" in practice often means: compressing the higher-complexity integration and delivery capabilities, rather than the core logic generation.

Buying Guide: Pay for Engineering Delivery Completeness

Three takeaways that summarize the real differences across the GPT 5.6 lineup:

1. No meaningful gap at the backend level: Sol and Terra tie exactly, and both are edged out by GLM. If your only question is "can the model write backend code?" — the two are essentially equivalent.
2. Frontend interaction and packaging are where the real gap emerges: Sol is the only version that closes the full loop from frontend to packaging. That's the true source of its premium. Terra is strong on backend but falls behind on frontend and build output. Luna's frontend is essentially non-functional.
3. Choose based on your needs: Need full engineering delivery? Go Sol. Prioritizing backend value-for-money? Terra is the pick. Just need a fast prototype scaffold? Luna is fine.

The practical insight from this benchmark: the price gap between models increasingly shows up in "engineering delivery completeness" rather than "code quality itself."

Why "Engineering Delivery Completeness" Matters for the Industry: This concept refers to a model's ability to complete the full chain from requirements to a runnable product — including frontend-backend coordination, state management, build packaging, and more. This dimension is becoming the core competitive moat for AI coding tools. The rise of tools like Devin and Cursor is fundamentally about reinforcing this end-to-end loop. For enterprise buyers, the gap between "benchmark scores" and "delivery success rates" is generating a new class of demand: not just code completion, but end-to-end software engineering agents. Sol's premium in this benchmark illustrates the trend precisely — flagship pricing isn't protecting the ability to "write a few lines of code." It's protecting the systemic engineering capability to "get the project running."

Every model can write backend code these days. But whether you can actually click through the UI, capture clean network traffic, and produce three-platform build artifacts — that's the true source of flagship-tier pricing. For developers, selection decisions shouldn't rely on benchmark scores alone. Ask the harder question: how far can this model actually take the product toward delivery?

Key Takeaways