GPT-5.6 Is Public: Pricing, Performance, and Codex Merging into ChatGPT

OpenAI officially released GPT-5.6 on July 9, 2026, with rollout expanding globally over the following 24 hours.

This is obviously a model release, but if you read it as just “GPT got a bit better again,” you miss the bigger point. GPT-5.6 sends two clear signals. First, OpenAI's narrative has shifted from absolute performance to performance per dollar: getting more work done on the same budget. Second, ChatGPT, Work, and Codex are being pulled into a single entry point. OpenAI is no longer trying to sell only the model itself, but a complete workspace and execution workflow.

What Exactly Was Released with GPT-5.6

GPT-5.6 was not released as a single model, but as a family:

• GPT-5.6 Sol: the flagship tier for complex reasoning, coding, and high-value tasks
• GPT-5.6 Terra: the balanced middle tier for capability and cost
• GPT-5.6 Luna: the high-throughput, cost-efficient tier

According to OpenAI's API documentation, all three support Functions, Web search, File search, and Computer use, with a 1.05M token context window and a knowledge cutoff of February 16, 2026. The gpt-5.6 alias points to gpt-5.6-sol by default.

For end users, GPT-5.6 is now available across ChatGPT, Codex, and the OpenAI API. For developers, the more important change is that GPT-5.6 is not just “better answers.” It also comes with a more layered configuration and execution system:

• reasoning effort: from none to max, which determines how much reasoning budget the model will spend
• Pro mode: a heavier execution mode on the same model, not a separate model
• Ultra: a multi-agent mode in Codex / ChatGPT that trades more compute for stronger results and faster completion
• Programmatic Tool Calling: a more structured way to organize tool calls in the Responses API and reduce wasteful intermediate tokens

That is why OpenAI keeps emphasizing “more value per token,” rather than pushing a single benchmark headline.

What Sol, Terra, Luna, Pro, and Ultra Actually Mean

If you've been jumping between the API docs, Codex, and ChatGPT lately, it's easy to get lost in the naming. OpenAI is simultaneously talking about base model variants, reasoning levels, execution modes, and product-layer work modes. Those are not the same thing, but the interface makes them feel like they are.

Let's separate the base layer first:

• Sol, Terra, and Luna are the three base GPT-5.6 variants
• the gpt-5.6 alias points to gpt-5.6-sol
• all three share the same tool support, the same 1.05M context window, and the same set of reasoning effort options

In the API docs, all three support these reasoning levels:

• none
• low
• medium
• high
• xhigh
• max

That means “low reasoning,” “high reasoning,” and “max reasoning” are not separate models. They are simply different inference-intensity settings on the same model. For example:

• gpt-5.6-sol + low
• gpt-5.6-sol + max
• gpt-5.6-terra + medium

These are different combinations of “model variant + effort,” not entirely different products.

Next comes Pro, which is where the naming gets more confusing.

Source: https://developers.openai.com/api/docs/guides/reasoning#reasoning-mode

OpenAI is explicit in the API docs: Pro is not a standalone model slug. If you want Pro mode, you do not switch to something like gpt-5.6-pro. Instead, you keep the same Sol / Terra / Luna variant and set reasoning.mode to pro. reasoning.mode and reasoning.effort are also independent, so you can still separately choose low, medium, high, or max effort.

Put more plainly, Pro in the API is not a “fourth variant.” It is a heavier execution mode on top of the same model: the model does more work and returns a single final answer, at the cost of higher latency and greater token usage.

Ultra is yet another layer. On the GPT-5.6 launch page, OpenAI describes it as Codex's default four-agent configuration, and explicitly says developers can use the multi-agent beta in the Responses API to build “ultra-like experiences.” That makes Ultra much closer to a product-layer multi-agent work mode than to a fourth base GPT-5.6 model.

So if you force all of these names into one table, the safest interpretation looks like this:

And that is exactly why GPT-5.6 feels stronger while also feeling more confusing. In practice, users are no longer just “choosing a model.” They are often choosing across four different layers at once:

1. A base variant: Sol, Terra, or Luna
2. A reasoning level: from none to max
3. An execution mode: standard or pro
4. A product-layer multi-agent mode in Codex / ChatGPT, such as ultra

This design gives power users more room to tune behavior, but it also makes it less obvious what exactly they are using at any given moment. For ordinary developers, OpenAI is no longer selling a single model name so much as a growing matrix of runtime configurations.

How Pricing Changed

Under OpenAI's Standard API pricing, GPT-5.6 is priced as follows:

Two things stand out immediately.

First, Sol is priced the same as standard GPT-5.5. In other words, OpenAI did not simply raise the price on the flagship tier. It is trying to convince developers that, at roughly the same unit price, they can get higher task success, lower latency, and fewer tokens used.

