Yesterday, the AI industry had a perfectly reasonable model hierarchy.

You paid a lot for the smartest models. You stepped down to cheaper models when scale mattered. And somewhere in your architecture document was probably a sentence saying something like: “Use the frontier model only for difficult requests.”

Then roughly 24 hours happened.

SpaceXAI released Grok 4.7 on September 21. Anthropic followed on September 22 with Claude Opus 5.5. OpenAI released GPT-6 Sol and GPT-6 Luna the same day. (SpaceXAI)

The obvious story is that the models got smarter. The more consequential story is that intelligence got cheaper.

Anthropic pushed Opus toward the performance territory previously occupied by its much more expensive Fable models. OpenAI cut Sol and Luna API prices in half. Grok kept its already-aggressive $2/$6 pricing while substantially improving its capabilities.

And independent evaluations make the situation even more interesting: the model with the cheapest token price is not necessarily the cheapest model to finish a job.

That distinction — price per token versus price per successful task — may be the most important idea to take away from this entire release cycle.

First, the new price sheet

Here is what developers woke up to.

Anthropic also offers an Opus 5.5 Fast mode at $8/$40 with up to 2.5× faster generation. Grok 4.7 has a Fast variant at twice its normal rates in Cursor and Grok Build. (Anthropic)

The eye-catching number is obviously Luna: ten cents per million input tokens and fifty cents per million output tokens.

But resist the temptation to declare a winner from that table.

LLMs don't sell useful work by the token. They consume tokens while attempting useful work.

And those are very different things.

The metric that matters more than token price

Suppose Model A costs half as much per token as Model B.

Wonderful!

But Model A reasons for twice as long, calls five extra tools, retries the task once and writes twice as much output.

Your finance department does not get a refund because the price sheet looked beautiful.

A simplified model of actual agent cost is:

Task cost = fresh input + cached input + reasoning/output + tool calls + retries

And ultimately what we really care about is:

Cost per successful task = total money spent ÷ successful outcomes

This is why some of the new independent Artificial Analysis results are fascinating.

Their Intelligence Index combines ten evaluations covering coding, knowledge work, science, reasoning and agentic tasks. Because the evaluations are run under a more standardized methodology, it gives us one useful — though certainly not universal — way of comparing capability with actual evaluation cost. (Artificial Analysis)

Look at this:

These aren't prices for your task. They are costs incurred on Artificial Analysis's evaluation workload, so treat them as relative measurements rather than an enterprise budget calculator. (Artificial Analysis)

But they reveal something important. The AI race is becoming a curve, not a leaderboard. Want maximum measured intelligence? One part of the curve.

Want 85–90% of that capability much cheaper? Another part. Want thousands of disposable subagents? Suddenly Luna exists.

That changes architecture.

Claude Opus 5.5 is the most interesting release of the bunch

If by "best model" we specifically mean the strongest result on Artificial Analysis's current composite Intelligence Index, then yes: Opus 5.5 Max currently has the highest published score, 58. (Artificial Analysis)

But there is a more interesting part of the release than that number.

Anthropic says Opus 5.5 performs around Claude Fable 5.1 level on most work, while typical workloads cost approximately 40% less than Opus 5. Its basic token prices dropped only 20%, from $5/$25 to $4/$20, but cached reads fell from $0.50 to just $0.20 per million tokens. Anthropic also says output generation is over 30% faster. (Anthropic)

That cache number matters enormously.

A long coding-agent session repeatedly sends large portions of the same repository context, instructions, tool history and conversation state. Paying full price for that context every turn is brutal. If most of it hits the cache, the economics change dramatically.

Anthropic explicitly says cache reads make up a large fraction of agentic and coding-work costs. (Anthropic)

Then there are the benchmarks

On Anthropic's own reported results, Opus 5.5 scores:

66.4% on Terminal-Bench 4.0, versus 57.9% for GPT-6 Astra and 55.8% for Fable 5.1.

54.4% on FrontierCode 1.1, compared with 53.3% for Astra.

1846 Elo on GDPval-AA v2.1, compared with 1735 for Fable 5.1.

And 81.8% on OSWorld 2.0 partial reward, against 80.7% for Fable 5.1. (Anthropic)

But here is where responsible benchmark reading becomes important.

