When a model picker says Low, the natural assumption is “economy mode,” “easy jobs only,” or “not the serious setting.”
GPT-6 Astra makes that intuition look suspicious.
On third-party benchmarks, Astra Low beats GPT-5.6 Sol at xhigh on the aggregate Intelligence Index, opens a much larger gap on some agentic coding evaluations, and—on that benchmark workload—even costs less per task.[1]
So the obvious question is:
“Why not just leave Astra on Low forever?”
The useful answer is: Astra Low is a very strong default, but Low should be a starting gear, not a religion.
Start on Low. Move to Medium when a well-specified task is still missed or the reasoning chain becomes genuinely complicated. Reserve High and xhigh for the small fraction of jobs that justify them.
The badge says Low. The model did not get the memo.
1. The numbers first — Sol xhigh vs. Astra Low, Medium, High and xhigh
Artificial Analysis reported the following values 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 caution: an Intelligence Index score of 46 versus 44 should not be converted into “4.5% smarter.” It is a composite benchmark index, not a ratio scale like price or distance.
What we can say is that Astra Low scored 46 versus Sol xhigh at 44 under the same index, while Terminal-Bench v4.0 showed 42% versus 25%.[1]
Sol still wins SciCode at 57% versus Astra Low at 54%, so Low is not a universal strict upgrade.[1]
The story is more interesting than “new model wins everything.”
2. The pricing paradox — Astra costs 2.5× per token, yet Low was cheaper per benchmark task
OpenAI’s official API prices are straightforward.[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 token volume, Astra costs 2.5× as much.
The official Work/Codex credit rate has 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 benchmark task for Astra Low and $1.18 for Sol xhigh.[1]
That is possible because a higher token price can still produce a lower task bill if the model uses far fewer tokens.
On the same evaluation, Sol xhigh used roughly 20k output and 10k reasoning tokens per task. Astra Low used roughly 4k output and 938 reasoning tokens.[1]
It is the expensive taxi that drives straight to the destination versus the cheaper taxi that takes three sightseeing laps around the neighborhood.
Important: those $0.82 and $1.18 figures are Artificial Analysis weighted benchmark-task costs, not guaranteed Codex charges for your own repository.[1]
3. OpenAI itself says to start with Low or Medium
OpenAI’s Astra usage guide for Work and Codex explicitly separates model choice from reasoning effort.[8]
Lower effort is positioned as a useful starting point for faster responses or stretching an allowance. Medium balances response time with deeper reasoning. Higher effort is for genuinely difficult work.[8]
OpenAI also says that Astra at Low can outperform Sol at High and recommends trying Astra Low or Medium if Sol High has been working well.[8]
There is an even more important warning: higher effort does not always produce a better result.[8]
This is not an RPG shop where the most expensive sword automatically has the highest damage in every fight.
4. What should stay on Astra Low?
Low is easiest to standardize when the goal, files and acceptance criteria are already clear.
Examples include bounded implementation work, local code changes, refactoring, adding tests, routine review, investigating a known error, summarization, comparison tables, and repeated tasks governed by explicit rules.
For these jobs, more reasoning is not automatically more useful. Finishing correctly with a short reasoning path can produce better throughput than thinking ceremonially for three minutes before touching a file.
OpenAI also recommends checking instructions, files, connected apps and permissions before increasing effort. More reasoning cannot manufacture missing information or access.[8]
No file permission plus xhigh is still no file permission. The model has not unlocked clairvoyance.
5. When should Low become Medium?
If Low misses a clearly specified task once, do not immediately jump to xhigh. Medium is the first serious escalation.
Medium fits cross-file dependencies, ambiguous requirements, bugs with multiple plausible causes, architectural trade-offs, longer implementation plans, and repairs where failing tests need to be interpreted along the way.
Artificial Analysis shows Astra Medium at Intelligence Index 50, Terminal-Bench v4.0 at 49%, and $1.54 per benchmark task.[2]
That is meaningfully above Low’s 46 / 42% / $0.82, but it is still not the heaviest setting.
Medium is the boss-fight loadout for “Low was a little too casual, but we do not need to call in a tank.”
6. When do High and xhigh make sense?
High makes sense when Medium still misses the central issue, when architectural side effects are expensive, or when concurrency, performance, security or data migrations make a wrong decision costly.
Astra High scores 51 on the Intelligence Index, 54% on Terminal-Bench, and $1.72 per benchmark task.[3]
That is an improvement over Medium, but not a reason to lock every task to High.
xhigh is easier to justify for the hardest root-cause investigations, long autonomous jobs, multi-constraint redesigns and one-shot tasks where failure is expensive. It scores 53 overall and 60% on Terminal-Bench, highest among these five settings, at $2.31 per benchmark task.[4]
Using xhigh for everything is like commuting to the convenience store by helicopter.
Powerful? Yes. Possible? Sure. We should still discuss fuel.
7. Is Sol xhigh obsolete now? Not quite
Astra Low is attractive, but “Sol is dead” overstates the evidence.
First, benchmark winners differ. SciCode favors Sol xhigh at 57%, while Astra Low/Medium/High/xhigh score 54/54/55/56%.[1][2][3][4]
Second, Sol’s official per-token price is 60% lower than Astra’s. Astra Low came out cheaper per benchmark task because it used much fewer tokens on that workload. That outcome is not guaranteed for every real task.[5][6][1]
Third, real repositories contain things benchmarks do not: strange build systems, internal conventions, tools, permissions, huge histories, and failure modes unique to the project.
A benchmark is a map. It does not measure the height of the step outside your own front door.
8. A practical rule — start Low, escalate only when evidence says to
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 architecture | Astra High |
| High cannot close it / very high failure cost / hardest root cause | Astra xhigh |
| The hard part is solved and work returns to normal | Back to Low |
This avoids both mistakes: wasting allowance by starting everything at maximum effort, and wasting time by stubbornly repeating Low after the evidence says the task needs more reasoning.
Treat effort as a gear, not a personality trait.
9. Verdict — “Astra Low forever?” Default yes; fixed forever, no
Based on public data available on September 12, 2026, starting routine Codex work on Astra Low is a strong strategy.
It beats Sol xhigh on the aggregate Artificial Analysis index, has a large Terminal-Bench advantage, and costs less per task on that evaluation workload.[1]
OpenAI itself recommends Low or Medium as starting points and warns that higher effort is not guaranteed to improve the answer.[8]
But Low is not universal.
Low for normal work. Medium when ambiguity, complexity or a real miss appears. High when Medium cannot close the problem. xhigh for the hardest, highest-cost failures. Then go back to Low.
Do not let the name fool you.
Astra Low looks like economy mode and performs like a first-team starter.
Sources
- 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
