How to Choose the Three GPT-6 Models: A Practical Guide to Three Knobs, Failure-Cost Calculus, and Cost-per-Success Math

After several rounds of hands-on testing plus careful cross-reading of the GPT-6 docs, one number keeps coming back: the flagship Astra costs roughly 100x as much per token as Luna for the same input. But the real budget killer is not “using Luna for the wrong things”—it’s “using Astra where it shouldn’t have been used in the first place.” This article walks through that entire decision, and at the center of it there are really only three knobs to turn.

I. Three Knobs: Model, Reasoning Effort, Speed

The most useful mental model for GPT-6 isn’t “pick one model.” It’s “adjust three switches together.” Those three are:

Knob	Choices	What it changes
Model	Astra / 6.1 Sol / Sol / Luna	Per-token price, context window, ceiling on reasoning depth
Reasoning effort	low / medium / high / xhigh / max	How much the model “thinks” (output token volume)
Speed	Standard / Fast / Ultrafast	Per-token multiplier and tail latency

The instinct to crank all three to max is wrong. Speed and reasoning depth are independent switches—Fast mode just makes output generation faster; it does not make the model think harder. Push all three to max and the bill gets scary without any real improvement.

A useful opening question: how much intelligence does this task actually require? Once you’ve answered that, the model choice falls out; once the model is chosen, the rest of the switches have a basis.

II. Picking a Model: What Astra, 6.1 Sol, Sol, Luna Each Cover

Aligning the GPT-6 family against OpenAI’s official documentation produces this table:

Model	Positioning	Key data	Supported reasoning efforts
GPT-6 Astra	Strongest intelligence, flagship	1,050,000-token context; 98% on FrontierMath Level 4; SOTA on OSWorld, browsing, software engineering	low / medium / high / xhigh / max
GPT-6.1 Sol	Near-Astra performance at roughly 1/5 the price	On DeepSWE v1.1, ties Astra while clearly cutting per-task cost	low / medium / high / xhigh / max
GPT-6 Sol	Smooth migration target for existing users, mid-range workhorse	“Fills the slot the old Terra used to occupy”	none / minimal / low / medium / high / xhigh
GPT-6 Luna	Cheapest, built for high-frequency repetitive tasks	Input price under DeepSeek-V4.1 Flash; at max effort matches 5.6-Sol mid-range accuracy at ~1% of the cost	none / minimal / low / medium / high / xhigh

Engineering details worth calling out specifically:

1. 6.1 Sol is not a small upgrade of 6 Sol—it’s a slot shift. The “near-flagship” position moved up; the old 5.6 Sol slot is now filled by 6 Sol; the actual “Astra-but-cheaper” option is 6.1 Sol. This is also why OpenAI’s docs caution that mis-tiered Sol often costs more than just moving to Astra.
2. Astra is expensive per token but not necessarily expensive per task. The official phrasing includes the counterintuitive point that “Astra achieves stronger results with fewer output tokens on multiple benchmarks, so per-task API cost can land lower than earlier models.” Translation: high per-token price, but faster, better, fewer output tokens—cost per task can stay controlled.
3. Cache hit discounts became genuinely valuable on the 6 series. Cached input tokens get an official 90% discount. GitHub Copilot, after switching on this mechanism, saw the prompt-token reprocessing share drop by over 50% across billions of requests—cache tuning ends up mattering more than model choice for high-volume workloads.

A decision formula more reliable than reading price tables

The two-dimensional rule of thumb:

Cost of one mistake × how many times the task runs = the basis for picking a model

• Rare task with very high cost-per-mistake—pick Astra.
• Runs thousands of times a day with clear rules (field extraction, classification, fixed-format summarization)—pick Luna (or even 6 Sol + none effort is enough).
• Day-to-day coding and research—pick GPT-6.1 Sol, start at medium effort, push up only when needed.

This rule beats “look at the leaderboard” because it folds the task itself into the decision.

III. Reasoning Effort: Where to Set the Five Gears

Once the model is chosen, the bill and the latency are dominated by reasoning effort. Astra and 6.1 Sol support five gears:

low → medium → high → xhigh → max
(fast, cheap)                                (slow, expensive)

The other two models (Sol, Luna) additionally support none and minimal. none is the traditional non-reasoning mode—best for extraction, rewriting, and classification work that doesn’t need to “think.”

What each gear is actually used for (cross-referenced to AutomationBench / DeepSWE v1.1 benchmarks)

Effort	Use case	Engineering equivalent
low	Extraction, field alignment, light edits	Non-reasoning mode + a little thinking
medium	Planning a feature, comparing options, writing docs	Default; covers most day-to-day work
high	Tricky debugging, deep analysis, code review	6.1 Sol · high ≈ Astra · light
xhigh	Multi-file refactoring, complex architecture judgment	6.1 Sol · xhigh ≈ Astra · medium
max	Pushing for the last 1–2% of accuracy	Highest spend, marginal returns not guaranteed