Artificial Analysis's independently run Terminal-Bench 4.0 setup gets 59.6% for Opus 5.5, essentially level with GPT-6 Astra under its standardized setup. (Artificial Analysis)

Anthropic reports 66.4%. Artificial Analysis gets 59.6%.

Did somebody lie?

No.

The agent harness is part of the system.

Anthropic's result uses Claude Code and its particular configuration. Artificial Analysis runs models through a standardized mini-swe-agent harness. Change context management, tool descriptions, retries, terminal policies and orchestration, and you are no longer evaluating exactly the same system.

This is one of the biggest lessons of modern AI evaluation:

A benchmark score increasingly measures Model + Harness + Effort + Tools, not merely Model.

The model is becoming an engine inside a larger machine.

Opus 5.5 also exposes the strange economics of "thinking harder"

Opus 5.5 Medium scores 51 on Artificial Analysis for about $1.34 per evaluation task.

Max reaches 58.

But task cost climbs to $5.98. (Artificial Analysis)

You pay more than four times as much to move those final seven index points.

That may be entirely worthwhile for a difficult migration, financial analysis or autonomous overnight coding run.

It would be absurd for many routine jobs.

This is why simply setting every production request to "maximum reasoning" is increasingly the AI equivalent of running every database query on the largest cluster because, technically, the results arrive.

GPT-6 Sol and Luna: OpenAI attacks the middle of the market

OpenAI's announcement is less dramatic if you look only at raw benchmark supremacy.

It becomes much more interesting when you look at economics.

GPT-6 Sol dropped from $4/$20 to $2/$10.

GPT-6 Luna dropped from $0.20/$1.20 to $0.10/$0.50.

OpenAI describes both as descendants of the methods behind GPT-6 Astra, its premium model, rather than replacements for Astra. (OpenAI)

That positioning makes sense.

Artificial Analysis currently scores Sol Max at 48, below Opus 5.5's 58 but at only about $1.06 per Intelligence Index task. (Artificial Analysis)

Luna Max scores 37.

Nothing shocking there — until you notice the estimated evaluation cost:

seven cents per task. (Artificial Analysis)

Suddenly Luna isn't competing with Opus.

It is competing with the architectural assumption that intelligent model calls need to be rationed.

Imagine an agent with 40 sub-tasks

A research agent might need to:

search 12 sources, extract structured information from 20 documents, classify results, compare duplicates, check claims, summarize findings and finally ask a more capable model to synthesize everything.

Previously, sending all forty steps to a frontier model was expensive.

So engineers compressed workflows, wrote custom heuristics and tried to minimize calls.

With models approaching Luna's economics, another architecture becomes practical:

use cheap intelligence liberally, expensive intelligence selectively.

Luna gathers. Luna classifies. Luna checks formatting. Luna runs cheap subagents.

Sol handles harder reasoning. Opus 5.5 or Astra handles the few tasks where another percentage point of reliability is worth real money.

This may end up being more important than which individual model tops which benchmark.

Sol isn't just "Luna but bigger"

OpenAI reports GPT-6 Sol Max at 68.8% on DeepSWE v1.1, which evaluates longer software-engineering tasks on real codebases. Luna Max reaches 66.6%. (OpenAI)

That gap is surprisingly small given Luna's price.

There is also a useful reality check in Zapier's AutomationBench, which tests agents carrying out workflows across 47 tools rather than merely answering questions.

The current leaderboard reports:

Opus 5.5 Max: 40.0%, $1.28/task

GPT-6 Sol xHigh: 33.2%, $0.27/task

So Opus completes more tasks, while Sol costs roughly a fifth as much on that evaluation. (Zapier)

That is what an actual engineering decision looks like.

Not:

Which model won?

But:

How much additional reliability am I buying, and does this particular workflow justify it?

OpenAI quietly improved something even more important: caching

GPT-6 cached input receives a 90% discount.

OpenAI says developers can now alter reasoning effort or tool availability without invalidating earlier cached context, and can explicitly control caching breakpoints. GitHub told OpenAI that caching improvements over recent months reduced the proportion of prompt tokens requiring fresh processing by more than 50% across billions of requests. (OpenAI)

This sounds boring next to a benchmark graph.

It isn't.

If agents become long-running processes with million-token histories, caching infrastructure may have almost as much influence on economics as the model's list price.

