My First Week with GPT-5.6: Testing Sol, Terra, and Luna for Real Work

A dev's honest, early take — some quick personal testing after the public release, before anyone's really put real miles on it.

There's a specific kind of feeling when a new frontier model drops. It's not quite excitement and it's not quite skepticism — it's the itch to open your editor and see for yourself whether the benchmarks mean anything for the boring, real work you actually do.

GPT-5.6 gave me that itch, so I spent the week actually using it instead of just reading about it.

Three models, one clean idea

OpenAI released GPT-5.6 as a family of three models with a naming scheme straight out of an astronomy textbook: Sol (the sun, their flagship), Terra (the earth, the balanced everyday workhorse), and Luna (the moon, fast and cheap). Clean idea: the number is the generation, the name is the tier.

I've had it for a few days now — long enough to run it against my actual side-project stack, not long enough to pretend I've stress-tested every corner. So let me be upfront: this is a first-week impression, not a verdict. If someone's already telling you GPT-5.6 "changed everything," they're selling something.

What actually caught my attention

Here's what I keep coming back to, and it's not the benchmark screenshots.

Terra is the one that matters for people like me. Sol gets all the headlines — 91.9% on Terminal-Bench 2.1, top scores on cybersecurity evals, the whole flagship circus. But Sol costs $5/$30 per million tokens. For a solo dev shipping side projects and running an indie stack, that math gets scary fast.

Terra is the quiet story: roughly GPT-5.5 performance at half the price ($2.50/$15). That's not a spec-sheet flex — that's the difference between me running an agent loop for a weekend experiment or watching the meter and closing the tab. Half price at the same quality is the kind of thing that actually changes what I'll attempt, not just what I'll benchmark.

And Luna at $1/$6 is the first model cheap enough that I stopped thinking about cost for the small stuff — summaries, drafts, the little automation glue that never justified a premium model before.

The Ultra thing is genuinely new

Okay, one feature I can't stop thinking about. Sol has a new "Ultra" mode that doesn't just think harder — it spawns subagents that work in parallel and then pulls the results back together. OpenAI basically baked the agent-orchestration loop into the model itself.

I've spent enough time wiring up my own multi-agent setups to know how fiddly that is to do by hand. Seeing it become a native mode is one of those moments where you feel the ground shift a little. I ran it against a small refactor on this site's own codebase and it split the work into three parallel threads without me having to orchestrate anything — I haven't pushed it on anything bigger yet, but conceptually it's the thing I'm most curious to keep breaking.

How I actually tested it

Nothing fancy: I pointed Terra at real tickets from my own backlog — a couple of small features, a refactor, some boring glue code — and compared how it felt against what I was using before. I ran Luna on the throwaway stuff I usually overpay for: commit messages, quick summaries, first-draft copy. And I poked at Sol Ultra on one deliberately gnarly task just to see the subagent behavior in action.

None of this is a scientific benchmark. It's just me, my actual backlog, and a week of paying attention to what felt different.

My practical Codex setup for using fewer tokens

This is the baseline I am testing in ~/.codex/config.toml:

model = "gpt-5.6-sol"
model_reasoning_effort = "medium"
model_verbosity = "low"
personality = "pragmatic"

That is not a magic "cheap mode." It is a sensible default: OpenAI's Codex model guide describes Sol with medium reasoning as the default balance, low verbosity shortens the final answer, and pragmatic is a supported personality in the official configuration schema. I keep Sol on the main thread because planning, trade-offs, and final validation are where the stronger model earns its cost. For a very narrow task, I lower reasoning before I change anything else.

If you use subagents, my cost-conscious pattern is Sol as the architect, Terra as the workers:

Sol reads the requirements, defines the plan, assigns bounded tasks, reconciles results, and performs the final review.
Terra handles exploration, read-heavy scans, straightforward implementation, and targeted checks.
Luna fits repetitive transformations, extraction, classification, short summaries, or other work with an obvious definition of done.

This is a routing strategy, not a guarantee that it will always be cheaper. OpenAI's subagent guide explicitly warns that every subagent does its own model and tool work, so parallelism can use more tokens than one agent. I only fan out work that is genuinely independent, keep agents.max_depth at its default of 1, cap concurrency, and ask workers to return distilled findings instead of raw logs.

A few more things that have helped:

Use the lowest reasoning effort that still gets the job done. Medium is a good default; low is enough for many well-scoped tasks, while Max and Ultra are expensive tools for the few tasks that justify them.
Keep AGENTS.md small and local. Codex includes project instructions in context. project_doc_max_bytes can cap how much it reads, but concise, scoped instructions are safer than blindly truncating a huge file.
Give the agent a narrow target. Name the files, constraints, acceptance criteria, and smallest relevant check. Less discovery means less context churn.
Do not paste giant logs into the main thread. Let a worker analyze them and return the relevant lines plus a short conclusion.
For API workflows, design for caching. Put stable instructions and tool definitions first, variable input last, reuse a prompt_cache_key, and monitor both cached_tokens and cache_write_tokens. GPT-5.6 charges for cache writes, so repeated reads have to justify them.
Measure instead of guessing. OpenAI's token-counting endpoint accepts the same messages, tools, images, and files as a Responses request, so you can estimate the real input before spending it.
Compact long-running agents. Responses API compaction carries forward useful state with a smaller context. For predictable tool-heavy steps, Programmatic Tool Calling can filter large results in code and return only the useful structured output to the model.

The useful rule is simple: buy expensive reasoning at decision points, then route bounded execution to the cheapest model that can reliably finish it.

Where I'm landing after a week

I'm not going to pretend I've put GPT-5.6 through its paces. I haven't. What I have done is form a plan:

Terra is going to become my default for real project work — the price-to-quality ratio is too good to ignore.
Luna takes over all the throwaway tasks I used to overpay for.
Sol Ultra is my weekend rabbit hole — I want to see if native subagents actually beat my hand-rolled setups on something bigger.

OpenAI is shipping roughly every seven weeks now, so I'll probably be writing one of these again before I know it. More once I've actually broken something — that's usually when the real review starts.

Sources and further reading

Written the week of July 2026, right after GPT-5.6's public release. Everything here is early-days impression from my own testing — I'll update as I put real miles on it.