One counterintuitive but important point

On GPT-6 Sol, going from xhigh to max yields tiny accuracy gains but a big price jump. This affects agent-heavy users’ bills disproportionately. A reliable pattern: run Sol on high/xhigh as the sweet spot; bumping to max rarely pays off better than just switching to Astra.

Cross-gear switches don’t blow the cache

A key 6-series improvement: changing reasoning effort mid-conversation does not, by default, invalidate the prompt cache. What this enables:

• Run the bulk of the conversation on medium, bump effort only on the hard steps;
• OpenAI recommends doing this with the configuration_update input item rather than re-issuing the request—preserves the original prompt prefix and keeps the cache warm.

For long agent chains this is significant—the pre-6 series behavior was that any gear switch invalidated the cache, driving token spend to climb steeply.

IV. Speed: The Third Knob People Ignore

Fast / Ultrafast modes are easy to mistake for “make the model think harder.” They don’t. They only adjust speed, not reasoning depth. The relationships:

Standard = default speed, standard per-token price
Fast     = faster response, clearly higher per-token price, good for real-time chat / IDE completion
Ultrafast = fastest, most expensive, best for high-frequency in-IDE round trips

Engineering boundaries to keep in mind:

• GPT-6 Astra Fast mode has no latency SLA; Ultrafast supports only US data residency.
• GPT-6.1 Sol Fast supports EU data residency; Ultrafast supports US / EU / global.
• For EU-facing compliance work, default to 6.1 Sol + Fast rather than Astra—data residency is a hard constraint.

V. Prompting: Goals Over Step-by-Step Scripts

Even after picking the right model and setting the right effort, most teams don’t actually reduce their bill. The root cause is usually prompts written wrong. The contrast is sharp:

Approach	Example
Step-locked	Open this specific sheet, field order, length of every paragraph
Goal-defined	This weekly report is for the boss, must read in 3 minutes, focus on risks and upcoming decisions, figures traceable to source

The step-locked version breaks the moment the sheet structure changes—the model obediently follows the now-stale instructions. The goal-defined version knows the actual intent and finds a new path to it.

The four things to always include in a prompt:

1. The desired output (not the workflow)
2. The audience (sets density and wording)
3. Background and constraints (context, but kept lean)
4. A concrete definition of “done”

Spell out the decision boundary too

A common long-task failure mode is “ask me about everything.” Patterns like that pile up and the session stalls. The prompt should draw a clear line: what the model may decide on its own, and what requires pre-approval from you.

Example: regarding project organization, if the model intends to change scope, ask first; for routine decisions (file naming, internal function signatures, test coverage), let the model continue.

Another frequent failure is undefined “done.” In the prompt, decompose “done” into four things:

1. Made the change
2. Ran it
3. Checked the results
4. Fixed any failures

And require a short handover note—a list of what changed, what was verified, what still needs your attention. One team formalized this “passed vs not-yet-tested” listing approach and found it makes task progress scannable at a glance, far better than a vague “I’m done.”

VI. Skill and AGENTS.md: Externalize the Reusable Rules

As prompts get longer, two problems get sharper: every conversation repeats the same setup (wasted tokens), and rules scattered across conversations drift apart. The 6-series ecosystem gives two engineering fixes:

• Skill: a small reusable instruction unit with an explicit trigger condition—“read this Skill file under scenario X”; written concise and scope-bounded.
• AGENTS.md: a document at the repo root, read by the model at startup. Defines safety procedures, e.g., “use throwaway data for local tests, never touch production systems where real users run.”

The relationship: Skill controls how a tool gets used, AGENTS.md controls where actions are taken.

VII. Long-Task Points: Hours-to-Days Sessions

GPT-6 brings real long-task capability—sessions running for hours or days. Engineering four rules worth pinning down:

First, you can course-correct mid-run, but there is no undo. On the API, you can submit a correction that gets queued behind the current tool. It will not cancel a running tool, and it will not roll back completed actions. So “that doesn’t count” doesn’t work here—only updating the upstream prompt or opening a new session will change direction.

Second, don’t block on slow tasks. While your application runs a slow test, the model can work on unrelated things (read the next section of code, spawn a subagent to investigate another module), and return later. Any action that depends on that slow result must still wait—make this explicit in the prompt, otherwise the model “optimistically assumes” and gives confidently wrong output.

Third, delegate to subagents whenever possible. The 6-series API supports multi-agent workflows—hand independent tasks to subagents in parallel (e.g., simultaneously audit multiple modules of a codebase, then aggregate the result into one final answer). That’s the most direct way to break a “long wall” into parallel short tasks, and the cleanest escape from a single session timing out.

