Skip to main content
Illustration of the GPT-5.6 Sol, Terra, and Luna model tiers and the prompt caching mechanism
OpenAI officially released the GPT-5.6 family on July 9, 2026. AIHubMix has completed integration of all three tiers: gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna are now available through Chat Completions and Responses. The release also changes the prompt caching mechanism and its billing — cache writes are now billed separately. This post covers the positioning of the three tiers and walks through the caching changes point by point.

​
What changes with the three GPT-5.6 tiers

GPT-5.6 revises the naming scheme: the number denotes the model generation, while Sol, Terra, and Luna are capability tiers that can evolve independently. Per the official definitions — Sol is the flagship model, Terra is a lower-priced tier with performance comparable to GPT-5.5, and Luna is the fastest, lowest-priced tier.
gpt-5.6-solgpt-5.6-terragpt-5.6-luna
Official positioningFlagship model for complex professional workBalanced intelligence and costFor cost-sensitive workloads
Context window1,050,0001,050,0001,050,000
Max output128,000128,000128,000
Knowledge cutoff2026-02-162026-02-162026-02-16
Rough equivalent in the previous generationNo-suffix tiermini tiernano tier
On capabilities, the official position: Sol achieves state-of-the-art results on coding, knowledge work, cybersecurity, and science tasks, is described by OpenAI as its best coding model to date, and sets new records on Terminal-Bench 2.1 and DeepSWE; Terra matches GPT-5.5 performance at half the price. The family adds a max reasoning level, and the Responses API gains Programmatic Tool Calling and multi-agent (Beta) capabilities.

​
The caching mechanism upgrade, explained

Before GPT-5.6, prompt caching on GPT models was fully automatic: prefixes of 1,024 tokens or more were cached automatically, developers had no control over what was cached or for how long, and caches were cleared after 5–10 minutes of inactivity. OpenAI summarizes the GPT-5.6 changes as “more predictable prompt caching”, with three concrete points:
  1. Retention moves from “as short as 5 minutes” to “at least 30 minutes”. prompt_cache_options.ttl currently only supports "30m"; that is a guaranteed minimum, and actual retention may be longer.
  2. Explicit cache breakpoints are new. Setting prompt_cache_breakpoint on a content block pins the cache boundary at the end of stable content, so changes after the breakpoint do not invalidate the cached prefix before it; with prompt_cache_options.mode set to "explicit", only manual breakpoints are used.
  3. prompt_cache_key moves from an optimization to an official requirement. Starting with GPT-5.6, the parameter should be set to enable more reliable cache matching; OpenAI recommends keeping traffic per key to roughly 15 requests per minute.

​
How to evaluate the 1.25x cache write billing

Starting with GPT-5.6, cache writes are billed at 1.25x the base input rate and cache reads at 0.1x; on earlier models, cache writes have no additional fee. The official wording (from the GPT-5.6 announcement): “For GPT-5.6 and later models, cache writes are billed at 1.25x the model’s uncached input rate, while cache reads continue to receive the 90% cached-input discount.” The break-even math follows directly from the official rates: writing a prefix costs 0.25x the input rate more than not caching, and every subsequent hit saves 0.9x the input rate — a prefix reused even once produces a net saving, and the more reuse, the larger the saving.
  • Workloads that clearly benefit: agent workflows with long system prompts, RAG that repeatedly includes long reference material, applications carrying large tool definitions, and multi-turn conversations that only append messages. These workloads have high prefix reuse, so the 0.1x read rate dominates.
  • Workloads to watch: one-off long requests whose prefix is never reused. Automatic caching is on by default, so these requests incur an unrecoverable 1.25x write fee; setting prompt_cache_options.mode to "explicit" without setting any breakpoints makes the request skip the cache entirely and incur no write fee.

​
Comparison: prompt caching on GPT-5.6 and Claude

