GPT-5.6 Is Here: Sol, Terra, and Luna

-->

GPT-5.6 Is Here: Sol, Terra, and Luna Pricing & Benchmarks

India's Most Futuristic AI Conference Is Back – Bigger, Sharper, Bolder

d

:

h

:

m

:

s

Career

GenAI

Prompt Engg

ChatGPT

LLM

Langchain

RAG

AI Agents

Machine Learning

Deep Learning

GenAI Tools

LLMOps

Python

NLP

SQL

AIML Projects

Reading list

How to Become a Data Analyst in 2025: A Complete RoadMap

A Comprehensive Learning Path to Tableau in 2025

A Comprehensive NLP Learning Path 2025

Learning Path to Become a Data Scientist in 2025

Step-by-Step Roadmap to Become a Data Engineer in 2025

A Comprehensive MLOps Learning Path: 2025 Edition

Roadmap to Become an AI Engineer in 2025

A Comprehensive Learning Path to Master Computer Vision in 2025

Best Roadmap to Learn Generative AI in 2025

GenAI Roadmap for Enterprises

Large Language Models Demystified: A Beginner’s Roadmap

Learning Path to Become a Prompt Engineering Specialist

GPT-5.6 Is Here: Sol, Terra, and Luna

Vasu Deo Sankrityayan Last Updated : 10 Jul, 2026

10 min read

For twelve days, the best AI models on the planet existed and almost nobody could touch them.

That ends now! GPT-5.6 Sol, Terra, and Luna go public today! The models are accessible by all users (no subscription required)

This is the full breakdown of what’s on offer: three models, four prices, one precedent, and a capability table that should help you select the right model. Hands-on results follow the moment access opens.

Table of contents

One Generation, Three Models

Pricing: Four Ways to Pay

Capabilities: Max Effort, Ultra Mode, and a Sleeper Hit

The Capability Nobody Expected in the Budget Tier

Five Layers Deep: The Safeguard Stack

The Family vs GPT-5.5 at a Glance

Hands-On: Eight Tests, One Rule

Test 1: Defender’s Audit (Sol, the cyber claim’s legitimate half)

Test 2: The Root-Cause Hunt  (Sol, Terminal-Bench claim)

Test 3: GPT 5.5 Sol vs GPT-5.5, Coding

Test 4: The GPT 5.6 Stress Test (the Sol sleeper claim)

Test 5: The Contradiction Trap  (Sol, High reasoning claim)

The Bottom Line

Frequently Asked Questions

One Generation, Three Models

GPT-5.6 retires OpenAI’s naming chaos for good. The number marks the generation. This makes it easy to classify, so the next Luna improvement won’t force a whole-family rename.

Sol is the flagship, built for the hardest 10 percent of work: long-horizon coding agents, security research, deep scientific analysis. The new reasoning controls live here.

Terra is the workhorse and the obvious migration target. GPT-5.5-class quality at half the price, aimed at production volume: support, internal tools, document pipelines.

Luna is the speed tier, and quietly the sleeper of the launch. The cheapest model in the family lands near GPT-5.5 on several tests. More on why that matters below.

gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna are their respective names in the API. This might seem like a small change on paper. But it’s a big one for any coder who has tried keeping track of o3, o4-mini, GPT-4 Turbo, and 4o all at once.

Pricing: Four Ways to Pay

Three models, but four prices, because launch week surfaced a wrinkle.

Model Input / 1M tokens Output / 1M tokens Positioning

Sol $5 $30 Flagship, deepest reasoning

Sol Fast $12.50 $75 Same model at up to 750 tokens/sec

Terra $2.50 $15 GPT-5.5 class at half the cost

Luna $1 $6 Fast, high-volume workloads

Sol Fast is the new shape here: the same flagship brain served from Cerebras hardware at up to 750 tokens per second, for 2.5x the standard rate. Speed as an explicit paid tier, rather than a queue lottery, is something OpenAI has never sold before. If your product is latency-bound, this line item alone changes what’s viable.

The quieter pricing story is caching, and agent builders should care more about it than the headline rates:

Explicit cache breakpoints, so you control what gets cached instead of guessing

A 30-minute minimum cache life

Cache writes billed at 1.25x the uncached input rate

Cache reads keep the 90% discount

For long-running agents that re-read the same context hundreds of times, that discount compounds into an order-of-magnitude cut on input costs. Structure your prompts now: stable context before the breakpoint, volatile input after.

Capabilities: Max Effort, Ultra Mode, and a Sleeper Hit

OpenAI is holding the expanded evaluation suite for the GA system card, but the preview numbers already sketch the picture. Two new controls headline Sol:

Max reasoning effort, a new ceiling that gives Sol the most time to think through a problem.

Ultra mode, which goes past the single-agent paradigm entirely. Sol spins up subagents and coordinates them to parallelize complex work.

On benchmarks, the standout claims:

Terminal-Bench 2.1: Sol sets a new state of the art on command-line workflows demanding planning, iteration, and tool coordination.

GeneBench v1: Sol beats GPT-5.5 on long-horizon genomics and quantitative biology analyses, using fewer tokens to do it.

ExploitBench: Sol is competitive with Mythos Preview at roughly a third of the output tokens.

The family effect: Sol and Terra set new highs across the board, while Luna performs near GPT-5.5 on several tests despite being the cheapest thing on the price sheet.

That last bullet point is the sleeper. Last generation’s flagship quality is now available at $1 per million input tokens. The pattern across the whole family isn’t just “smarter,” it’s smarter per token and per dollar. Efficiency is the actual headline.

The Capability Nobody Expected in the Budget Tier

Here’s the system card detail that got buried under the availability drama, and it deserves its own section.

