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.

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.

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:

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

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:

1. Trained refusals. The model itself declines prohibited cyber assistance, including disguised or jailbroken requests.
2. Real-time classifiers. Cyber and bio misuse detectors evaluate output as it generates.
3. Reasoning-model review. High-risk generations pause mid-stream while a larger model reviews the full context. Disallowed output never reaches the user.
4. Account-level signals. Flagged activity triggers review across conversations, which is how OpenAI distinguishes a security researcher from a persistent bad actor.
5. 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

Hands-On: Five 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.”

# ============================================================
#  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(type(x)==int for x in r) else r

Wow! GPT 5.6 Sol was able to do the requested, at 1/5th the response size of GPT 5.5. Clear and obvious improvement.

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

Prompt: “Summarize the following text in exactly three bullet points, then extract every date and dollar figure into a JSON object with keys “dates” and “amounts”:

Correct and to the point observation.

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

Prompt: “Schedule 6 speakers (A, B, C, D, E, F) across 3 rooms and 4 time slots. Constraints: A and B cannot be scheduled in the same time slot; C must be in an earlier slot than D; E needs Room 1 to itself for two consecutive slots; F must present in the final slot; and no room may sit empty in any slot. Give me the full schedule.”

Response:

Observation

Sol didn’t take the bait. Everything about the prompt says produce a grid. It counted instead.

Twelve room-slots must be filled. Six speakers fill six; E’s two-slot claim adds one. Seven of twelve. Inconsistent before scheduling begins.

The tell is what it ignored: A/B, C-before-D, F’s closing slot. Decoys, all of them. Sol found the conflict between cardinality and coverage and argued only that.

One miss. We asked for the minimal constraint to relax. Sol offered three exits and ranked none, though only one is a single-constraint fix.

The Bottom Line

GPT-5.6 are three stories just in one. 

The first is the model family: a flagship that pushes the agentic frontier, a workhorse that halves production costs, and a budget tier carrying last generation’s flagship quality at a dollar. Tiering this clean makes routing, not model choice, the new architecture question.

The specs say this is the best model family ever shipped. Based on my experience, I agree. Now it’s for you to test these models on your workflows and decide for yourself. 

Frequently Asked Questions