GPT-5.6’s caching design converges with Claude’s cache_control on several dimensions, with the core difference in default behavior: GPT caches automatically with no parameters required, while Claude requires caching to be enabled in the request — either the top-level cache_control field (automatic breakpoint) or content-block-level explicit breakpoints.
DimensionGPT-5.6 familyClaude family (all active models)
ActivationAutomatic caching, explicit breakpoints optionalMust be enabled: top-level cache_control automatic breakpoint, or content-block-level explicit breakpoints
Breakpoint parameterprompt_cache_breakpoint (content-block level)cache_control (top level or content-block level)
Breakpoint limitAt most 4 new cache writes per requestAt most 4 breakpoints
Cache retentionAt least 30 minutes5 minutes by default (refreshed at no cost on every hit), optional 1 hour
Cache write billing1.25x input rate1.25x for the 5-minute tier, 2x for the 1-hour tier
Cache read billing0.1x input rate0.1x input rate
Minimum cacheable length1,024 tokens512–4,096 tokens depending on the model
Hit requirementByte-for-byte identical before the breakpointByte-for-byte identical before the breakpoint
The Claude column reflects the rules shared by all active Claude models: 1.25x writes for the 5-minute tier, 2x for the 1-hour tier, and 0.1x reads apply uniformly across the lineup (Anthropic prompt caching documentation), with per-model differences limited to the minimum cacheable length; the GPT-5.6 column comes from the OpenAI prompt caching guide. The breakpoint limits, write rates (for the corresponding tiers), and read rates match exactly across the two providers; in practical terms, the same “static content first, changing content last” prompt structuring strategy carries over between them. Migration cost is concentrated in parameter syntax: GPT uses prompt_cache_breakpoint + prompt_cache_key, Claude uses cache_control.

​
The same caching pattern in both protocols

For the same “cache a static long instruction” scenario, the minimal implementations in the two protocols follow. The examples use gpt-5.6-sol and claude-opus-4-8 — both share the same base input price ($5/M), so the effective per-token prices derived from cache writes (1.25x) and reads (0.1x) are also identical; only the syntax differs. The GPT protocol sets prompt_cache_key at the top level (long prefixes are cached automatically, no breakpoint marker needed); the Claude protocol sets cache_control at the top level to enable automatic caching, switching to content-block-level breakpoints when precise control over the cache boundary is needed:
GPT-5.6 (Chat Completions)
curl https://aihubmix.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -d '{
    "model": "gpt-5.6-sol",
    "prompt_cache_key": "my-app-report-v1",
    "messages": [
      {
        "role": "system",
        "content": "[Static long instructions, >=1024 tokens]"
      },
      {
        "role": "user",
        "content": "Summarize the key figures."
      }
    ]
  }'
Claude (Messages)
curl https://aihubmix.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: $AIHUBMIX_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-4-8",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral"},
    "system": "[Static long instructions, >=1024 tokens]",
    "messages": [
      {
        "role": "user",
        "content": "Summarize the key figures."
      }
    ]
  }'
Comparing the two requests, the differences come down to: the endpoint (/v1/chat/completions vs /v1/messages), the auth headers (Authorization: Bearer vs x-api-key + anthropic-version), the caching parameter (top-level prompt_cache_key vs top-level cache_control), and Claude requiring an explicit max_tokens. Both requests were verified against aihubmix.com (2026-07-10): gpt-5.6-sol returned cached_tokens: 2816 on the second call; claude-opus-4-8 returned cache_creation_input_tokens: 3632 on the first call and cache_read_input_tokens: 3632 on the second. Beyond the request format, three mechanism-level differences remain:
  1. Activation: GPT caches automatically even without any caching parameters, with prompt_cache_key improving hit reliability; Claude requires a declaration — a content-block-level cache_control breakpoint, or the top-level cache_control automatic mode.
  2. Usage fields: GPT reports cache reads in prompt_tokens_details.cached_tokens; Claude reports writes and reads separately as cache_creation_input_tokens and cache_read_input_tokens, making it easy to verify writes and hits independently.
  3. Lifetime control: GPT-5.6’s ttl currently only supports "30m"; Claude defaults to 5 minutes (refreshed at no cost on every hit), with an optional "ttl": "1h" (writes billed at 2x).

​
What to change when swapping models across protocols