Second, Terra and Luna make the pricing ladder much clearer. For teams doing large numbers of agent calls, batch content generation, or medium-complexity coding tasks, those two tiers may be more attractive than defaulting to the strongest model every time.

GPT-5.6 also introduced an easy-to-miss but very important change for API costs: starting with the GPT-5.6 family, Prompt Caching cache writes are no longer “no additional charge.” They are billed separately.

Under Standard pricing, the caching-related prices look like this:

• cached input is still billed at 10% of the normal input rate
• cache writes are billed at 1.25x the uncached input rate

Using GPT-5.6 Sol as the example under short-context Standard pricing:

• normal input: $5 / 1M tokens
• cached input reads: $0.50 / 1M tokens
• cache writes: $6.25 / 1M tokens

The key point to clarify here is this: stronger explicit cache controls do not mean implicit caching went away. OpenAI's documentation is clear that prompt caching is still enabled by default, and eligible requests can still be cached automatically. By default, requests above 1024 tokens may trigger automatic caching. In other words, after GPT-5.6, automatic caching still exists; developers simply get more explicit control over cache breakpoints.

The difference between the two is roughly this:

In the docs, OpenAI separates request behavior into implicit and explicit:

• implicit is the default mode: the system places implicit breakpoints automatically and also uses any explicit breakpoints you add
• explicit disables the default implicit breakpoints and uses only the breakpoints you define yourself

That distinction matters for cost control. For developers, implicit behaves like automatic optimization by default, while explicit is better suited to workflows where you want to define cache boundaries yourself and make long prefixes and reusable context more stable.

The cache write pricing rule on GPT-5.6 also deserves separate attention. OpenAI states in the prompt caching docs that before GPT-5.6, cache writes had no additional fee; starting with the GPT-5.6 family, cache writes are billed at 1.25x the uncached input rate. The docs also note that, in implicit mode, the system's automatically placed implicit breakpoint also consumes a write slot. The safest interpretation, then, is that whenever a request actually creates new cached content, that cost now needs to be tracked explicitly rather than treated as a free side effect.

Source: https://developers.openai.com/api/docs/guides/prompt-caching#frequently-asked-questions

Another GPT-5.6-specific change worth noting is prompt_cache_key. OpenAI's docs say that, starting with GPT-5.6 and later models, if you want more reliable implicit or explicit cache matching, you should proactively set prompt_cache_key. Without it, the system may still hit automatic caching, but it will not use the more stable exact-matching path.

So the more precise way to describe GPT-5.6's caching changes is not “it now supports caching,” but:

1. Implicit caching still exists and remains enabled by default
2. Developers can use explicit breakpoints to control cache boundaries more precisely
3. cache writes are billed separately starting with the GPT-5.6 family, whenever new cache writes actually occur
4. If you want stable caching gains in production, prompt_cache_key is becoming close to mandatory

That means teams using the API heavily can no longer focus only on input and output prices. They also need to watch three separate things: cache write volume, cache read hit rate, and how stable their prompt prefixes really are.

Performance Improved, but OpenAI Is Really Selling Efficiency

If you only look at the official presentation, GPT-5.6 appears stronger across nearly every category: coding, knowledge work, design, browsing, science, and cybersecurity. But if you read the launch materials closely, OpenAI's emphasis is not on a broad “we lead everywhere” slogan. It is on fewer tokens, lower latency, and higher completion rates.

Some of the representative claims OpenAI highlights include:

• 80 on the Artificial Analysis Coding Agent Index v1.1 for GPT-5.6 Sol
• 92.2% on BrowseComp for GPT-5.6 Sol Ultra
• 62.6% on OSWorld 2.0 for GPT-5.6 Sol
• repeated claims that GPT-5.6 is more cost-efficient than Claude Fable 5 on long-form, professional agent evaluations such as Agents' Last Exam

It is still worth staying cautious here. Different sections of OpenAI's own page do not always show identical numbers. For example, the main text says GPT-5.6 Sol reaches 53.6 on Agents' Last Exam, while the summary table later on the page shows 52.7. That usually signals differences in evaluation mode, reasoning effort, or whether a stronger configuration was used. In other words, GPT-5.6 is getting better, but any benchmark still has to be read in the context of its test conditions, not just its headline number.

That is why I think the most important part of this release is not “bigger and stronger,” but a much more production-oriented pitch:

1. Get more tasks done under the same budget
2. Use fewer tokens to reach similar or better outcomes
3. Let multi-agent systems and programmatic tool calling handle more of the complex work

For enterprises and heavy API users, that matters more than a benchmark score being two points higher.

Codex Merging into ChatGPT May Matter More Than the Benchmark Scores

If GPT-5.6 is the headline on the model side, the bigger product story may actually be something else: the Codex app is being merged into the new ChatGPT desktop app.

