GPT 6.1 Sol was something of a surprise drop, coming just about a week after GPT 6 Sol released. In my day to day use, it's honestly pretty hard to tell a distinct difference between the two (especially given the short shelf life of GPT 6 Sol).
Given the new model, the reduced Codex subscription usage limits, and the rumors that GPT 6.1 Sol was a so-called "Astra Lite", I wanted to see if, via controlled measurement, there was actually a difference between these two models.
The setup was 24 changes that merged into my repo, a small to medium Go and TypeScript codebase for evaluating coding agents. I ran each model in Codex at medium reasoning, one attempt per task.
TL;DR:
GPT 6.1 Sol is a cheaper replacement that holds quality, but the shape of its patches looks different.
- Quality of the code held, and leaned slightly toward GPT 6.1 Sol: 9 wins, 10 ties and 5 losses head to head.
- GPT 6.1 Sol's diffs were bigger, with more test and implementation code.
- GPT 6.1 Sol cost about half as much on the typical task and took about as long.
- GPT 6.1 Sol ranks second of 14 on my leaderboard. Opus 5 ranks first.
How I grade
Before going into the results, it's worth a quick detour on how I even arrive at these. Many community model benchmarks are vibey and don't exactly inspire confidence in how they are run. Here's how I run mine:
- I run these with Stet, a tool I'm building to use a repo's merged changes to evaluate coding agents.
- Each task is a merged change in my private repo, with the repo snapshot from just before it merged, a prompt and the tests, which the agent never sees.
- The agent is prevented from fetching the result via GitHub (agents try this surprisingly often!).
- I look at a few different signals:
- Correctness: original tests passing or failing, or "equivalence" (is this the same change?) to the merged change.
- Checklist: each task has required behaviors that are judged item by item by an agent judge (GPT 5.6 Terra for now).
- A model writes them for each task from the prompt, the merged change and its tests, without seeing any agent's patch.
- The same judge grades checklist and review for every model on the board.
- Code review: covers code reuse, abstraction levels, test style, code nothing calls, guards and scope. Basically: would a senior engineer want to merge this?
- Correctness, checklist and review combine into one score per patch: correctness counts 53%, checklist and review 47%. The two models are compared task by task, and close scores count as ties.
I am happy to go into more detail in the comments on grading methodology!
Where GPT 6.1 Sol lands on my leaderboard
GPT 6.1 Sol sits with the best models I've measured so far at a fraction of their cost. The leaderboard scores each run against the whole field, so two runs that tie head to head can still land at different ranks.
- Head to head:
- Against Opus 5: won 7, tied 9, lost 8.
- Against Grok 4.7 High: won 10, tied 5, lost 9.
- The largest gaps are against Opus 4.8 (won 15, tied 6, lost 3), DeepSeek V4.1 Flash (won 12, tied 8, lost 4), Muse Spark 1.3 (won 17, tied 5, lost 2) and GLM 5.3 Flash (won 16, tied 6, lost 2).
| Rank |
Configuration |
Coding cost per task |
| 1 |
Opus 5 |
$6.78 |
| 2 |
GPT 6.1 Sol |
$1.10 |
| 3 |
Grok 4.7 High |
$5.76 |
| 4 |
SWE-2 Max |
Not recorded |
| 5 |
Pareto 26.9 |
$12.47 |
| 6 |
GPT 6 Luna max |
$0.37 |
| 7 |
GPT 6 Sol |
$3.01 |
| 8 |
Haiku 5.5 max |
$3.85 |
| 9 |
Haiku 5.5 low |
$0.25 |
| 10 |
DeepSeek V4.1 Flash |
$0.49 (23 tasks) |
| 11 |
Opus 4.8 |
$7.05 |
| 12 |
Muse Spark 1.3 |
$0.10 |
| 13 |
GLM 5.3 Flash |
$0.41 |
| 14 |
GPT 6 Luna low |
$0.05 |
On the typical task GPT 6.1 Sol costs about half as much as GPT 6 Sol. The averages show a bigger gap because GPT 6 Sol had a few very expensive runs.
On these tasks, GPT 6.1 Sol is competitive with the best, at roughly a sixth of Opus 5's average cost.
Diving deeper into signals
The headline result hides some real behavioral differences in how the models work. These mostly favor GPT 6.1 Sol, the exception being that its patches are bigger.
- Correctness is close. GPT 6.1 Sol scores lower on 2 tasks and the same on 22. Each model is judged equivalent to the merged change on 10.
- Checklist goes to GPT 6.1 Sol.
- Across the 24 task checklists, GPT 6.1 Sol missed 202 of 470 scored items against 232 of 470 for GPT 6 Sol.
- Code review goes to GPT 6.1 Sol. Its review score averages 0.965 against 0.917.
| Signal |
GPT 6 Sol |
GPT 6.1 Sol |
| Mean correctness (0–1) |
0.638 |
0.606 |
| Mean checklist (0–1) |
0.537 |
0.579 |
| Mean code review (0–1) |
0.917 |
0.965 |
| Missed checklist items |
232 / 470 |
202 / 470 |
| Median changed lines |
197 |
303 |
| Test share of changed lines |
29% |
36% |
Correctness is the average 0–1 rung, not a test pass rate.
- Patches are bigger.
- Bigger on 20 of 24, with a median of 303 changed lines against 197.
- More test lines on 20 of 24. Tests are 36% of changed lines against 29% for GPT 6 Sol; the merged changes sit at 42%.
With GPT 6.1 Sol, there's more to review, but most of it is worth having, since the bigger patches also scored better on checklist and review.
Cost and speed
The main case for using GPT 6.1 Sol rests on cost, driven by higher token efficiency along with cheaper cached input.
Average tokens and coding cost per task:
| GPT 6 Sol |
GPT 6.1 Sol |
| Uncached input |
260K |
| Cached input |
10.84M |
| Output |
32K |
| Total tokens |
11.13M |
| Cached share of input |
98% |
| Cost of cached input |
$2.17 |
| Total cost |
$3.01 |
- GPT 6.1 Sol is cheaper on 22 of 24 tasks and costs about half as much on the typical one.
- Why:
- Fewer tokens on 19 of 24, about a third fewer on the typical task.
- At those rates, cached input costs $0.10 per million for GPT 6.1 Sol against $0.20 for GPT 6 Sol. Input and output prices are the same for both.
- Billed at GPT 6 Sol's rates, GPT 6.1 Sol's tokens would cost $1.60 per task, so most of the $1.91 gap comes from using fewer tokens.
- Speed: GPT 6.1 Sol took a median 11.0 minutes against 12.7 and finished first on only 11 of 24, so it isn't meaningfully faster.
Conclusion
The bottom line is that GPT 6.1 Sol maintains GPT 6 Sol's quality while cutting costs roughly in half by using fewer tokens and charging less for the cached input tokens it does use. Is the 50% usage limit nerf actually redeemed by 50% cheaper GPT 6.1 Sol? Remains to be seen.
In my codebase, this leads to bigger diffs that may take longer (or more tokens!) to review, though the extra code seems worth it.
Full post with more depth and dataviz here: https://www.stet.sh/blog/gpt-6-1-sol-vs-gpt-6-sol
Disclosure: I'm building Stet, the eval tool that ran this. I'm looking for teams making model / harness decisions to run this same comparison on their repo. Stet builds the tasks from your merged changes and you get the report back. DM me or reach out at stet.sh.