Model Routing / Agent Systems

GPT-5.6 Sol vs. Terra vs. Luna: an evidence-based routing policy for coding agents

The practical GPT-5.6 split is Sol for discovery, Terra for bounded execution, and Luna for repeatable processing - with a different verification contract for each.

Executive summary — TL;DR / BLUF

  • Sol High is the discovery lane. Use it when the path, owner, or failure mode is still unknown. Give it an evidence target and an exit condition.
  • Terra Medium is the execution lane. Use it after the decision is made and the work has explicit files, behaviors, boundaries, and acceptance gates.
  • Luna is the processing lane. Use it for narrow, repeatable, high-volume tasks whose outputs can be checked by a schema, deterministic test, or sample audit.
  • Max is an escalation, not a default. DataCurve's current DeepSWE result shows a modest observed gain over High at roughly 2.4 times the estimated task cost, with slightly overlapping confidence intervals.
  • Fast and Ultra are separate controls. Fast is a higher-credit option for supported models. Ultra uses maximum reasoning and may add agents for eligible users.
  • Current usage note: eligible Plus and Pro personal accounts may be offered an instant reset that restores both five-hour and weekly Work/Codex usage. The reset starts a new weekly schedule; it does not add a separate allowance.

BLUF: do not choose a GPT-5.6 model by prestige. Route by uncertainty and by the cost of proving the answer is correct.

Model routing is a completion-contract problem

The important difference between Sol, Terra, and Luna is not simply “smart, cheaper, cheapest.” Each model is most reliable when the agent is given a different definition of done. Sol needs a research boundary. Terra needs a specification. Luna needs a validator.

ModelJobCompletion contractFailure to design around
SolDiscoverQuestion, evidence target, protected boundaries, and stop conditionContinuing after the useful answer or widening scope without evidence
TerraExecuteApproved plan, named files, acceptance gates, and required testsTreating unresolved uncertainty as if it were an implementation detail
LunaProcessExact schema, examples, deterministic validator, and retry ruleLetting a cheap silent error propagate through the pipeline

OpenAI's current model-selection guidance describes the same capability ladder in product terms. The engineering move is to turn that ladder into a contract-and-verifier architecture.

What our first week changed

We used the three lanes across research, evaluation, websites, and agent systems. This was operational observation, not a controlled benchmark, so the claims below are field notes rather than universal rankings.

Sol was best when the work had to discover its own path. It carried long investigations and found consequential mistakes that a narrower pass could have missed. Its failure mode was persistence without a stopping rule: once the answer existed, it could keep exploring. The improvement was not a cleverer prompt. It was an explicit evidence target, protected boundaries, and a rule for when to stop.

Terra was strongest when the acceptance contract was already explicit. Given a bounded scope, it produced specific adversarial findings and clear approve-or-hold judgments. When hidden discovery remained, however, the apparent execution task was actually routed too early.

Luna was reliable when the output boundary was machine-checkable. Exact-schema JSON, extraction, metadata, and other constrained jobs repeatedly landed inside the requested shape. Some runs benefited from an explicit completion reminder. The model was not the whole control system; the schema and validator were.

A reference router for coding agents

def route(task):
    if task.uncertain or task.crosses_subsystems:
        return ("Sol", "high", "evidence + exit condition")
    if task.specified and task.bounded:
        return ("Terra", "medium", "acceptance gates")
    if task.repeatable and task.cheap_to_verify:
        return ("Luna", "lowest sufficient", "schema + validator")
    return ("Sol", "high", "evidence + exit condition")

The fallback matters. If work is neither bounded nor cheap to verify, it probably still contains discovery. Route that uncertainty deliberately before paying an executor to guess.

First constrain the router to the product surface

A routing policy cannot select a model the current product does not expose. “GPT-5.6” means different controls in ChatGPT, Codex, and the API, so record the surface as part of the route.

  • Standard ChatGPT: OpenAI's current rate card says Medium, High, and Extra High all use GPT-5.6 Sol at the same per-message credit rate. Instant may switch a request to Medium.
  • ChatGPT Work and Codex: the current rate card lists Sol, Terra, and Luna with token-based credit rates. Availability and included limits still depend on the account and plan.
  • API: the three models support none, low, medium, high, xhigh, and max reasoning effort.

Check the current ChatGPT rate card and API model catalog when implementing the policy. A model-picker screenshot is not an architecture contract; availability can change independently across products and plans.

Escalate reasoning effort only after diagnosing the failure

Reasoning effort is a second routing dimension. Higher effort gives the same model more room to explore, use tools, and revise, but it cannot repair a wrong premise, missing permission, broken test environment, or underspecified deliverable.

Sol effortDeepSWE v1.1 scoreEstimated cost per task
High69.4%$3.47
Extra High70.7%$4.70
Max72.7%$8.39

Those July 9, 2026 values come from DataCurve's raw DeepSWE v1.1 artifact. High to Max adds 3.3 observed percentage points while estimated task cost rises from $3.47 to $8.39 - about 2.4 times. The set contains 113 tasks, and the reported 95% confidence intervals for High and Max overlap slightly.