OpenAI says this very directly in a separate announcement: starting that day, the Codex app would merge into the new ChatGPT desktop experience. After the merge, the ChatGPT desktop app can access local files and applications, and also includes a built-in browser so webpages, online tools, and online files can all be brought into the same workspace. At the same time, Codex keeps its developer workflow features, including:

• inline editing inside diffs
• PR review in the sidebar
• faster computer use
• support for multiple repositories in a single project

The significance is not just “one less app to install.” It shows that OpenAI is consolidating three things that used to feel separate:

• everyday chat
• long-form knowledge work
• coding and execution-oriented agents

People used to think of ChatGPT as the chat window, Codex as the developer tool, and Work as the heavier productivity mode. The direction now looks much clearer: OpenAI wants to collapse these into one interface, so users stop switching products and instead switch task types inside the same container.

If that direction holds, OpenAI's competitive edge will increasingly depend not just on whether its model ranks first, but on whose work loop is more complete.

How the Community Is Reacting to GPT-5.6

Judging from the Hacker News thread, community opinion on GPT-5.6 is far from uniformly enthusiastic. It splits in a fairly familiar way between “this is real progress” and “hold on a second.”

The positive reactions cluster around three themes.

The first is faster, cheaper, and more stable. Many developers are not saying “this is suddenly much smarter than the last generation.” What they are saying instead is that it feels more stable, faster, and more consistent at roughly the same or even lower cost. That lines up neatly with OpenAI's own efficiency-first messaging.

The second is Codex's product experience appears to be catching up with, or even overtaking, other coding harnesses. In the discussion, some developers explicitly say they have already switched from Claude Code to Codex, not because of a single benchmark, but because of reliability, price, and long-task behavior. One comment even reduced Codex's killer feature to a single word: price.

The third is design and frontend capability are finally being discussed seriously. OpenAI spent real time highlighting GPT-5.6's design judgment and computer use, and some developers think that if those capabilities hold up in real projects, OpenAI may finally narrow the perception gap with Claude in UI and design workflows.

The reservations are just as real.

First, the benchmark marketing still makes people uneasy. Many readers do not fully trust launch-style comparisons, especially when different parts of the official material show different numbers or compare different models under different modes. That naturally raises the question of whether the results are actually being compared under directly equivalent conditions.

Second, there is the issue of quotas and token usage. Some HN users have already reported that GPT-5.6 Sol can produce strong results on long tasks, but also burns through quota very aggressively, sometimes even continuing into extra review passes after the main task is already done. In other words, OpenAI says “each token is more valuable,” while some users are saying “it still spends a lot of tokens, it just spends them in a way that feels more justified.”

The third point of friction is prompting habits may need to change. OpenAI's own documentation explicitly warns that GPT-5.6 is more sensitive to generic brevity instructions such as “Be concise” and “Keep it short,” and may over-compress output to the point of dropping information that should have been included. That warning also triggered criticism on HN, because it implies some previously well-worn prompting habits may now need to be rewritten.

The last practical concern is model selection itself is getting more complicated. Sol, Terra, Luna, different reasoning efforts, max, ultra, standard mode, Pro mode: for ordinary developers, choosing a model is starting to feel less like “pick the strongest one” and more like operating a scheduling system.

My Take on GPT-5.6

If I had to summarize this release in one sentence, it would be this:

The significance of GPT-5.6 is not just that the model is stronger, but that OpenAI is trying to turn “model leadership” into “workflow leadership.”

Its value is not primarily in any one benchmark. It comes from three things being bundled together:

• a clearer pricing ladder
• a stronger emphasis on token efficiency and tool execution efficiency
• a unified entry point for ChatGPT, Work, and Codex

From a product-strategy perspective, that is more important than “there is another new model.” Once raw model capability starts to converge, what determines switching cost and retention is often not a three-point benchmark gap, but who can complete a full stretch of work more reliably.

That said, GPT-5.6 is still nowhere near a blind “switch everything over” moment. Benchmark comparability, real token burn in production, quota experience, and the friction introduced by safety checks all still need to be validated with more real-world usage.

But at least from this July 9, 2026 release, OpenAI has made its next direction very clear. It does not just want to keep training stronger models. It also wants to turn ChatGPT into a unified work interface, and shift Codex from being a standalone coding agent into the core execution layer inside that interface.

If this direction works, GPT-5.6 may end up being remembered not because it had “the strongest benchmark,” but because it marked the point where OpenAI began systematically restructuring the relationship between ChatGPT and Codex.

Related Resources

• OpenAI announcement: GPT-5.6
• OpenAI API Models docs
• OpenAI API Pricing docs
• OpenAI model guide: Using GPT-5.6
• OpenAI announcement: ChatGPT for your most ambitious work
• Hacker News discussion thread