We are moving from:

"How much does this LLM cost?"

to:

"How efficiently does the entire inference system reuse computation?"

That is a much more mature question.

Then there is Grok 4.7: cheap per token, hungry per task

Grok 4.7 might be the best example of why the API price sheet can mislead you.

SpaceXAI kept pricing at $2 input / $6 output per million tokens, with cached inputs at $0.50. The new model uses a larger base than Grok 4.6, underwent longer reinforcement-learning training on harder long-duration tasks, and is explicitly designed to verify its work more carefully. (SpaceXAI)

Its provider benchmarks show meaningful jumps.

CursorBench 4.0 rises from 40.4% to 46.3%.

DeepSWE rises from 65.2% to 71.0%.

Terminal-Bench 4.0 goes from 20.3% to 37.6%.

On an electrical-engineering benchmark, EEBench, it reaches 64.0%. On the Harvey Legal Agent benchmark it gets 19.6%, well above the comparison systems shown by SpaceXAI. (SpaceXAI)

So far, so good.

Then Artificial Analysis measured the token consumption.

Grok 4.7 xHigh scored 46 on its Intelligence Index, two points above Grok 4.6.

But it used roughly 81,000 output tokens per task, compared with about 38,000 for Grok 4.6 and 27,000 for GPT-6 Astra in that evaluation. (Artificial Analysis)

That is the catch.

Grok charges only $6 per million output tokens.

But it may consume a lot of them.

Artificial Analysis estimates roughly $2.73 per Intelligence Index task at high effort and $3.74 at xHigh. Intriguingly, both configurations currently score 46 on the overall index. (Artificial Analysis)

More thinking did not produce a higher composite score there.

It just produced a larger bill.

That does not mean xHigh is useless. Some difficult individual tasks may absolutely benefit from it.

It means reasoning effort is now something engineers should benchmark, not max out reflexively.

Grok has one more pricing wrinkle worth knowing

Grok 4.7's $2/$6 pricing applies below a 200K-token prompt.

Once the request exceeds that threshold, SpaceXAI's current release notes list rates of $4 input, $1 cached input and $12 output per million tokens. (X.ai)

For ordinary chat this may barely matter.

For repository-scale coding agents, research agents and very long conversations, it absolutely can.

A giant context window is not the same thing as a free context window.

What are people actually saying?

Launch-day social sentiment deserves a giant warning label: people who love a model and people who hate a model are much more likely to post than everyone quietly getting work done.

Still, early reactions reveal what benchmarks sometimes miss.

Opus 5.5

The strongest recurring positive signal I found was not "it solved obscure benchmark X."

It was speed + readability.

Several Claude Code users described it as noticeably faster than Opus 5, better at finding bugs and much easier to understand. Another thread specifically praised simpler language, rule-following and terminal commands working with fewer iterations. (Reddit)

There are counterexamples already. One user running a long plan reported the model unexpectedly stopping partway through and then generating suspicious entries that needed verification. (Reddit)

That's healthy context.

Twenty-four hours is enough for first impressions, not reliability statistics.

GPT-6 Sol and Luna

The OpenAI discussion is much more focused on economics and quota consumption.

Some Codex users report Sol consuming surprisingly little of their usage allowance for initial tasks. Others describe the benchmark gains as relatively modest compared with the much larger pricing change. There were also rollout glitches where the models appeared in selectors before requests actually worked. (Reddit)

Luna may be the model to watch once people stop comparing it with flagship models and start asking what workloads can suddenly become cheap enough to run at scale.

Grok 4.7

Early Grok feedback is more mixed.

Some Cursor users say 4.7 feels faster than 4.6 and more pleasant to work with. Others complain about long reasoning traces or high token consumption. One side-by-side user considered 4.7 clearly better than 4.6 but still below models such as Astra or Fable for the particular front-end task tested. (Reddit)

That lines up surprisingly well with the independent measurements: capable, improved, competitively priced per token — but potentially token-hungry.

The benchmark war is becoming a harness war

There is another shift hiding inside all these announcements.

Look at what the major evaluations now test:

Terminal-Bench 4.0 evaluates agents performing hard terminal tasks.

FrontierCode 1.1 asks whether a coding agent's change is good enough that a maintainer would actually merge it.