That makes Max a diagnosed escalation: use it after High failed because exploration ended too soon or a hard branch was not followed. It is poor compensation for a bad brief. The benchmark is evidence from one harness, not a guaranteed gain on a particular repository.

Keep three cost systems separate

API price, benchmark-estimated cost, and Codex credits are not interchangeable units. OpenAI currently publishes API prices per million input/output tokens of $4/$20 for Sol, $2/$12 for Terra, and $0.20/$1.20 for Luna. The current Business and Enterprise/Edu Work/Codex rate card lists input/cached-input/output rates of 100/10/500 credits for Sol, 50/5/300 for Terra, and 5/0.5/30 for Luna.

A benchmark's dollars-per-task number belongs to its own harness. A real agent run also pays for context, cached input, tool output, retries, validation, and any parallel branches. Use the current ChatGPT Work and Codex rate card for the plan it covers, then measure verified completion cost in the system itself.

P.S. Current five-hour and weekly limits

OpenAI's current reset guidance explicitly treats Work and Codex as having five-hour and weekly usage allowances. Eligible Plus and Pro personal accounts can buy an instant reset from Usage settings, subject to account availability. The option is not available on Free, Go, Business, Enterprise, or Edu plans.

A completed purchase restores both five-hour and weekly usage immediately. It pulls the normal weekly allowance forward instead of adding another entitlement, and it cannot be banked or scheduled.

The new weekly period begins with the first Work or Codex request after the reset. The next automatic weekly reset is seven days after that request, not necessarily seven days after payment. Usage credits are a separate pay-as-you-go balance.

Do not collapse Max, Fast, and Ultra into one ladder

  • Max expands reasoning effort for one GPT-5.6 model.
  • Fast exists as a higher-credit Codex option for supported models. The current rate card does not identify which GPT-5.6 models support it or publish a GPT-5.6 multiplier, so do not hardcode either claim.
  • Ultra uses maximum reasoning and may run additional agents for eligible users. It is not a separate model row; credits still depend on the chosen model and the tokens produced by the task and its agents.

Ultra earns its overhead when branches can produce independent evidence: separate subsystem reviews, competing implementations, or research questions without shared mutable state. It wastes context and creates collision risk when every worker needs the same files, decision, or sequential dependency.

The verifier belongs in the routing table

LaneRequired evidenceTypical verifier
Sol discoveryReproduction, cited investigation, or decision recordTest, source audit, or independent review
Terra executionBounded diff plus every acceptance gate named in the planTargeted tests, lint, type checks, and diff review
Luna processingStructured output conforming to the requested contractSchema, deterministic check, sample audit, or stronger-model review
The economical model is the one with the lowest total cost to a verified result, not the lowest token price.

Implementation checklist

  1. Classify the task by uncertainty: discovery, bounded execution, or repeatable processing.
  2. Record the product surface and verify that the intended model and effort control exist there.
  3. Attach the right completion contract: evidence plus exit condition, acceptance gates, or schema plus validator.
  4. Begin unclear hard work with Sol High. Escalate to Max only after diagnosing insufficient exploration.
  5. Hand decided work to Terra and high-volume verifiable units to Luna.
  6. Measure verified completions, retries, review time, latency, and token or credit use - not output volume alone.

This policy makes model choice auditable. A failed task can be traced to the route, contract, environment, or verifier instead of being dismissed as “the model was not smart enough.” For the owner/operator version focused on approval and business risk, read the PuenteWorks companion: use the cheapest AI model that can reliably finish the job.

FAQ

Is Sol always the best GPT-5.6 model for coding?

No. Sol is the strongest discovery route when the path is unclear. Terra is often the better engineering route once a plan is bounded, and Luna is more efficient for narrow transformations with deterministic validation.

Should coding agents default to Sol High or Max?

Start difficult, uncertain work at Sol High. Escalate to Max only after identifying that insufficient exploration—not a bad brief or environment—caused the failure.

Can Luna run a complete coding-agent session?

It can run a constrained session, but its strongest system role is often inside a workflow: classification, extraction, naming, summaries, and other repeated work whose output can be checked automatically.

Is Ultra more intelligent than Max?

No. Max increases reasoning effort for one model. Ultra coordinates multiple agents. Parallelism helps only when the work can be decomposed without duplicating context or colliding on shared state.

What happens when I buy an instant Work or Codex reset?

For eligible Plus and Pro personal accounts, it immediately restores both five-hour and weekly usage. The next weekly period starts with the first request afterward, and the next automatic reset lands seven days after that request. It is not extra banked usage.

Sources and limits

Fact-checked September 4, 2026. Product availability, prices, rate cards, usage limits, and benchmark results can change. The field notes are observational, and the routing policy should be validated against your own repositories and verification costs.

Work with Kyanite

Want this working in your environment?

If this post describes a Kyanite tool or result you need, implementation help can cover setup, advising, docs, examples, checks, and a usable handoff.

Fit boundary

