Model Routing / Agent Systems

GPT-6 Sol vs. Luna vs. Astra: a routing policy for coding agents — and when local still wins

A routing policy for the actual GPT-6 lineup: Sol for discovery and coding, Luna for bounded high-volume processing, Astra when nothing else holds — each with a verification contract, and the lanes where a local 27B still beats all three.

Correction first, policy second

We previously published a routing guide for "GPT-5.6 Sol, Terra, and Luna." That naming was wrong: there is no GPT-5.6 generation and no Terra model. The real lineup is the GPT-6 family — Astra (September 3, 2026) and Sol and Luna (September 22, 2026). We deleted the social posts carrying the old names and kept this page as published history. This post replaces the policy with verified facts and labels everything we could not verify.

The verified lineup (as of 2026-09-26)

  • GPT-6 Astra — launched 2026-09-03 as the frontier lane: the most capable model in the family, positioned for the hardest reasoning work.
  • GPT-6 Sol — built for complex work, coding first among it. OpenAI states Sol makes about half as many mistakes as its 5.6-series predecessor, reaching Astra-level reliability at lower cost.
  • GPT-6 Luna — high-volume tasks with a clear goal: summarizing, extraction, quick answers. The only one of the three in the desktop app and on Free/Go plans.
  • Price: the 6-series API costs half of the 5.6-series Sol/Luna, attributed to caching and inference gains.
  • Availability: Sol and Luna are in ChatGPT Work, Codex, and the API for most paid accounts; Astra on Pro, Enterprise, and Business Premium.

Labeled uncertainty: the factuality and comparison claims above are OpenAI's own; the context window for Sol/Luna was not published at launch and we will not guess it. Public coverage: TechCrunch, 2026-09-22.

The routing policy

The lanes that mattered in our GPT-5.6-era policy survive intact — only the model names change, because the task shapes they map to did not:

  • Discovery lane → Sol. Unknown path, unknown failure mode, or a coding task where the spec itself is shaky. Give Sol an evidence target and an exit condition, not a step list. The completion contract is a finding, not a file.
  • Volume lane → Luna. Bounded, repeatable, high-count: extraction, summaries, classification, quick answers. The completion contract is a schema — Luna's job is to never be interesting. If a Luna output surprises you, that is a routing bug, not a model win.
  • Frontier lane → Astra. The problems that are only expensive until they are solved: novel architecture, deep debugging across systems, anything where the cost of a wrong answer dwarfs the token bill. Astra is the model you route to when the routing question itself is the hard part.

Verification contracts, per lane

The routing decision is half the policy; the other half is what you check:

  • Sol output: verify the claims — run the tests, execute the diff, re-derive the reasoning. Sol-grade code still needs a harness before it is trusted.
  • Luna output: verify the shape — schema validation, spot-check sampling, count reconciliation. Deep review of every Luna output means Luna was the wrong lane.
  • Astra output: verify the premise — the expensive lane earns review of whether the problem was framed right, since a confident wrong frame is the failure mode that survives every test suite.

Where a local model still wins

We route a 27B-class local model on a $1,400 mini-PC for real work, and the GPT-6 price cut does not close that gap. The local lane wins on: egress (nothing leaves the machine), marginal cost (tokens are electricity), and latency floor (no network hop). Our measured Qwen3.8-27B numbers — throughput sweeps, acceptance rates, the failures included — live in the public repo. The policy is not "local versus cloud"; it is: local for the volume lane when the task fits, cloud Sol/Astra for the lanes where capability is the bottleneck, Luna for cheap clerical volume that is not sensitive.

What we do differently this time

The retired guide failed on model names we did not verify. This post's facts were checked against the launch announcements and dated coverage the day of publication, every unverifiable claim is labeled, and the routing policy is ours — argued, not sourced. When the family changes again, the correction goes at the top of this page, the same way our benchmark re-baselines live beside the numbers they corrected.

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 Equalizer Bench: a 3B that can't write ffmpeg, the same 3B shipping video edits, and the bug our own benchmark caught

We benchmarked our own thesis: tiny model + deterministic guardrail layer vs raw capability. The curve is textbook, the trim trap is real, and the bench indicted our own product before anyone else could.

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.