All three models, not just Sol, are classified at OpenAI’s “High” risk level for cyber and biological capability. On internal capture-the-flag security testing:

Internal CTF results across the family

To give you a perspective, these models are on part with the Mythos “Fable 5” category of Claude.

“GPT‑5.6 Sol is better at helping people find and fix vulnerabilities than reliably carrying out end‑to‑end attacks.”

— OpenAI

That’s the company’s own framing, and the strategy follows: get the capability into defenders’ hands, make offensive misuse difficult, uncertain, and detectable.

Five Layers Deep: The Safeguard Stack

The safety architecture shipping with 5.6 is the most elaborate OpenAI has described publicly, with configurations matched to each tier’s capability. The design assumption is blunt: no single safeguard survives a determined, adaptive attacker.

Here is how the process went:

Trained refusals. The model itself declines prohibited cyber assistance, including disguised or jailbroken requests.

Real-time classifiers. Cyber and bio misuse detectors evaluate output as it generates.

Reasoning-model review. High-risk generations pause mid-stream while a larger model reviews the full context. Disallowed output never reaches the user.

Account-level signals. Flagged activity triggers review across conversations, which is how OpenAI distinguishes a security researcher from a persistent bad actor.

Differentiated access and rapid response. The most sensitive capabilities are not on by default, and newly discovered jailbreaks feed a reproduce-assess-patch loop.

One caveat that I’ve recognized while testing the models is that sometimes legitimate work sometimes gets blocked or slowed, especially in the type of prompt which are in the grey area (nothing fishy but non benign either).

The Family vs GPT-5.5 at a Glance

GPT-5.5 GPT-5.6 Family

Structure Single flagship Three durable tiers: Sol, Terra, Luna

Reasoning controls Standard effort levels New max ceiling; ultra mode with subagents (Sol)

Coding Strong State of the art on Terminal-Bench 2.1 (Sol)

Biology Baseline Beats 5.5 on GeneBench with fewer tokens (Sol)

Cybersecurity Capable All three tiers at High classification

Cost floor Flagship pricing only GPT-5.5-class quality from $1/$6 (Luna)

Speed option Shared infrastructure Sol Fast: 750 tok/s as a paid tier

Caching Standard Explicit breakpoints, 30-min minimum life

Release path Standard launch Government-reviewed, Commerce-approved

Hands-On: Eight Tests, One Rule

Specs are promises. Usage is proof.

Every test below targets a specific claim from OpenAI’s announcements.

Test 1: Defender’s Audit (Sol, the cyber claim’s legitimate half)

Prompt: “OWASP Juice Shop is a deliberately vulnerable web app used for security training. Based on its well-documented authentication and payment flows, rank the top five vulnerability classes it’s known for by severity, explain each in plain language, and write a patch (with code) for the most severe one.”

Response:

Strong response! The ranking is impact-based rather than a copy of Juice Shop’s star ratings, and the patch is the correct fix: replacing the interpolated sequelize.query with UserModel.findOne({ where: ... }) so email and password become bound values, with paranoid: true preserving the original deletedAt IS NULL behavior. Best part is the honest scoping, since it refuses to claim the auth flow is now production safe and calls out the unsalted MD5 in security.hash(). Main gripes: leaving XSS out of the top five is odd given that’s arguably what Juice Shop is most known for, and rank 4 is a slightly invented merged category rather than a standard class.

Test 2: The Root-Cause Hunt (Sol, Terminal-Bench claim)

Prompt: “This file has three sections: a pricing utility, a checkout function that calls it, and a test. Running it fails, and the error message suggests the test’s expected value is wrong. Find the actual root cause, fix it at the source (not the test), and explain in one paragraph why the error message was misleading. Do not just make the test pass.”

Click here to view the Python File

============================================================

billing_bug.py — self-contained failing test bundle

Run: python billing_bug.py

One bug spans all three sections. The traceback points at

the TEST, but the test is correct. Find the real root cause.

============================================================

---------- FILE 1 of 3: pricing.py ----------

Utility that normalizes a discount into a multiplier.

def normalize_discount(discount): """ Convert a discount into a price multiplier. A 20% discount should leave the customer paying 80% (0.80). Accepts either a percentage (20) or a fraction (0.20). """ if discount > 1:

treat as a percentage, e.g. 20 -> 0.20

discount = discount / 100

return the multiplier to apply to the price

return 1 - discount

---------- FILE 2 of 3: checkout.py ----------

Caller that applies the discount to a cart total.

def final_price(cart_total, discount): """ Apply a discount to a cart total and round to 2 decimals. Caller assumes normalize_discount returns the FRACTION to subtract (e.g. 0.20), not the multiplier to keep (0.80). """ fraction_off = normalize_discount(discount) price = cart_total - (cart_total * fraction_off) return round(price, 2)

---------- FILE 3 of 3: test_checkout.py ----------

The test is CORRECT. A $100 cart with 20% off should be $80.00.

def test_twenty_percent_off(): result = final_price(100, 20) expected = 80.00 assert result == expected, ( f"test_checkout.py: expected {expected}, got {result} " f"-- check the test's expected value" # <-- misleading hint )

if name == "main": test_twenty_percent_off() print("PASSED")

Amazing! Not just that it was able to find the right bug, but to do that and give the resolution in such a succinct manner. Models as used to wordiness in their responses. GPT 5.6 is a breath of fresh air I this regard.

Test 3: GPT 5.5 Sol vs GPT-5.5, Coding

Prompt: “Refactor this function for readability and correctness without changing its behavior. Then list any edge cases it mishandles.”

def p(d): r=[] for i in d: if i!=None and i not in r: r.append(i) return sorted(r) if all(typ

[truncated for AI cost control]