OpenAI moved GPT-5.6 to general availability yesterday, July 9th. Three tiers — Sol, Terra, and Luna — all sharing a 1M-token context window, with pricing that ranges from $1/$6 to $5/$30 per million tokens. If you're building anything serious on OpenAI's API, the model picker just got meaningfully more complicated and a lot more consequential for your cost model.
I've spent the past decade running infrastructure at scale, and more recently building AI systems that have to operate reliably under real load. The announcement that caught my attention wasn't Sol's benchmark win on Agents' Last Exam — a 13-point lead over Claude Fable 5, which is legitimately significant. It was the explicit cache breakpoints and the 90% discount on cache reads. Those are infrastructure mechanics, not benchmark numbers, and they tell me OpenAI is thinking seriously about how engineering teams actually run these models in production.
Let me walk through what this family release means if you're the person making the call about which model gets routed your API traffic.
The Three Tiers: What You're Actually Choosing Between
Sol is the flagship. $5 input, $30 output per million tokens. It scored 88.8% on Terminal-Bench 2.1 and set a new high of 53.6 on Agents' Last Exam — an evaluation of long-running professional workflows across 55 fields. Sol Ultra, the parallel-subagent mode, extends the effective context to 1.5M tokens and coordinates four specialized agents by default. Built for frontier reasoning, long-horizon agentic work, and tasks where quality has a hard floor.
Terra is the everyday tier. $2.50/$15 per million tokens — exactly half of Sol's price. OpenAI describes it as delivering GPT-5.5-competitive performance. On Terminal-Bench 2.1, Terra scored 84.3%, four and a half points behind Sol. That delta matters for hard reasoning tasks. For the broad middle of production workloads — customer-facing responses, structured extraction, moderate reasoning — it's likely sufficient and the cost case is compelling.
Luna is the budget tier. $1/$6 per million tokens, 82.5% on Terminal-Bench 2.1. Luna exists for the use cases where you're making hundreds of API calls per user session: classification, routing, triage pipelines, summarization at volume. The 82.5% score is stronger than it sounds for these tasks — you're not doing frontier reasoning in a classification pipeline.
All three tiers share the same 1M-token context window and 128K max output. That's an important architectural point: you can build your system once and route identical prompts to any tier without reformatting or truncating context. The shared specification is what makes tier routing a practical engineering option rather than an exercise in maintaining three different prompt formats.
The Cache Mechanics Are the Real News
Benchmark conversations are easy to follow. The caching improvements are what I'm actually integrating into systems this week.
GPT-5.6 ships with explicit prompt cache breakpoints. You can now mark specific positions in your prompt where caching should apply, rather than relying on OpenAI's automatic detection. Cache reads cost 90% less than uncached input. Cache writes cost 1.25x the standard input rate. The cache lifetime is guaranteed for at least 30 minutes.
The 90% cache read discount changes the math significantly for systems that repeatedly process large, stable context. Consider an agentic workflow that sends a 200K-token system prompt on every call — a shared knowledge base, a codebase snapshot, a long product spec. At Sol's uncached input rate, that's $1.00 per call in context costs alone. With a cache hit, it drops to $0.10. Run 10,000 tasks per day against that context and you're looking at $9,000 in daily savings on the context portion of your bill.
The explicit breakpoints matter operationally. When you control exactly where the cache boundary sits, you can structure your prompts so the stable portion (system instructions, reference data, tool definitions) always hits cache and only the variable portion (the user's task) is billed at full rate. Automatic detection works most of the time, but "most of the time" is not good enough when you're optimizing a cost model at scale.
The 30-minute minimum cache lifetime also matters for multi-step agentic work. If your workflow runs for 20 minutes, loops back to refine a plan, and sends another query against the same context, you can rely on the cache still being warm. That reliability is what makes it safe to architect around rather than treat as an optimization that might or might not fire.
Multi-Agent Orchestration and Programmatic Tool Calling
Two other things in this release are worth watching: the multi-agent beta in the Responses API, and programmatic tool calling via JavaScript execution.
The multi-agent feature lets Sol spin up subagents for parallel, focused work natively within the API — without you having to orchestrate that in your application layer. In Ultra mode it coordinates four agents by default, each working a specialized slice of the problem. This is a beta, and I wouldn't build production-critical systems on it yet, but the direction is unambiguous: OpenAI wants to absorb complexity that currently lives in your application code.
Programmatic tool calling is the subtler addition. Models can now compose and execute JavaScript to coordinate tool calls — bridging MCP servers and CLI utilities in ways that previously required custom glue code. I find this genuinely interesting and genuinely worth being careful about. The moment a model can write and execute arbitrary JavaScript to orchestrate tools, you have a new attack surface and a new set of auditability questions. I'll be watching how this develops in production environments before deploying it in anything that touches external systems.
Where Fable 5 Still Wins
I'd be doing you a disservice if I left the benchmark story at "Sol crushed Fable 5 on Agents' Last Exam." On SWE-Bench Pro — which measures software engineering capability against real codebases and real PRs — Claude Fable 5 substantially outperforms the entire GPT-5.6 family. That matters for code-heavy use cases.
The Agents' Last Exam result reflects broad professional workflow performance across 55 fields. Sol's 13-point lead over Fable 5 there is real, but Agents' Last Exam is not a coding benchmark. If your primary use case is deep code reasoning — agentic PR review, codebase-scale refactoring, complex debugging — Fable 5 still holds a meaningful edge.
The more interesting comparison for most teams is Terra versus Fable 5 at $2.50/$15. If Terra closes enough of the gap on your specific code tasks at half the cost, that's a legitimate production call. Run your own evals. Aggregate benchmarks will not answer that question for your workload.
A Framework for Picking the Right Tier
Here's how I'm thinking about routing decisions with the GPT-5.6 family:
- Sol: Frontier reasoning, long-horizon agentic workflows, tasks where quality has a hard floor and cost is secondary. The 53.6 Agents' Last Exam score and 88.8% Terminal-Bench result make this the right choice for complex multi-step problem solving. Budget: $5/$30 per 1M tokens.
- Terra: The majority of production workloads. Customer-facing responses, structured extraction, document analysis, moderate reasoning. GPT-5.5-competitive at half the price. Budget: $2.50/$15 per 1M tokens.
- Luna: High-volume, lower-complexity tasks. Triage, classification, short-form generation, routing decisions. If you're making hundreds of calls per user session and the task doesn't demand frontier reasoning, Luna's $1/$6 pricing changes what's economically viable. Budget: $1/$6 per 1M tokens.
Across all three tiers: cache aggressively. If your system prompt exceeds 10K tokens, you should be hitting explicit cache breakpoints on every call. The 90% discount on reads is not a marginal optimization at scale — it's a first-class architectural concern that should shape how you structure your prompts before you write a single line of routing logic.
What This Release Actually Signals
The trend I see across GPT-5.6 is that OpenAI is systematically packaging complexity into the API layer — parallel subagents, programmatic tool calling, improved caching primitives — while simultaneously making it cheaper to run high-quality inference at scale. That's a deliberate architectural bet: they want to be the substrate that more of the AI-application stack runs on, with less custom orchestration code sitting between their API and your product.
For engineering teams, the practical implication is that a three-tier model family creates a new optimization loop. You now have a real lever to pull between cost and quality on every API call. That's a good problem to have. It's also a real engineering problem to solve — especially in systems where different calls in the same user session warrant different tiers.
The GPT-5.6 preview announcement from OpenAI came on June 26th; GA shipped July 9th. The smart move now is not to pick a tier and lock in — it's to build routing logic that can shift between them as you learn what your actual workloads need. Three weeks from now you'll have real production cost and quality data. That data is worth more than any benchmark suite.