# GPT-6 Sol vs Claude Opus 5.5 cost per task: Sol costs 28% to 79% as much for the same target score

> Sol lists at half of Opus 5.5. Per task on Artificial Analysis's index it costs 28% to 79% as much, and past 272K input Opus 5.5 can be the cheaper one.

- Published: Sep 22, 2026
- Author: Leo Kaka, Engineering
- Tags: cost, pricing, caching, models
- Canonical: https://pirouter.ai/blog/gpt-6-sol-vs-claude-opus-5-5-cost-per-task

---
For the same target score on Artificial Analysis's Intelligence Index, GPT-6 Sol costs between 28%
and 79% of what Claude Opus 5.5 costs per task, and about two-thirds at the single point where
their scores meet. The ratio swings that widely because each model can only be bought at a
handful of effort settings, so hitting a target on one side often means overshooting it on the
other.

A few definitions before the numbers. [Artificial Analysis](https://artificialanalysis.ai/models/gpt-6-sol)
(AA) is an independent benchmarking firm; its Intelligence Index averages ten evaluations, from
knowledge work to terminal tasks, into one score. **Cost per task** is AA's average spend to run one
task in that index at list prices, with input, cache and output combined. It measures money only;
wall-clock time is a separate axis this post does not cover. Prices below are from OpenAI's and
Anthropic's documentation as read on 2026-09-23. The per-task figures are AA's. The arithmetic
is mine, done by one script over those two sources. Nothing here was run by us.

## GPT-6 Sol and Claude Opus 5.5 pricing, line by line

Both launched on 22 September at $2/$10 per million input/output tokens for Sol and $4/$20 for
Opus 5.5. Two of the lines below need a definition. A **cache write** stores a processed prompt
prefix so the next request can reuse it; it costs more than plain input. A **cache read** is that
reuse, billed at a fraction of input.

| Line (USD per MTok unless noted) | GPT-6 Sol | Claude Opus 5.5 |
| --- | --- | --- |
| Input | $2.00 | $4.00 |
| Cache read | $0.20 (0.1x input) | $0.20 (0.05x input) |
| Cache write | $2.50 (1.25x) | $5.00 for 5 minutes, $8.00 for 1 hour |
| Output | $10.00 | $20.00 |
| Prompt over 272K input tokens | 2x input and cache, 1.5x output, whole request | No change up to 1M |
| Caching by default | On (implicit mode) | Off until you set `cache_control` |
| Cache lifetime | At least 30 minutes after last write or reuse | 5 minutes, refreshed free on each hit |
| Batch | 50% off (Flex also 50%) | 50% off input and output |
| Fast | 2x all rates ($4/$20) | $8/$40 |
| Default effort | `medium` | `medium` |

Sources: [OpenAI API pricing](https://developers.openai.com/api/docs/pricing),
[GPT-6 Sol model page](https://developers.openai.com/api/docs/models/gpt-6-sol),
[OpenAI prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching),
[Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing),
[Claude Opus 5.5 overview](https://platform.claude.com/docs/en/models/opus-5-5/overview),
[Claude prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching).

The line that matters is the cache read. Anthropic's footnote: "Cache hits and refreshes on Claude
Opus 5.5 are priced at 0.05x the base input price." Half the usual multiplier on double the base
lands on the same $0.20 Sol gets from 0.1x on $2.

The caching-by-default row matters too. OpenAI's guide says "Prompt caching is enabled by default"
and that implicit mode places breakpoints "out of the box"; its own worked example bills a first
request of 12,000 input tokens as `cache_write_tokens: 12000`. On Sol, a prompt you never reuse is
still written at 1.25x unless you switch to explicit mode and place no breakpoint.

## Why the same tokens cost about 1.5x more on Opus 5.5, not 2x

Price one fixed set of tokens on both sheets, below the 272K line:

```text
Opus 5.5 bill   0.20·R + 4·I + 5·W + 20·O
Sol bill        0.20·R + 2·I + 2.5·W + 10·O

R = cache reads   I = uncached input   W = cache writes   O = output
```

Every Opus term is double except cache reads, which are equal. The ratio therefore sits between
1x and 2x and falls toward 1x as cache reads take over the bill.

A one-shot call is the high end. A 20K-token prompt with 1K of output costs $0.10 on Opus 5.5 and
$0.06 on Sol under Sol's default implicit caching, because Sol writes the prompt at $2.50: 1.67x.
In explicit mode with no breakpoint Sol pays plain input and the ratio is 2.00x.

An agent loop is the low end. The 60-turn loop this series priced before
([same $10/$50, and a 39% cheaper agent bill](/blog/same-price-different-bill)) re-reads 9M
cached tokens and emits 120K of output. That post used 180K of cache writes; counting the first
150K prefix plus every output fed back into history, it is closer to 270K, and I use 270K here.

```text
                        GPT-6 Sol                  Claude Opus 5.5 (5-min writes)
cache reads   9.00 M  ×  $0.20  = $1.80      ×  $0.20  = $1.80
cache writes  0.27 M  ×  $2.50  = $0.68      ×  $5.00  = $1.35
output        0.12 M  × $10.00  = $1.20      × $20.00  = $2.40
                                  -----                  -----
                                  $3.67                  $5.55
```

Opus 5.5 costs 1.51x Sol on this loop. The top row is identical and is about half of Sol's bill.
With one-hour writes on the Opus side the same loop is $6.36, or 1.73x.

## Past 272K input tokens the gap reverses: the 25-to-1 rule

OpenAI's model page: "Prompts with more than 272K input tokens are priced at 2x input and cache
rates and 1.5x output for the full request." Anthropic's pricing page: "A 900k-token request is
billed at the same per-token rate as a 9k-token request."

| Above 272K input, USD per MTok | GPT-6 Sol | Claude Opus 5.5 |
| --- | --- | --- |
| Input | $4.00 | $4.00 |
| Cache write | $5.00 | $5.00 (5-minute) / $8.00 (1-hour) |
| Cache read | $0.40 | $0.20 |
| Output | $15.00 | $20.00 |

With five-minute writes, input and writes are identical, so Sol's bill minus Opus 5.5's is
0.20·R − 5·O. When that number is positive Sol costs more:

```text
5-minute writes:   Opus 5.5 is cheaper when   0.20·R  >  5·O          i.e.  R / O > 25
1-hour writes:     Opus 5.5 is cheaper when   0.20·R  >  5·O + 3·W
```

This assumes both sides write the same new tokens to cache each turn. Sol does that by default;
on Claude you need automatic caching (a top-level `cache_control`) or a breakpoint you move
forward yourself.

Agent loops sit well above 25: the 60-turn loop re-reads 75 cached tokens per output token. The
more interesting part is what happens as a session grows. Take a 40-turn session where each turn
adds 2K tokens of input and 3K of output to the history, both sides cache every new token, and
Opus uses five-minute writes:

| Starting context | Turn that first crosses 272K | GPT-6 Sol | Claude Opus 5.5 | Cheaper |
| --- | --- | --- | --- | --- |
| 150K | 26 | $5.33 | $6.06 | Sol, by 12% |
| 250K | 6 | $8.49 | $7.34 | Opus 5.5, by 13% |
| 400K | 1 | $12.54 | $9.26 | Opus 5.5, by 26% |

The 250K row is the one to remember. The session starts on Sol's cheap side, crosses the line on
turn 6, and spends the other 35 turns re-reading a cache that now costs $0.40 per million. It
ends 13% more expensive than Opus 5.5 for identical tokens. The same 40 turns with history trimmed
so the prompt stays at 250K would be $4.00 on Sol against $6.02 on Opus 5.5.

The surcharge is decided per request and applies to the whole request, so a turn that grows from
271K to 273K reprices all 273K tokens. The guard belongs in front of the call, and it should fire
early: the next request carries this turn's output plus new input, so with a 16K output budget,
trim or summarise once the prompt passes 256K.

## Same effort name, 5.4x the bill: effort is not a unit

**Effort** is the request parameter that tells a reasoning model how much to think before it
answers; more effort, more output tokens. Both vendors default to `medium`: "GPT-6 Sol and Luna
also default to medium reasoning effort"
([Reasoning models, OpenAI API](https://developers.openai.com/api/docs/guides/reasoning)), and
"Claude Opus 5.5 defaults to medium"
([Effort, Claude Platform Docs](https://platform.claude.com/docs/en/build-with-claude/effort)).

AA ran both at `medium`. Sol cost $0.25 per task and wrote about 6,500 output tokens. Opus 5.5
cost $1.34 and wrote about 25,700. That is 5.4x the bill. Four times the output at twice the
output price would be 8x; the input and cache-read lines, which grow less than output, pull it
down to 5.4x. Anthropic's migration notes point the same way: "At the same effort setting the
model tends to think more per turn than Claude Opus 5"
([What's new in Claude Opus 5.5](https://platform.claude.com/docs/en/models/opus-5-5/whats-new-opus-5-5)).
The same word is not the same amount of thinking across vendors; the longer version is in
[what reasoning_effort actually does across four providers](/blog/reasoning-effort-one-name-five-physics).

## At the same target score, Sol costs 28% to 79% as much

AA publishes both models at five effort levels each, read from its model pages on 2026-09-23.
Two limits on what that covers. Sol also accepts `none` as an effort value, and GPT-6 models
offer a `pro` reasoning mode; AA measured neither, so everything below is "at the effort levels AA
tested, in standard mode". And AA ran every Opus 5.5 level with Anthropic's default fallback on:
by Anthropic's own description, when its safeguards intervene, cybersecurity tasks go to Opus 4.8
and biology and frontier-LLM-development tasks to Opus 5
([one model, two safety tiers](/blog/one-model-two-safety-tiers) covers that tiering).

| Model and effort | Intelligence Index | Cost per task | Output tokens per task |
| --- | --- | --- | --- |
| GPT-6 Sol · low | 33.9 | $0.13 | 3.4k |
| GPT-6 Sol · medium | 39.8 | $0.25 | 6.5k |
| GPT-6 Sol · high | 42.8 | $0.37 | 10.2k |
| GPT-6 Sol · xhigh | 44.1 | $0.53 | 16.0k |
| GPT-6 Sol · max | 47.5 | $1.06 | 31.2k |
| Claude Opus 5.5 · low | 42.3 | $0.55 | 10.2k |
| Claude Opus 5.5 · medium | 51.2 | $1.34 | 25.7k |
| Claude Opus 5.5 · high | 53.6 | $1.82 | 35.6k |
| Claude Opus 5.5 · xhigh | 56.0 | $3.46 | 65.7k |
| Claude Opus 5.5 · max | 57.6 | $5.98 | ~119k |

Source: AA model pages for [GPT-6 Sol](https://artificialanalysis.ai/models/gpt-6-sol) and
[Claude Opus 5.5](https://artificialanalysis.ai/models/claude-opus-5-5) at each effort level;
the Opus 5.5 max output figure is from
[AA's launch note](https://artificialanalysis.ai/articles/claude-opus-5-5).

A buyer does not pick an effort level; a buyer picks a score the work has to reach and then pays
for the cheapest setting that reaches it. Doing that on both sides:

| Target index | Cheapest GPT-6 Sol tier | Cheapest Claude Opus 5.5 tier | Sol as share of Opus 5.5 |
| --- | --- | --- | --- |
| 42.3 | high (42.8), $0.37 | low (42.3), $0.55 | 68% |
| 42.5 | high (42.8), $0.37 | medium (51.2), $1.34 | 28% |
| 44.0 | xhigh (44.1), $0.53 | medium (51.2), $1.34 | 40% |
| 47.5 | max (47.5), $1.06 | medium (51.2), $1.34 | 79% |
| 48 and up | none tested | medium (51.2) and above | n/a |

Only the first row compares settings with nearly equal scores. Sol at `high` and Opus 5.5 at `low`
land half a point apart and write almost the same output per task (10,232 against 10,151 tokens),
which is why that pair gets quoted. Sol costs 68% of Opus 5.5 there. That is an observed ratio,
not a check on the price-sheet arithmetic above: the two runs match on output but not on cache
reads or writes.

Move the target a fraction of a point above 42.3 and Opus 5.5 has to jump to `medium`, and Sol falls to
28% of its cost. From there the share climbs as Sol climbs its own ladder, to 79% at Sol's `max`.
So: between 42.3 and 47.5, Sol costs 28% to 79% of Opus 5.5 for the same target, and about
two-thirds only at 42.3. Below 42.3 AA tested no Opus 5.5 setting; above 47.5 it tested no Sol
setting.

AA's model pages for these runs do not break out a separate coding or agentic index. If your work
is coding, the table above is a prior, not an answer; run the comparison on your own coding tasks.

## What the launch posts compare against

Anthropic's "40% less than Opus 5 on typical workloads" is "at default settings"
([Introducing Claude Opus 5.5](https://www.anthropic.com/claude-opus-5-5)), which means Opus 5.5 at
`medium` against Opus 5 at `high`; AA's pages give $1.34 against $3.61 for that pair, while at `max`
AA's [launch note](https://artificialanalysis.ai/articles/claude-opus-5-5) calls the two "Level
with Opus 5 on cost per task" ($5.98 against the $5.86 on AA's
[Opus 5 page](https://artificialanalysis.ai/models/claude-opus-5)). Anthropic's benchmark table runs
Opus 5.5 at max effort (Terminal-Bench at xhigh) against GPT-6 Astra and GPT-5.6 Sol, the previous
Sol. OpenAI's "50% compared with their GPT‑5.6 promotional pricing"
([Introducing GPT-6 Sol and Luna](https://openai.com/index/introducing-gpt-6-sol-and-luna/)) is a
permanent price per a spokesperson quoted by
[The New Stack](https://thenewstack.io/openai-gpt-6-sol-luna-release/), and its cost-per-task
charts set Sol at xhigh against Opus 5 at max, not Opus 5.5.

## What the index cannot tell you about your bill

**Cache share moves the ratio.** AA splits each per-task cost by token type. Cache reads are 49% of
Sol's cost at `max` and 31% of Opus 5.5's at `medium`. The larger that share in your traffic, the
closer the two bills get, and AA's harness caches the way it caches, not the way yours does.

**Token counts do not travel.** The two vendors count tokens with different tokenizers and report
them in different fields. Compare dollars per task, never tokens.

**Idle time turns into writes on Opus 5.5.** Sol keeps a prefix at least 30 minutes; Opus 5.5
keeps it five minutes unless you pay for an hour. The rule: if turns in a session are ever more
than five minutes apart, buy the one-hour write. On a 200K context it costs $0.60 more than the
five-minute write, and the first lapse it prevents would have cost a $1.00 rewrite, so it pays for
itself at the first pause. Tight automated loops never pause and should keep five-minute writes.

**An index is a blend.** Ten evaluations averaged into one number. Your task is one thing, and the
28%-to-79% band will sit somewhere else for it.

## How to price GPT-6 Sol against Claude Opus 5.5 on your own traffic

**1. Find each model's cheapest passing effort, separately.** Start Sol at `high` and Opus 5.5 at
`medium`, then step down until your eval fails. Those starting points are where AA's curves bend:
Sol gains 24 index points per extra dollar per task from `medium` to `high` and 8 from `high` to
`xhigh`; Opus 5.5 gains 11 from `low` to `medium` and 5 from `medium` to `high`. Compare the two
cheapest passing settings, never `medium` to `medium`. If Sol fails at every setting you tested,
the answer is Opus 5.5 regardless of price.

**2. Map usage fields to the four lines.** The two APIs do not report the same thing under the same
name:

| Line | OpenAI Responses `usage` | Claude `usage` |
| --- | --- | --- |
| Cache reads (R) | `input_tokens_details.cached_tokens` | `cache_read_input_tokens` |
| Cache writes (W) | `input_tokens_details.cache_write_tokens` | `cache_creation_input_tokens` |
| Uncached input (I) | `input_tokens` minus the two above | `input_tokens` |
| Output (O) | `output_tokens` (includes reasoning) | `output_tokens` |

OpenAI's `input_tokens` already contains the cached and written tokens; its own guide computes
ordinary input as `input_tokens - cached_tokens - cache_write_tokens`. Claude's `input_tokens` is
only "the tokens that come after the last cache breakpoint". Add them up the same way on both and
you double-count Sol's cache.

**3. Measure R / O and count requests over 272K, per request.** Below 272K a high ratio shrinks
Sol's advantage; above it, a ratio over 25 hands the advantage to Opus 5.5. The
[30-day self-audit in the Fable 5.1 post](/blog/fable-5-1-cache-read-crossover) pulls the Claude
side straight from the response fields.

```python
# USD per million tokens, list prices read 2026-09-23. Standard tier, no batch, no residency.
SOL      = {"read": 0.20, "write": 2.50, "input": 2.00, "output": 10.00}
SOL_LONG = {"read": 0.40, "write": 5.00, "input": 4.00, "output": 15.00}  # prompt > 272K: whole request
OPUS_55  = {"read": 0.20, "write": 5.00, "input": 4.00, "output": 20.00}  # 5-minute cache writes

def lines_openai(u):
    d = u["input_tokens_details"]
    r, w = d["cached_tokens"], d["cache_write_tokens"]
    return r, w, u["input_tokens"] - r - w, u["output_tokens"]

def lines_claude(u):
    return (u["cache_read_input_tokens"], u["cache_creation_input_tokens"],
            u["input_tokens"], u["output_tokens"])

def cost(rates, r, w, i, o):
    return (r * rates["read"] + w * rates["write"] + i * rates["input"] + o * rates["output"]) / 1e6

def sol_cost(r, w, i, o):
    return cost(SOL_LONG if r + w + i > 272_000 else SOL, r, w, i, o)

def opus_cost(r, w, i, o):
    return cost(OPUS_55, r, w, i, o)

# One turn of a 400K session, default caching on both sides (new tokens written):
print(sol_cost(400_000, 5_000, 0, 3_000), opus_cost(400_000, 5_000, 0, 3_000))  # 0.23, 0.165
```

Run `lines_openai` over your Sol logs and `lines_claude` over your Claude logs, then price each
set on both sheets. That holds token counts fixed, which step 1 says is false across models, so
use it for the shape of your traffic, not as a forecast.

**4. Check the gaps between turns** against the five-minute Opus 5.5 cache, using the rule above.

| If your workload is… | Likely cheaper | Why |
| --- | --- | --- |
| Passes at Sol `medium` or below | GPT-6 Sol | AA tested no Opus 5.5 setting that low; Sol `medium` is $0.25 a task |
| Needs an index score between 42.3 and 47.5 | GPT-6 Sol, at 28% to 79% of Opus 5.5 | Cheapest passing tiers in the target table |
| Needs above 47.5 | Claude Opus 5.5 | No Sol setting AA tested reaches it |
| Prompts regularly over 272K with R / O above 25 | Claude Opus 5.5 | Sol's cache reads double past the line |

Which row you are in is set by where your eval starts failing, and that is the one number neither
vendor and no index can give you.

---

## Sources

### artificialanalysis.ai

- [Artificial Analysis](https://artificialanalysis.ai/models/gpt-6-sol)
- [Claude Opus 5.5](https://artificialanalysis.ai/models/claude-opus-5-5)
- [AA's launch note](https://artificialanalysis.ai/articles/claude-opus-5-5)
- [Opus 5 page](https://artificialanalysis.ai/models/claude-opus-5)

### developers.openai.com

- [OpenAI API pricing](https://developers.openai.com/api/docs/pricing)
- [GPT-6 Sol model page](https://developers.openai.com/api/docs/models/gpt-6-sol)
- [OpenAI prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching)
- [Reasoning models, OpenAI API](https://developers.openai.com/api/docs/guides/reasoning)

### platform.claude.com

- [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing)
- [Claude Opus 5.5 overview](https://platform.claude.com/docs/en/models/opus-5-5/overview)
- [Claude prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching)
- [Effort, Claude Platform Docs](https://platform.claude.com/docs/en/build-with-claude/effort)
- [What's new in Claude Opus 5.5](https://platform.claude.com/docs/en/models/opus-5-5/whats-new-opus-5-5)

### anthropic.com

- [Introducing Claude Opus 5.5](https://www.anthropic.com/claude-opus-5-5)

### openai.com

- [Introducing GPT-6 Sol and Luna](https://openai.com/index/introducing-gpt-6-sol-and-luna/)

### thenewstack.io

- [The New Stack](https://thenewstack.io/openai-gpt-6-sol-luna-release/)