OpenAI shipped GPT-5.6 on July 9, 2026, retiring the old mini/nano naming for three tiers — Sol / Terra / Luna. Official API pricing (per 1M input / output tokens):
| Tier | Positioning | Input | Output |
|---|---|---|---|
| Sol | Flagship, strongest reasoning | $5 | $30 |
| Terra | Daily driver — matches 5.5, half the price | $2.5 | $15 |
| Luna | High-concurrency, low-latency, cheapest | $1 | $6 |
OpenAI highlighted a ~54% gain in coding token efficiency. But run it inside an agent (Codex, Claude Code, and friends) and the bill still stings — because every turn re-sends the system prompt, project context, and history. Input tokens are where the money goes, and that's largely independent of which tier you pick.
The good news: you can bring GPT-5.6's effective cost way down without downgrading the model — often to a fraction of list price. Three levers, ordered by bang for buck.
1. Pick the right tier
Pricier isn't "better" — each tier has a lane:
- Sol — save it for genuine long-horizon reasoning (complex refactors, cross-file design). Wasted on simple tasks.
- Terra — the daily driver. Matches last-gen flagship at half the price; enough for most coding/agent work.
- Luna — high concurrency, latency-sensitive, low per-call complexity (bulk classification, simple completions).
A lot of inflated bills come from running everything on the flagship. Route by task and you save in one step.
2. Route through an OpenAI-compatible gateway
If you're juggling GPT + Claude + Gemini, or you just want a lower unit price, a compatible gateway is a common move: one key for multiple models, pay-as-you-go, volume-negotiated rates. Existing code changes two lines — base_url and api_key. Model name, streaming, function calling all stay put.
⚠️ One trap. Plenty of "dirt cheap" relays run on account-pool rotation — cycling accounts to cut cost. That wrecks prompt caching, so even at a headline-low price, your real spend at 0% cache hit can land near full official rate — with worse stability and no guarantee the model isn't being swapped underneath you. Evaluate on three things, not just price:
- Does the cache hit rate match going direct?
- Is the channel traceable?
- Is the model ever silently swapped or downgraded?
Get those answered before you compare prices.
The gateway I use here is Teamo, chosen against exactly those three: it routes official models directly (no swapping), holds a cache hit rate on par with going direct (>99%), is pay-as-you-go, and takes one key across GPT / Claude / Gemini. Because it pools volume across an upstream supplier network, GPT-5.6 lands as low as ~10% of official list. That discount floats with upstream cost, so check the live pricing before you wire it in — don't take a headline number on faith.
Wiring GPT-5.6 in
Using GPT-5.6 as the example (direct-to-official is the same — just swap base_url back).
Codex CLI — edit ~/.codex/config.toml:
model_provider = "teamorouter"
model = "gpt-5.6-terra" # or sol / luna — check the console for exact model names
model_reasoning_effort = "high"
[model_providers.teamorouter]
name = "Teamo"
base_url = "https://api.teamorouter.com/v1"
env_key = "OPENAI_API_KEY"
wire_api = "responses"
Set the key:
echo 'export OPENAI_API_KEY="your-key"' >> ~/.zshrc && source ~/.zshrc
Restart Codex and you're set. (Full macOS / Linux / Windows walkthrough is in the docs.)
Calling the API directly is the same — two lines change:
from openai import OpenAI
client = OpenAI(
base_url="https://api.teamorouter.com/v1",
api_key="your-key",
)
resp = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{"role": "user", "content": "Write quicksort in Python"}],
)
print(resp.choices[0].message.content)
Does it actually add up?
Take Terra ($2.5 / $15). A mid-size coding task, say ~1M input + 200k output tokens. Raw official cost:
2.5 + 0.2 × 15 = $5.5
At ~10% unit price that's about $0.55 — and caching then knocks ~90% off the repeated input on top, because these multiply, they don't add. How much you actually save depends on your cache hit rate and the live discount. Run a few real tasks and compare bills — that's the only number that matters.
3. Actually use prompt caching (the hidden lever)
Agents have a quirk: the input each turn is highly repetitive — the system prompt and project context barely change. Prompt caching bills those repeated input tokens at roughly 90% off. So your cache hit rate basically decides your real cost — same task, cache warm vs. cache cold, can differ by an order of magnitude.
Practical implication: keep your prompt prefix stable. Don't mutate the opening every turn, or you keep invalidating the cache.
TL;DR
You don't need to touch your application logic. Three moves: route by tier, max out prompt caching, and use a compatible gateway to aggregate and negotiate. GPT-5.6's 54% token efficiency saves tokens; caching and unit price save dollars. Stack both.
Top comments (0)