The AIHubMix gateway supports cross-protocol calls: the OpenAI-compatible endpoint can call Claude models (cache_control goes directly into OpenAI-format message content blocks; see Prompt Caching practices), and the Claude-compatible /v1/messages endpoint can call GPT-5.6 (verified working). When swapping models, check three things:
  • Change model to the target model ID;
  • Switch the caching parameter syntax: prompt_cache_key / explicit breakpoints correspond to Claude’s cache_control;
  • Switch the usage field names: cached_tokens corresponds to Claude’s cache_read_input_tokens.
Recommended paths for prompt caching: GPT models through Chat Completions (the cache-hit path verified in this post); Claude models work through either protocol.

​
Comparison: GPT-5.6 vs earlier GPT caching

DimensionBefore GPT-5.6GPT-5.6 and later
Cache writesNo additional fee1.25x input rate
Cache retentionCleared after 5–10 minutes of inactivity, up to 1 hourAt least 30 minutes
Cache controlNoneExplicit breakpoints, explicit mode, prompt_cache_key reliable matching
24-hour extended retentionprompt_cache_retention on some modelsReplaced by prompt_cache_options.ttl (currently 30m only)
The changes point in one direction: earlier-generation caching was free of write fees but uncontrollable, with uncertain retention; GPT-5.6 charges for writes while providing a guaranteed retention floor and precise cache controls. By the rates, a prefix reused more than once on average saves more than the added write cost; the 30-minute retention floor and controllable breakpoints make reaching that reuse rate more predictable.

​
Getting started on AIHubMix

All three tiers are live, with model IDs gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna. Caching requires no extra configuration; consecutive requests with the same long prefix hit the cache:
Python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AIHUBMIX_API_KEY"],
    base_url="https://aihubmix.com/v1",
)

long_context = "You are a meticulous assistant for analyzing quarterly financial reports... [Static long instructions, >=1024 tokens]"

for i in range(2):
    completion = client.chat.completions.create(
        model="gpt-5.6-sol",
        prompt_cache_key="my-app-report-assistant-v1",
        messages=[
            {"role": "system", "content": long_context},
            {"role": "user", "content": "Summarize the key figures in one sentence."},
        ],
    )
    print(completion.usage.prompt_tokens_details)
A usage.prompt_tokens_details.cached_tokens value greater than 0 on the second call indicates a hit (measured example: cached_tokens: 2816). For parameter details, billing specifics, and hit troubleshooting, see the GPT Prompt Caching documentation.

​
FAQ

​
Which APIs can call GPT-5.6 on AIHubMix?

Chat Completions (/v1/chat/completions), Responses (/v1/responses), and the Claude-compatible Messages API (/v1/messages) can all call the models, and all three tiers are live. For prompt caching, Chat Completions is currently the recommended path.

​
If my client changes nothing, what changes in billing after upgrading to GPT-5.6?

Prompt caching applies automatically by default: requests whose prefix reaches 1,024 tokens incur a cache write item billed at 1.25x the input rate, and reused prefixes are billed at the 0.1x read rate. Applications with high prefix reuse usually see lower total costs; one-off long requests that never reuse a prefix can disable caching with explicit mode.

​
I have used Claude prompt caching — what do I change to migrate to GPT-5.6?

The prompt structuring strategy stays the same: static content first, changing content last. The parameters change from cache_control to prompt_cache_breakpoint, plus prompt_cache_key; retention changes from the 5-minute/1-hour tiers to a 30-minute guaranteed floor.

​
How do I choose among the three GPT-5.6 tiers?

Per the official positioning: pick Sol for complex professional work and coding tasks; pick Terra for everyday workloads (GPT-5.5-level performance at half the price); pick Luna for cost-sensitive, high-volume scenarios. All three tiers share the same context window and max output, so you can route by task complexity.

​
Official references

Model specifications, caching mechanisms, and billing rates in this post come from these official sources: Related documentation on this site: GPT Prompt Caching · Claude Prompt Caching · Prompt Caching practices
Visit the model gallery for GPT-5.6 pricing, or explore more integration options in the documentation center.
Last updated: 2026-07-10