Fourth, pre-agree on pause conditions. Codex in RA mode will pause mid-run and ask you “what’s next?” If you’re not present, it stalls on that line. Recommended: predefine a rule—“if I send continue, keep going; otherwise stop and wait for me”—don’t let the model decide “I’ll keep guessing.”

Computer-Use Principle

All three GPT-6 models can drive desktop/web apps directly—even apps with no exposed API, the model can read the screen, click buttons, and fill forms. One golden rule: use the API if there is one; use an existing tool if there is one; turn on Computer Use only when GUI interaction is actually required. Always pick the simplest, most reliable method for each step—GUI is the most expensive and the least controllable.

VIII. Pre-Launch: Three Items, Three Numbers

Before going live, compressing “what most affects the bill” is the highest-priority engineering task. Three items:

1. Prompt cache: get repeated prefixes down to the 95% discount. Concrete steps: stable instructions and reference material go first, task-specific details go last, stop churning tool definitions. OpenAI now ships cache monitoring and diagnostic tools that show hit rate and explain misses—run the cycle of “find the miss, fix the prefix, raise the hit rate.”
2. Trim the context. Long-context cost is not linear (on the attention layer it approaches O(n²) pressure); cramming the full nominal 1M context slows the model visibly and steals resources from the model itself. Rule of thumb: less but sharper—keep only the evidence the task actually needs; for very long sessions, use compaction or external storage.
3. Watch three numbers: task success rate, latency, cost per successful outcome. These are the metrics that actually evaluate whether launch is working, not “how many tokens did we burn today.” The third one in particular deserves its own tracking—see the next section.

IX. The Math: Why a 5x-More-Expensive Model Can Be Cheaper per Success

Many teams oscillate between “go cheap” and “go expensive,” only looking at unit price. Unit price isn’t budget. The following hypothetical numbers make that mistake immediately visible.

Case 1: Cheap model costs $1 per run with a 10% success rate—run it 10 times to get one success, cost per success = $10.

Case 2: Expensive model costs $5 per run with a 90% success rate—on average, cost per success ≈ $5.56.

So unit price looks 5x bigger, but cost per success is barely over half. OpenAI itself has referenced this in internal retrospectives—median internal Coding Agent daily spend already exceeds $600, 90th percentile over $7,000; in that regime “unit price” matters far less than “success rate × cost per attempt.”

But the converse also holds: if the expensive model only nudges success rate up 5 points over the cheap one, it’s not worth it. The empirical method:

Run a representative batch on the cheap model to get a baseline success rate; run the same batch on the expensive model and directly compare cost-per-success. Don’t let leaderboards make your decisions.

X. Back to the Opening Question

Back to that 100x price gap at the top. My reading:

• 70% of optimization room comes from refining reasoning effort; only 30% from model selection.
• Most teams, on first contact with GPT-6, bundle “which model” and “which gear” into one decision. The result: “expensive but wrong” or “cheap but afraid to use.”
• The reliable workflow: first pick a model (using the cost-of-one-mistake × repetition formula), then pick the gear (start at medium, escalate only if needed), finally pick the speed (use Fast/Ultrafast to compress latency). Run all three and the typical bill drops 40–70%.

A workstation-friendly checklist to close on:

1. Does this task have to be right on the first try?
   - Yes → GPT-6 Astra + xhigh / max
   - No  → continue

2. Does this task run thousands of times a day with clear rules?
   - Yes → GPT-6 Luna + high (or max, depending on factual-accuracy needs)
   - No  → continue

3. Is this task complex but tolerant of 5–10% errors?
   - Yes → GPT-6.1 Sol + high / xhigh
   - No  → back to 1

4. Is this a simple extraction / classification / rewrite?
   - Yes → GPT-6 Sol · reasoning.effort = none
   - No  → back to 3

A few code-level hard rules cover the remaining 20%:

• On a first run of any task, try Astra · medium or 6.1 Sol · high first to establish a baseline before cranking effort up.
• Cross-gear switches belong in configuration_update, not in re-issuing the request.
• For batch / long-context scenarios, default to prompt cache on; tune TTL through the monitoring dashboard.
• If the model keeps asking for approval, add a system prompt line like “if you have authority to act, proceed; no confirmation needed”—don’t solve it by maxing effort.
• For EU-compliance projects, default to 6.1 Sol, not Astra.

Bringing it all together: doing GPT-6 well isn’t about getting any single switch right—it’s about wiring up model, effort, speed, prompting, caching, decision boundary, definition-of-done, and subagent delegation in one go. Each one is simple in isolation; together they’re how you take back what’s yours inside that 100x price gap.