Short answer: starting every normal task on Astra Low makes sense, but don't lock it there. Start on Low, move to Medium if it misses, and save High and xhigh for the few jobs that really need them.
When a model menu says Low, you'd normally read it as "economy mode," "easy jobs only," or "not the serious setting."
GPT-6 Astra makes that guess look wrong.
On third-party benchmarks, Astra Low scores higher than GPT-5.6 Sol at xhigh on the overall Intelligence Index. On some coding-agent tests the gap is much bigger. And on that test set, it even cost less per task.[1]
So the obvious question is:
"Why not just leave it on Astra Low forever?"
The badge says Low. The model didn't get the memo.
1. The numbers first: Sol xhigh vs Astra Low, Medium, High and xhigh
Here is what Artificial Analysis reported when checked on September 12, 2026.[1][2][3][4]
| Setting | Intelligence Index | AutomationBench-AA | Terminal-Bench v4.0 | SciCode | AA cost per task | Output tokens/task | Reasoning tokens/task |
|---|---|---|---|---|---|---|---|
| GPT-5.6 Sol xhigh | 44 | 55% | 25% | 57% | $1.18 | ~20k | ~10k |
| GPT-6 Astra Low | 46 | 59% | 42% | 54% | $0.82 | ~4k | ~938 |
| GPT-6 Astra Medium | 50 | 65% | 49% | 54% | $1.54 | ~10k | ~3k |
| GPT-6 Astra High | 51 | 67% | 54% | 55% | $1.72 | ~12k | ~5k |
| GPT-6 Astra xhigh | 53 | 67% | 60% | 56% | $2.31 | ~17k | ~9k |
One warning first. Don't read 46 versus 44 as "4.5% smarter." The Intelligence Index blends several tests into one score. It isn't like price or distance, where ratios mean something.
What you can say is this: on the same index, Astra Low scored 46 and Sol xhigh scored 44. On Terminal-Bench v4.0, which tests an AI working through coding tasks on its own, the result was 42% versus 25%.[1]
Sol still wins SciCode, 57% to Astra Low's 54%. So Low isn't a better model in every way.[1]
"New model wins everything" would be a boring story. This one is more interesting.
2. The price puzzle: Astra costs 2.5× per token, yet Low was cheaper per task
OpenAI's official API prices are simple.[5][6]
| Model | Input / 1M | Cached input / 1M | Output / 1M |
|---|---|---|---|
| GPT-5.6 Sol | $4 | $0.40 | $20 |
| GPT-6 Astra | $10 | $1 | $50 |
For the same number of tokens, Astra costs 2.5 times as much.
The official Work/Codex credit rates use the same ratio. Astra is 250 / 25 / 1,250 credits per million input / cached-input / output tokens. Sol is 100 / 10 / 500.[7]
Yet Artificial Analysis measured $0.82 per task for Astra Low and $1.18 for Sol xhigh.[1]
How? A model with a higher price per token can still cost less per task if it uses far fewer tokens.
In the same test, Sol xhigh used about 20k output tokens and 10k reasoning tokens per task. Astra Low used about 4k and 938.[1]
Picture a pricey taxi that drives straight to the destination, and a cheap one that does three sightseeing laps around the block first.
One catch: the $0.82 and $1.18 are Artificial Analysis's weighted averages for its own test tasks. They are not what your own Codex work will necessarily cost.[1]
3. OpenAI itself says to start with Low or Medium
OpenAI's Astra guide for Work and Codex treats the choice of model and the amount of reasoning as two separate settings.[8]
Lower settings are a good starting point when you want faster answers or want your usage allowance to last longer. Medium balances speed and deeper reasoning. Higher settings are for genuinely hard problems.[8]
OpenAI also says Astra at Low can beat Sol at High, and suggests trying Astra Low or Medium if Sol High has been working well for you.[8]
And one more point: turning reasoning up doesn't always give a better result.[8]
This isn't an RPG shop where the priciest sword wins every fight.
4. What should stay on Astra Low?
Low is easiest to make your default when the goal, the files and the finish line are already clear.
Examples:
- building something with a clear spec
- small changes to existing code
- refactoring (tidying code without changing what it does)
- adding tests
- routine code review
- looking into a known error
- summaries and comparison tables
- repeated jobs that follow fixed rules
On these jobs, more thinking doesn't automatically help. Getting it right with a short chain of thought and moving on is often faster than pondering for three minutes before touching a file.
OpenAI also says to check your instructions, files, connected apps and permissions before turning reasoning up. More thinking can't conjure missing information or access.[8]
No file access plus xhigh is still no file access. The model doesn't gain X-ray vision.
5. When should Low become Medium?
If Low misses a clearly described task once, don't jump straight to xhigh. Medium is the first step up.
Medium fits these situations:
- dependencies that cross several files
- vague requirements
- bugs with more than one likely cause
- design trade-offs
- longer implementation plans
- fixes where you read failing tests as you go
Artificial Analysis shows Astra Medium at Intelligence Index 50, Terminal-Bench v4.0 49%, and $1.54 per task.[2]
That's clearly better than Low's 46 / 42% / $0.82, and still not the heaviest setting.
Think of Medium as the boss-fight loadout for "Low was a bit too casual, but we don't need to call in a tank."
6. When do High and xhigh make sense?
High is worth it when Medium keeps missing the core problem, when a design's side effects are expensive, or when a wrong call is costly to repair. Think concurrency, speed, security, or data migration.
Astra High scores 51 on the Intelligence Index, 54% on Terminal-Bench, and costs $1.72 per task.[3]
That's a step up from Medium, but not enough to lock every task to High.
xhigh is easier to justify for the hardest root-cause hunts, long jobs you leave running on their own, big redesigns with many constraints, and one-shot work where failure is expensive. It scores 53 overall and 60% on Terminal-Bench, the top of these five settings, at $2.31 per task.[4]
Using xhigh for everything is like going to the convenience store by helicopter.
Powerful? Yes. Possible? Sure. But let's talk about fuel.
7. Is Sol xhigh obsolete? Not quite
Astra Low looks great, but "Sol is dead" claims more than the data shows.
First, the winner changes from test to test. On SciCode, Sol xhigh gets 57%, while Astra gets 54% at Low and Medium, 55% at High and 56% at xhigh.[1][2][3][4]
Second, for the same number of tokens, Sol's official price is 60% lower than Astra's. Astra Low came out cheaper per task because it used far fewer tokens on that test. Real work may not turn out the same way.[5][6][1]
Third, real projects have things benchmarks don't: odd build setups, house rules, tools, permissions, huge histories, and failure modes of their own.
A benchmark is a map. It doesn't measure the step outside your own front door.
8. A practical rule: start on Low, move up only when something goes wrong
A simple ladder is enough.
| Situation | Recommended setting |
|---|---|
| Starting an ordinary new task | Astra Low |
| Clear instructions and access, but the core requirement was missed once | Astra Medium |
| Medium still misses the central issue / difficult design | Astra High |
| High can't close it / failure is very costly / hardest root cause | Astra xhigh |
| The hard part is solved and work is back to normal | Back to Low |
That way you avoid two mistakes: burning your allowance by starting everything at maximum, and wasting time by repeating Low after it has clearly missed.
Think of reasoning level as a gear, not a personality.
9. Verdict: "Astra Low forever?" Yes as the default, no as a fixed rule
Going by the public data available on September 12, 2026, starting everyday Codex work on Astra Low is a strong strategy.
On the Artificial Analysis tests, it beats Sol xhigh on the overall index, leads by a wide margin on Terminal-Bench, and costs less per task.[1]
OpenAI itself recommends Low or Medium as starting points, and warns that higher reasoning doesn't guarantee a better answer.[8]
But Low isn't all-purpose.
Low for normal work. Medium when something is vague, complicated, or actually missed. High when Medium can't close it. xhigh only for the hardest, costliest failures. Then back to Low.
Don't let the name fool you.
Astra Low looks like economy mode and plays like a first-team starter.
References (8)
- Artificial Analysis — GPT-6 Astra (low) vs GPT-5.6 Sol (xhigh) artificialanalysis.ai
- Artificial Analysis — GPT-6 Astra (medium) vs GPT-5.6 Sol (xhigh) artificialanalysis.ai
- Artificial Analysis — GPT-6 Astra (high) vs GPT-5.6 Sol (xhigh) artificialanalysis.ai
- Artificial Analysis — GPT-6 Astra (xhigh) vs GPT-5.6 Sol (xhigh) artificialanalysis.ai
- OpenAI API — GPT-6 Astra Model developers.openai.com
- OpenAI API — GPT-5.6 Sol Model developers.openai.com
- OpenAI Help Center — ChatGPT Rate Card (Business, Enterprise/Edu credit-based pricing) help.openai.com
- OpenAI Help Center — Managing usage with GPT-6 Astra in Work and Codex help.openai.com