DeepSWE v1.1 focuses on long-horizon software-engineering work.

AutomationBench puts agents inside simulated business systems and checks whether they actually changed the world correctly — not whether they merely claimed success.

AA-Briefcase v1.1 evaluates multi-step professional work producing spreadsheets, decks and reports.

GDPval-AA v2.1 covers real-world tasks across 44 occupations.

OSWorld 2.0 tests computer-use agents on longer real-world workflows.

This is substantially healthier than obsessing over multiple-choice exams.

But it creates a new problem.

The model interacts with the benchmark through Claude Code, Codex, Grok Build, mini-swe-agent or another harness.

That harness decides how the model sees files, compresses context, invokes tools, retries failures, allocates tokens and maintains state.

So when Model X beats Model Y by three percentage points, ask:

Were we comparing two models — or two complete agent systems?

Increasingly, the honest answer is the latter.

There may no longer be a single "best model"

This release cycle makes the phrase increasingly unhelpful.

For maximum independently measured composite capability right now, Opus 5.5 Max has a compelling result.

For substantially lower cost while preserving strong capability, GPT-6 Sol occupies a very different point on the curve.

For extremely high-volume tasks and subagents, GPT-6 Luna's economics are hard to ignore.

For a $2/$6 model with strong coding and professional-work capability, Grok 4.7 is competitive — provided its token appetite doesn't erase the pricing advantage on your workload.

And OpenAI still positions GPT-6 Astra above Sol and Luna for its most demanding work. (OpenAI)

That is not a neat leaderboard.

It is a routing problem.

And that is probably where production AI architecture is heading.

The architecture I'd expect to see more often

Instead of:

User → Best Model → Answer

we are moving toward:

User → Complexity Router → Cheap Worker Models → Specialist/Frontier Model when needed → Verifier

A simple extraction request does not need Opus 5.5 Max.

A 700,000-line migration probably should not begin with the cheapest possible model just because its token rate makes your spreadsheet look attractive.

A research agent may use fifty Luna calls before asking Sol or Opus to synthesize the results.

A coding platform may dynamically increase reasoning effort only after tests fail.

The right optimization target isn't fewest model calls anymore.

It is:

lowest cost and latency for an acceptably reliable completed task.

That is a much more interesting engineering problem.

So what actually happened in these 24 hours?

It wasn't merely another round of model releases.

Three laboratories attacked three different pieces of the same equation.

Anthropic compressed capability tiers. Opus 5.5 moved remarkably close to — and on several evaluations beyond — the territory previously reserved for its premium models, while cutting cost and dramatically lowering cache-read pricing. (Anthropic)

OpenAI compressed the price curve. Sol now costs $2/$10 and Luna just $0.10/$0.50, while GPT-6's caching improvements make persistent agents cheaper still. (OpenAI)

SpaceXAI pushed harder on price-performance, improving Grok's long-horizon capabilities without increasing its headline price — although independent testing suggests token consumption remains an important caveat. (SpaceXAI)

And that leads to the part I find most important.

For years, AI progress was mostly discussed as:

How intelligent is the next model?

The question now becoming equally important is:

How cheaply can we buy a unit of useful intelligence?

Not a token.

Not a benchmark point.

Not a model call.

A successfully completed piece of work.

That is a much harder metric.

It may also be the metric that determines which of these models actually matters six months from now.

SPONSORED

Explore more deep-dive AI engineering breakdowns, benchmark analysis, and architectural guides.

Learn more

References

Introducing Grok 4.7

SpaceXAI’s most powerful model for coding and knowledge work. Twice as fast, at half the price of comparable models.

xAIxAI

Introducing Claude Opus 5.5

Claude Opus 5.5 leads in agentic coding and knowledge work, and costs 40% less to run than Opus 5 on typical workloads.

https://openai.com/index/introducing-gpt-6-sol-and-luna/

Artificial Analysis Intelligence Index v4.3.2 | Artificial Analysis

Compare AI model performance on Artificial Analysis Intelligence Index v4.3.2. A composite benchmark aggregating ten challenging evaluations to provide a holistic measure of AI capabilities across mathematics, science, coding, and reasoning.

Artificial Analysis

Intelligence Benchmarking | Artificial Analysis

Detailed intelligence benchmarking methodology for LLM quality evaluations.

LLM Leaderboard