Claude has a new model.
But this time, what really matters isn’t:
Whether benchmarks improved.
It’s:
Can the same AI task be completed for less money?
On September 22, Anthropic officially launched:
Claude Opus 5.5.
It’s the first member of the new Claude 5.5 Family.
Anthropic positions it straightforwardly:
Most tasks perform close to the more advanced:
Claude Fable 5.1.
But with execution costs much lower than the previous generation:
Claude Opus 5.
What exactly changed in Opus 5.5?
Let’s start with the most direct: API pricing.
Claude Opus 5 pricing:
Input:
$5 per million tokens
Output:
$25 per million tokens
Claude Opus 5.5 pricing:
Input:
$4 per million tokens
Output:
$20 per million tokens
Both are:
20% cheaper.
Looking only at these figures,
you might think:
It’s just a 20% discount.
But the biggest change isn’t in these two prices.
Cache Read cost drops from $0.50 to $0.20
For:
Claude Code.
Coding Agents.
Long-running Agents.
Who repeatedly read the same project context,
the crucial price is:
Cache Read.
In Opus 5, cached tokens cost:
About $0.50 per million tokens.
In Opus 5.5,
$0.20 per million tokens.
That’s a:
60% decrease.
This difference may not matter much for single-line Q&A,
but if AI is:
Reading repositories,
Modifying code,
Running tests,
Reviewing results,
Making further changes,
And running tests again,
Then the cost structure changes entirely.
Why do agents particularly depend on Cache?
Imagine you have Claude Code modify a feature.
In the first round,
it reads:
CLAUDE.md,
project rules,
APIs,
controllers,
tests,
and related components.
This context may cumulatively reach:
100,000 tokens.
In the next round, it runs tests,
thinks,
and reads not just the latest test results,
but the entire conversation history.
The third round is the same.
So a session may never show more than 120,000 tokens on screen,
but the total input processed during the entire task
can be several million tokens,
because the same context is:
Re-read repeatedly.
The prompt cache’s purpose is
to avoid charging fresh input rates for those repeated reads.
Anthropic’s own example illustrates this clearly
Anthropic explains with a hypothetical Claude Code task:
A session context grows to 120,000 tokens.
And after 40 turns,
the total input tokens processed may be about:
2.8 million input tokens.
If 90% are read from cache,
the input cost is about:
$1.62.
If the same task only takes 25 turns,
the cost falls to about:
$1.02.
The takeaway is not the exact dollar amounts,
but rather:
Each extra pass costs money.
“Cheaper tokens” is only the first step
Anthropic states for Opus 5.5:
Under default settings,
typical workloads cost about:
40% less than Opus 5.
Why not just 20%?
Because the new model is expected to:
Not only offer lower token prices,
but also require fewer turns,
make fewer mistakes,
and need less rework and output tokens
to complete the same task.
But this
40%
is an estimate based on typical workloads,
not a guaranteed saving for your specific task.
The real metric is cost per completed task
This is the most valuable lesson from Opus 5.5.
Many compare:
Model A:
Input token cost $4.
Model B:
Input token cost $2.
Therefore, Model B is cheaper.
Not necessarily.
Suppose Model B:
Makes a mistake,
has to check another file,
reworks,
runs tests,
misses a caller,
totaling 20 turns.
Model A:
Detects all dependencies first,
finishes in 10 turns.
In the end, the model with higher token cost
may have:
Lower total cost.
What really matters is:
Cost per Completed Task.
Not:
Cost per million tokens.
Anthropic also warns: retries cost money
If you try to save tokens
by reducing effort too much,
the AI may:
not think through fully,
miss files,
fail the first fix,
run again,
and you may lose any saved thinking tokens
to the cost of retries.
So using Opus 5.5
isn’t about:
Always minimizing effort.
Instead:
Use less effort for simple tasks.
Use more effort for difficult tasks.
Avoid having to redo the entire job.
Opus 5.5 offers adjustable effort levels
In Claude Code,
Opus 5.5 can be configured with:
Low,
Medium,
High,
and XHigh effort levels.
There is also a max effort allowed per session.
Anthropic recommends:
For routine tasks with clear scope,
start with:
Medium
Examples include:
Modifying a feature,
debugging several related files,
or code reviews.
If you find only superficial fixes and incomplete dependency tracing,
raise the effort to:
High.
What tasks suit low effort?
Mechanical edits such as:
Renaming the same symbol across multiple files,
pattern-based fixes,
log reviewing,
or locating where a function is defined.
These don’t require much thinking.
Using the highest effort for such tasks
only wastes money making the AI think longer about simple matters.
When is high effort worthwhile?
For tasks like:
API fields renamed,
backend updated,
but frontend, mobile app, tests, legacy clients, and documentation still depend on them.
If the AI sees only a single file,
it may succeed locally but fail globally.
The point of raising effort
is not to get longer answers, but to encourage the AI to:
Identify more dependencies.
A money-saving strategy: let AI self-verify
Anthropic offers a practical tip:
Don’t just ask the AI to:
"Make the change."
Let it check results by itself using:
unit tests,
builds,
linting,
API tests,
or validation scripts.
The reason is simple.
If the model makes a mistake but can immediately run tests to catch it,
it can fix the issue within the same session.
Without verification,
it may confidently say,
"Done."
Only for you to find problems the next day,
then reopening context,
rethinking,
reloading code,
and repairing again.
That’s truly costly.
How to choose between Opus 5.5 and Fable 5.1?
This is a practical question for Claude users today.
Anthropic’s Claude Code Cost Guide clearly divides their roles:
Opus 5.5:
Best for tasks you actively watch as it works, such as:
feature development,
debugging,
code reviews,
and modifications across a few files.
Because it’s faster, cheaper,
and you can immediately intervene if it veers off track.
Fable 5.1 is reserved for the most difficult tasks
Anthropic suggests Fable 5.1 if:
Task quality matters more than token price,
You won’t constantly supervise,
No existing patterns apply,
Multiple subagents must coordinate,
The change is very large,
Or Opus 5.5 High effort has already stalled on the same problem twice.
In those cases,
switch to:
Fable 5.1.
Fable 5.1’s API list price:
Input:
$10
Output:
$50
About:
2.5 times the Opus 5.5 cost.
So the simplest rule is not:
"Fable is strongest, so always use Fable."
But rather:
Start with Opus 5.5 for general complex tasks,
upgrade to Fable if you hit a wall,
then switch back once solved.
Even simpler tasks might not need Opus
Conversely,
if your task is only:
searching,
reading logs,
file lookup,
or organizing test outputs,
Anthropic suggests letting:
Sonnet
or
Haiku
handle these.
In multi-agent workflows, if every subagent uses expensive models,
the final bill can quickly balloon.
A more sensible approach is:
Cheap models for data lookup,
Opus 5.5 for main tasks,
Fable 5.1 for toughest problems.
This is true:
Model routing.
Cache is cheap, but not permanent
Cache Read in Opus 5.5 costs:
$0.20 per million tokens.
Only 5% of inputs are fresh.
Sounds very affordable.
But cache isn’t:
A one-time build free forever.
Depending on payment plans,
cache lifetime may vary.
If a session is idle for a long time,
the next time you return,
cache might have to be rebuilt.
Also,
Cache Write
can be more expensive than fresh input.
A practical tip:
Finish a task in one concentrated effort.
Avoid:
Splitting into multiple rounds,
taking long breaks,
returning to rewarm the cache,
and continuing.
Switching models or effort may rebuild cache
Another often overlooked point:
Changing effort levels, thinking settings,
or even switching model,
may invalidate existing cache.
So don’t switch:
Medium to High to Low and back to High every few minutes,
as each swap may generate new context costs.
A better strategy is to switch only at:
Natural breaks,
such as planning complete,
ready for implementation,
or confirming Opus can’t solve the problem before upgrading.
Opus 5.5 introduces a practical Prompt Audit feature
Anthropic also notes:
Old prompts designed for previous models
may force the new models to do unnecessary work.
For example, if you had prompts demanding:
Exactly six steps every time,
double verification,
reloading rules every round,
and always outputting a scratchpad,
the new model may produce:
more output,
more tool calls,
and redundant work.
Claude Code can now use:
Prompt Audit
to identify
outdated,
repetitive,
or conflicting
instructions.
Anthropic tested a 44-ticket workflow
Using 44 customer support tickets for internal testing,
switching from Opus 4.8 to Opus 5.5 Low effort
reduced cost by about:
18%.
After cleaning the prompt of:
fixed six-step processes,
scratchpad rules,
verify-twice rules,
and conflicting instructions,
cost dropped an additional:
9%.
Totaling about a:
25% reduction versus the original.
This is just an:
Anthropic benchmark example,
not a guarantee prompt cleaning saves 25%,
but it underscores an important lesson:
When models upgrade, prompts must be refined too.
The most important tool might be /usage
If you’re really working in Claude Code,
don’t guess:
"This version feels cheaper."
Anthropic recommends checking after each session:
/usage
or
/cost.
You’ll see:
Input tokens,
output tokens,
cache usage,
and estimated cost.
Then run the same real task on:
Opus 5,
and Opus 5.5,
to compare:
how many turns,
how much output,
cache hit rate,
and overall cost.
Don’t compare models with toy prompts
If your real task is:
modifying a Laravel project,
analyzing 20 documents,
or running a long agent workflow,
compare using:
Real tasks.
Don’t just use:
"Write a poem about cats,"
then decide your company’s model strategy based on a single token count.
The right approach is to pick:
3-5 recurring daily tasks,
record completion rate,
turns,
review time,
tokens,
and cost,
then determine which model is truly more cost-effective.
There’s also a notable safety improvement
Opus 5.5 is the important new model announced after:
Pacing the Frontier.
Before release, Anthropic had:
external teams METR and Frontier Design
conduct tests.
Company containment evaluation shows Opus 5.5 attempts to bypass system boundaries
about:
85% less than Opus 5 and Mythos 5.1.
But note:
This is not:
"Claude is 85% safer."
It’s just:
One specific category of safety evaluation.
High-risk work still requires careful oversight
Even with:
benchmark gains,
safety improvements,
production deployment,
payment,
data deletion,
security settings,
customer commitments,
and regulated fields like medical, legal, and financial decision-making
should not be:
left fully unchecked.
The more a model can autonomously complete tasks,
the more you must clearly define:
Which steps it can do alone,
and which must:
always pause for review.
Lower costs with Opus 5.5 are best applied to:
Make more AI-suitable tasks economically feasible,
not:
Delegate all decisions to AI.
Who benefits most from trying Opus 5.5?
First:
Heavy users of Claude Code,
especially with very long sessions,
large repository contexts,
and heavy cache reading.
The 60% price drop for cache reads is most noticeable here.
Second:
Those who found Fable too expensive.
If your work doesn’t require top-tier models every time,
Opus 5.5 may offer a better value-to-performance balance.
Third:
Enterprise agent workflows
running dozens, hundreds, or even thousands of tasks daily,
where shaving a few cents per task
adds up to substantial budget savings.
Who doesn’t need to worry much?
If you only:
occasionally ask a few questions,
summarize short texts,
write emails,
or do simple brainstorming,
your actual bottleneck likely isn’t:
saving a few dollars per million tokens between Opus 5 and 5.5.
Such users might not even need Opus models.
Don’t choose the strongest model just because it’s:
"the latest."
Mature AI use means:
Using just enough power for each task.
Final judgment tip
Don’t ask:
"Are tokens cheaper in Opus 5.5?"
The simple answer:
Yes.
The real question should be:
"How much does this task actually cost to complete?"
When testing Opus 5.5,
just check four things:
Turns
How many rounds?
Output
How much thinking and writing?
Cache
How much old context got cheaply reused?
Retry
Were there failed attempts requiring rework?
Then compare:
Cost per Completed Task.
This is where Opus 5.5 truly shines.
AI models are entering a more mature phase of competition:
Not just asking:
Who’s smartest?
But:
Who can reliably complete real work with fewer resources?
Today, progress with AI a little every day.
Learn one AI tip daily.
Save a little time each day.
Improve a bit more every day.
SasaDaily grows with you.