Kyanite offers help grounded in its tools, products, and build practice. Broader consulting routes through PuenteWorks.

Keep following the system.

The One-Line Bug That Crashed Our Fast Lane: finding, fixing, and measuring a speculative-decoding crash on a $1,400 mini-PC

Spec decoding crashed our fastest lane on day one. The bug was one missing line in our fork; the fix bought +17.7% and a surprise about draft quantization.

Two models, one $1,400 mini-PC: the paired numbers, failures included

A 35B reasoning model now runs shoulder to shoulder with our daily 27B on one $1,400 box, at the same time. Every number paired, same problems, same machine. The failures are in here too.

How I became a forward deployed engineer without a software engineer title

The title is new; the work is old. Twelve years of enterprise deployments plus public, measured AI work. The honest path, artifacts included.

Evals are the FDE skill nobody lists: my 495-trial public benchmark

The market says it cannot find people who can build AI evals. The skill is learnable and I published mine: 495 trials, certified floors, sabotage cell, open source.

Forward deployed vs solutions engineer vs implementation vs customer engineer: the title decoder

Four titles, one job family, different coding bars. A decoder that reads any posting and tells you what you are actually signing up for.

What does a forward deployed engineer actually do? A demo on a $1,400 mini-PC

The straight answer, then the receipts: the whole FDE job run end to end on a $1,400 mini-PC, with public evals.

The Delegation Card: we asked a $1,400 mini-PC to take our jobs

Not is-it-smart but can-you-hand-it-work-and-walk-away. 495 certified trials, then re-validated at deeper n after the product changed: 965 total, floors to 92.8%.

Qwen 3.8 27B on Strix Halo: the complete measured story

Every dial measured, every number public: the frozen optimal config for a 27B on a $1,400 mini-PC.

Lab Notes: the measured-knees method for reasoning effort

A methods note on reasoning-effort calibration. Thinking rescued 15/40 hards vs 4/40 off. On easy tasks it bought nothing. Publish the knee.

Lab Notes: 67% LiveCodeBench-30 on a $1,400 rig

20/30 = 67% LiveCodeBench-30 on a $1,400 mini-PC. Wilson 95% CI 49-81%. Easy 10/10, medium 8/10, hard 2/10. n=30 public subset. Not the card.

Lab Notes: we reverted a llama.cpp regression

We found a llama.cpp regression and reverted it. n=6 battery on a $1,400 rig: 0/6 slashes before, 5/6 after. Same Q4_K_XL. Not a quant story.

Lab Notes: 93% HumanEval on a $1,400 rig

28/30 = 93% HumanEval on a $1,400 mini-PC. Qwen3.8-27B Q4_K_XL. Temp 0, thinking off. Failures: 50 and 145. Raw log linked.

Lab Notes: the model that can't forget but can't remember

The number first: this model is 75% not a transformer. 48 of 64 layers keep a running state. On a $1,400 rig, load 198k once (1818s), then query in 9-27s.

Lab Notes: the basin was a bug

We published a basin. The serving binary was the hole. After the c7d8722 revert: 6/6 HIT at 198k. n=1 map of the fixed build.

Lab Notes: the KV verdict

The q8-to-q4 KV question from night 1 got its paired answer: same accuracy, zero tripwires, half the cache. Plus the label we had to correct in public when the server's counter beat our estimate.

Lab Notes: verdict night

A $1,400 mini-PC serving a 27B at 262k context asks one question: does capping thinking cost accuracy? The paired answer, the invalid first attempt it survived, and the doctrine that followed.

One mini-PC, one night, and the numbers that argued with themselves: tuning Qwen3.8-27B on Strix Halo

A fully measured night-and-evening of tuning a 27B dense model on a Strix Halo mini-PC: the honest bands, the reversal, the crash doctrine, and the EC detective story.

Agents need verifiable tools, not better prompt theater

The useful agent pattern is not a prettier prompt. It is a tool surface the agent can call, inspect, verify, and revise.

Repo history is a product signal

A repo is not just storage. It is evidence of decisions, repairs, release behavior, naming drift, test gaps, and what the builder actually knows how to finish.

Implementation help is part of the product surface

A useful open-source tool still needs a path from public repo to working environment. That path is product work, not an afterthought.

Why Kinocut matters

Kinocut gives AI agents callable handles on timelines, effects, Hyperframes, and finished media at kinocut.dev.

Infinite monkeys, LLMs, and the room around the machine

The argument behind the video: output quality is not just probability. It is architecture, filters, and human taste.

What a working AI tool needs before people can use it

A practical checklist for turning a working tool, workflow, or rough app into something other people can understand, install, and use.

MCP server implementation checklist

The checklist Kyanite uses to decide whether an MCP server is a toy, a usable tool, or something worth implementing.

Repo archaeology turns history into proof

Why commit history is one of the strongest proof sources for learning diagnostics, implementation help, and engineering trust.

AI discovery needs more than a sitemap

What Kyanite adds so search engines and AI assistants can understand the tools, products, proof, and support path.