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

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 (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.

Sources: OpenAI API pricing, GPT-6 Sol model page, OpenAI prompt caching guide, Claude pricing, Claude Opus 5.5 overview, 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:

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) 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.

                        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.”

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:

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:

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), and “Claude Opus 5.5 defaults to medium” (Effort, Claude Platform Docs).

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). 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.

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 covers that tiering).

Source: AA model pages for GPT-6 Sol and Claude Opus 5.5 at each effort level; the Opus 5.5 max output figure is from AA’s launch note.

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:

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), 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 calls the two “Level with Opus 5 on cost per task” ($5.98 against the $5.86 on AA’s Opus 5 page). 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) is a permanent price per a spokesperson quoted by The New Stack, 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:

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 pulls the Claude side straight from the response fields.

# 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.

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.