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.
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.
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.
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:
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.
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:
On benchmarks, the standout claims:
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.
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.
“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.
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:
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).
Specs are promises. Usage is proof.
Every test below targets a specific claim from OpenAI’s announcements.
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.
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.
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.
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.
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.
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.
A. GPT-5.6 Sol, Terra, and Luna launched publicly on Thursday, July 9, 2026, following Commerce Department approval, with preview access already expanding globally. The rollout covers the API, Codex, and ChatGPT. OpenAI has not yet published which ChatGPT subscription tiers get Sol first, so check the model picker on launch day.
A. Sol is the flagship for the hardest work: long-horizon coding agents, security research, and deep analysis. Terra matches GPT-5.5 quality at half the price, making it the migration target for production workloads. Luna is the fastest, cheapest tier yet still lands near GPT-5.5 on several tests.
A. Per million tokens: Sol is $5 input and $30 output, Terra $2.50 and $15, Luna $1 and $6. Sol Fast is a new premium option at $12.50 and $75 that serves the same flagship model at up to 750 tokens per second on Cerebras hardware.
A. Sol is OpenAI’s most capable cybersecurity model, so at the government’s request under a new cyber Executive Order framework, the June 26 launch began as a limited preview for roughly 20 vetted organizations. After additional testing and agency meetings, the Commerce Department approved the broad launch twelve days later.
A. OpenAI classifies all three models at its “High” cyber risk level, with Sol solving 96.7% of internal capture-the-flag challenges, but says none can autonomously run a complete attack campaign under test conditions. They ship with five layered safeguards hardened by over 700,000 GPU hours of red-teaming.
Facts Only
* Three models launched: gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna.
* Access is available to all users without subscription.
* GPT-5.6 Sol is the flagship model.
* Sol Fast is a premium option offering up to 750 tokens per second on Cerebras hardware for $12.50 and $75, respectively.
* Pricing per million tokens: Sol is $5 input / $30 output; Terra is $2.50 input / $15 output; Luna is $1 input / $6 output.
* All three models are classified at OpenAI’s “High” risk level for cyber and biological capability.
* The safety architecture includes configurations matched to each tier's capability.
* Sol is noted as better at finding and fixing vulnerabilities than carrying out end-to-end attacks.
* Usage testing demonstrated Sol corrected a bug in a file and refactored code, and improved response conciseness compared to prior models.
* A scheduling task revealed model inconsistency when asked for a grid, resulting in an answer based on counting rather than full constraint satisfaction.
Executive Summary
The release of GPT-5.6, encompassing the models Sol, Terra, and Luna, provides public access to three new AI systems without subscription requirements. The structure introduces Sol as a flagship model, Terra as a cost-effective alternative matching previous quality, and Luna as the fastest and cheapest tier. Pricing varies across the models, with an explicit premium option called Sol Fast offering higher token throughput at a significantly increased rate for Sol. A key feature is the revised pricing structure, which factors in efficiency through caching benefits and per-token costs, establishing a model family tiered by performance and cost.
The system also details the models' risk classification and safety architecture, noting that all three are classified as "High" risk for cyber and biological capability, with Sol specifically noted for its security capabilities. The underlying strategy emphasizes integrating capability into defensive frameworks while making offensive misuse difficult through layered safeguards hardened by extensive red-teaming. Hands-on testing revealed model capabilities across tasks ranging from complex code debugging and refactoring to structured summarization and scheduling, demonstrating improvements in reasoning, efficiency, and output quality compared to prior versions.
Full Take
The emergence of the Sol, Terra, and Luna family reflects a strategic shift from monolithic naming to granular performance tiering, redefining the architecture around efficiency. The emphasis on per-token pricing and explicit speed tiers fundamentally shifts the value proposition from raw capability alone to measurable economic output. This structure forces users to adopt a routing strategy based on latency and cost constraints rather than an assumed hierarchy of intelligence.
The observation regarding the scheduling task highlights a crucial tension: maximizing capability versus strictly adhering to all imposed logical constraints. Sol’s ability to identify the conflict between cardinality and coverage suggests that true agentic intelligence resides not just in factual recall, but in complex constraint satisfaction and pattern recognition across multiple variables—a domain where current safety architectures are explicitly designed to be brittle against adaptive manipulation.
The framing of capability as 'risk' being addressed by embedded safeguards indicates a systemic commitment to managing potential misuse rather than simply maximizing output. The performance gains seen in coding tasks suggest that the improved instruction following and error localization capabilities translate directly into enhanced agentic utility, pushing the boundary where efficiency and safety are designed to intersect, not be separate concerns.
What future system requires measuring success by the complexity of constraints successfully navigated? What happens when the cost structure incentivizes agents to prioritize speed over exhaustive validation, and how does that tension manifest in autonomous action?
Sentinel — Human
The text functions as a detailed editorial synthesis of new AI model announcements, blending hard data with subjective analysis and practical testing results.