WEBVTT

1
00:00:01.300 --> 00:00:06.715
This is Anthropic, Read Aloud. Today: What a task costs on Opus 5.5.

2
00:00:08.015 --> 00:00:10.568
What a task costs on Opus 5.5.

3
00:00:11.018 --> 00:00:20.678
The same token price can cost very different amounts per task. Learn what Claude Code tasks cost on Opus 5.5 and which settings change the bill.

4
00:00:21.128 --> 00:00:25.459
From Claude Blog, published September 22, 2026.

5
00:00:26.459 --> 00:00:29.013
The cost of a task, and the cost of a retry.

6
00:00:29.463 --> 00:00:39.864
You don't set out to buy millions of tokens. You set out to build a feature, finish a migration, or run a task. The token count is whatever the model needed to get there.

7
00:00:40.314 --> 00:01:00.132
Two models with the same cost per token can cost very different amounts on the same task. One reads the code once. The other reads it, tries a fix, and reads it again. Each of those steps is a turn, and each turn resends the conversation so far. So the model that needs more turns costs more, even at the same price.

8
00:01:00.582 --> 00:01:04.956
By the end of this post you should be able to answer three questions about your own work:

9
00:01:05.406 --> 00:01:08.967
What do my typical tasks cost me on Opus 5.5?.

10
00:01:09.207 --> 00:01:11.604
Which settings change that, and by how much?.

11
00:01:11.844 --> 00:01:13.966
How do I check my own session usage?.

12
00:01:14.416 --> 00:01:32.100
The tradeoff I want to share upfront is that every way to spend fewer tokens can also cost you a finished task. Lower effort, a smaller model, or less context can all certainly save tokens. A retry costs more than those savings. This post attempts to put a price on each tradeoff.

13
00:01:32.550 --> 00:01:45.981
Some numbers here are list prices, and some are illustrations built from them. The figures are interactive, so change the inputs as you read. These are best effort illustrations, so be sure to check our docs and your own math.

14
00:01:46.781 --> 00:01:48.050
What does a task cost?

15
00:01:48.500 --> 00:02:01.919
A task in Claude Code is a loop. The model reads the conversation, calls a tool, reads the result, and goes round again until it's done. Each trip round the loop is one request. Four things set what the loop costs.

16
00:02:02.369 --> 00:02:08.248
Turns. Every turn resends the conversation so far. Fewer turns means less input processed.

17
00:02:08.698 --> 00:02:18.080
Cache reads. Most of what a turn resends is text the model saw on the previous turn. It's billed as a cache read, at a small fraction of the input price.

18
00:02:18.530 --> 00:02:29.965
Output token type. The most expensive tokens, at five times the input price. Thinking is billed as output, so a model that reasons less on the way to the answer costs less.

19
00:02:30.415 --> 00:02:37.788
Model. Each model has its own prices, listed on the pricing page, so the model you pick sets the price of every token.

20
00:02:38.238 --> 00:03:01.620
Our examples use Opus 5.5 A P I list prices: 4 dollarsper million input tokens, 20 dollarsper million output tokens and 0.20 dollarsper million cache reads. Like the calculator further down, the examples bill cached input at the read price and everything else at the input price, and leave out cache writes. The token counts are illustrations.

21
00:03:02.420 --> 00:03:03.041
Turns.

22
00:03:03.491 --> 00:03:28.310
Let’s say a task starts with 20 thousand tokens of context and grows to 120 thousand as the model reads files and tool results. At 40 turns, the average turn sends about 70 thousand tokens. That's about 2.8 million input tokens for the task, though the conversation never grew past 120 thousand. With 90 percent read from cache, the input costs about 1.62 dollars.

23
00:03:28.430 --> 00:03:37.721
The same task in 25 turns processes about 1.75 million tokens and costs about 1.02 dollarsin input.

24
00:03:38.171 --> 00:03:45.559
A turn costs more than the tokens it adds, because it resends everything before it. So the cheapest turn is the one you don't need.

25
00:03:46.009 --> 00:03:59.309
One habit that can cut turns is giving the model a way to check its work. For example, a test to run, a build, or a script that calls the endpoint. A model that can check its own work finds its mistakes earlier.

26
00:03:59.759 --> 00:04:06.073
A model that gathers what it needs in one pass, and batches its tool calls, pays the resend fewer times too.

27
00:04:06.873 --> 00:04:07.797
Cache reads.

28
00:04:08.247 --> 00:04:31.903
The same 2.8 million input tokens cost 11.20 dollarsif none come from cache. At a 90 percent hit rate they cost 1.62 dollars, and at 96 percent about 0.99 dollars. No other setting moves input cost this much. A steady session keeps a high hit rate on its own. I cover some actions to avoid breaking your cache later in this post.

29
00:04:32.703 --> 00:04:33.792
Output tokens.

30
00:04:34.242 --> 00:04:58.903
On Opus 5.5, an output token costs 100 times a cache read. The 60 thousand output tokens of a typical task cost 1.20 dollars, the same as reading 6 million tokens from cache. Output includes thinking. You pay for all of it, even when Claude Code only shows you a summary. That's why effort, which mostly changes how much the model thinks, moves the bill so much.

31
00:04:59.703 --> 00:05:00.330
Model.

32
00:05:00.780 --> 00:05:08.991
A model with cheaper cache reads mostly helps long sessions. One with cheaper output mostly helps tasks that need a lot of reasoning.

33
00:05:09.791 --> 00:05:12.019
What changed in Opus 5.5.

34
00:05:12.469 --> 00:05:16.170
Two things changed: the price, and how much work the model does.

35
00:05:16.620 --> 00:05:37.007
Every price line is lower. Input and output tokens are 20 percent cheaper than on Opus 5. Cache reads are 60 percent cheaper. The input price falls, and the read rate falls with it, from a tenth of the input price to a twentieth. Fig A compares the two models per million tokens. These are A P I list prices.

36
00:05:37.127 --> 00:05:53.120
On a Pro, Max or Team plan, the lower Opus 5.5 price is passed on to your limits, including cached context, so they go about 25 percent further than on Opus 5. The extra cut on cache reads is an A P I price change.

37
00:05:53.570 --> 00:05:56.535
Figure 1: Fig A. Price per million tokens.

38
00:05:56.985 --> 00:06:16.544
On an A P I key, the cache-read price cut matters most for Claude Code. A long agentic session spends most of its input on cache reads. In the session priced in Fig B below, the cache line falls from 1.00 dollarsto 0.40 dollars, the largest drop on the receipt.

39
00:06:16.994 --> 00:06:36.980
How much you save depends on the shape of your work. A session that is mostly cache reads can save up to 60 percent on input. A short question with no cache and a long answer can save up to 20 percent, because output dominates it. Most Claude Code tasks sit between the two. The calculator below shows where yours sits.

40
00:06:37.430 --> 00:06:57.355
Opus 5.5 can use more tokens on an answer, because it always thinks before it replies. We expect people to get more done on Opus 5.5, but it varies by task, so measure it on your own work. Fig C compares cost per task on the two models. This part depends on your work far more than the price does.

41
00:06:57.805 --> 00:07:15.574
On a well-scoped task, both models finish in about the same number of turns, and the price cut is all you get. The gap should be biggest on open-ended tasks, where a model can spend many turns on the wrong idea. No single number holds for every codebase, so measure it (see the last section).

42
00:07:16.024 --> 00:07:30.210
Long runs end with a report. Opus 5.5 closes a long run with what it changed, what it found, and what it needs from you. That can save money too, because you rerun a session less often when you can see what happened.

43
00:07:31.010 --> 00:07:32.660
The same tasks side-by-side.

44
00:07:33.110 --> 00:07:44.779
Fig B prices one session on both models with the same token counts. So the difference is the price change and nothing else. Switch models to compare. The token counts are illustrative.

45
00:07:45.229 --> 00:08:01.291
Fig B · One task, two models (receipt toggle). Self-contained Webflow embed. 3.50 dollarsat Opus 5 list prices Fig B. Illustrative session with the same tokens on both models, so this is the price change alone.

46
00:08:01.741 --> 00:08:07.878
Fig B. Illustrative session with the same tokens on both models, so this is the price change alone.

47
00:08:08.328 --> 00:08:26.227
The receipt has the three lines /usage shows for a session. Cache reads are the biggest line by tokens, at 2 million. Output is the smallest by tokens and the biggest by cost. Fresh input sits between them. It covers the first read of each file and each new tool result.

48
00:08:26.677 --> 00:08:40.979
Fig B gives both models the same token counts, so it shows the price change alone. Your own sessions can use more or fewer tokens on Opus 5.5. Priced that way, the session costs about 31 percent less.

49
00:08:41.429 --> 00:08:50.771
A recorded run adds the second effect, the change in how much work the model does. On a task with a false start, the gap should widen. Try your own numbers

50
00:08:51.221 --> 00:09:08.003
Set what one of your tasks uses, or start from a preset. The presets are pretty illustrative but I’d still recommend doing your own math. Cached input bills at the cache-read price and fresh input at the input price, so the cache slider shows how much of the gap comes from cache reads.

51
00:09:08.453 --> 00:09:26.647
To fill the sliders from a real session, run /usage at the end of a task. The Session block gives input, output and cache figures. The last slider is your assumption about how much less work Opus 5.5 does on your tasks. Leave it at 0 percent for the price change alone.

52
00:09:26.767 --> 00:09:41.209
To set it from your own work, here's how: run the same task on Opus 5 and on Opus 5.5, and compare turns and output tokens. Measure it yourself walks through it, and Reading a session shows what to check in /usage.

53
00:09:41.659 --> 00:10:04.344
Try your own numbers (cost calculator). Self-contained Webflow embed. Input tokens per task Everything sent to the model across all turns, cached or not. Read from cache Output tokens per task Includes thinking, which is billed as output. Tasks per day Fewer tokens on Opus 5.5 (your assumption) Leave at 0 percent for price alone.

54
00:10:04.464 --> 00:10:23.598
Opus 5.5 does more with fewer tokens, but measure that on your own tasks. Opus 5 per task to to Opus 5.5 per task to to Change per task to to A month is working days. List prices. No batch or volume discounts, and cache writes are not counted (see the caching section below).

55
00:10:24.398 --> 00:10:26.840
Tips for maximizing the value of your session.

56
00:10:27.290 --> 00:10:36.058
Opus 5.5’s lower price makes each token cost less. How you run a session decides how many tokens you use, and these steps help.

57
00:10:36.858 --> 00:10:39.015
Raise effort before you change models.

58
00:10:39.465 --> 00:11:01.452
Effort sets a general disposition for how many tokens the model spends on each turn: its thinking, the text it writes, and its tool calls. At lower effort it makes fewer tool calls and keeps them shorter. Opus 5.5 has four levels (low, medium, high and xhigh), plus max for a single session. Pick a level below to see when to use it and the command that sets it.

59
00:11:01.902 --> 00:11:09.576
Effort level picker with copyable commands. Self-contained Webflow embed. Levels run from least to most thinking per turn.

60
00:11:10.026 --> 00:11:30.356
Claude Code sets a default level for each model, and /effort status shows yours. Try medium for well-scoped, day-to-day work. When medium stalls, try high. It spends more per turn than medium, but less than moving to a bigger model. Use low for mechanical work, like renames or applying a known pattern across files.

61
00:11:30.806 --> 00:11:53.145
A rough way to think about effort pricing: say high adds 20 thousand thinking tokens across a task. On Opus 5.5 that's 0.40 dollars. A retry loop of ten turns at 100 thousand of cached context, with 10 thousand output tokens in total, costs about the same. So high pays for itself on a task where it saves one retry.

62
00:11:53.265 --> 00:11:56.557
On a task medium would have finished the first time, it's wasted.

63
00:11:57.357 --> 00:11:58.989
When medium fixes one layer.

64
00:11:59.439 --> 00:12:03.308
The clearest sign you need more effort is a fix that stops at one layer.

65
00:12:03.758 --> 00:12:24.836
Say a field is renamed in an A P I handler. At medium, the model updates the handler, the handler's tests pass, and the client still sends the old field. It did what it was asked. It just didn't read far enough to find the second caller. At high, it spends more turns reading call sites before it writes, and it changes both layers in one pass.

66
00:12:25.286 --> 00:12:44.411
A check can catch the same bug. If the model can run a test that goes through the client, the old field fails that test on the turn it was written, at medium. So before you raise effort, check whether the model has a way to check its work. A test run costs one turn and its output. More effort adds thinking to every turn.

67
00:12:44.861 --> 00:12:49.555
If upgrading effort levels and adding checks doesn’t work, then switch to a bigger model.

68
00:12:50.355 --> 00:12:51.893
Changing effort mid-session.

69
00:12:52.343 --> 00:13:04.438
In Claude Code, run /effort with a level, for example /effort high. /effort status prints the current level. You can change it mid-task, and the new level applies to the next request.

70
00:13:04.888 --> 00:13:17.124
Changing effort or thinking settings clears the cached conversation, because those settings are part of the prompt the cache matches. The next request pays the cache-write price on the whole conversation.

71
00:13:17.924 --> 00:13:19.612
Choose the right model for your work.

72
00:13:20.062 --> 00:13:40.884
Model choice sets the price of every token in a session, so it moves the bill more than effort does. It also reaches further. Every subagent that inherits the main model inherits its price too. Most days need three models: a small one for lookups, Opus 5.5 for work you supervise closely, and a bigger one for the hardest tasks.

73
00:13:41.683 --> 00:13:44.303
Opus 5.5 as the daily driver.

74
00:13:44.753 --> 00:13:59.372
Use Opus 5.5 for work you supervise: feature work across a few files, debugging, and code review with follow-up edits. You read what it does and step in when it drifts, so the loop stays short. Moving up to Fable 5.1

75
00:13:59.822 --> 00:14:21.689
Move up to Fable 5.1 when the result matters more than the token price. For example long runs you won't supervise, problems with no existing pattern in the codebase, and large changes that coordinate many subagents. Don't wait for a third failure. If Opus 5.5 on high hits the same problem twice, switch, and switch back once it's solved.

76
00:14:21.809 --> 00:14:27.970
For interactive work, Opus 5.5 is a better fit as it has lower latency and costs less.

77
00:14:28.420 --> 00:14:55.140
Fable 5.1 lists at 10 dollarsper million input tokens and 50 dollarsper million output, two and a half times the Opus 5.5 price. Its cache reads cost 0.25 dollarsper million, only 1.25 times the Opus 5.5 rate, because they bill at 0.025 times its input price. So the gap is smallest on a long, cache-heavy run, and largest on a task that writes a lot.

78
00:14:55.590 --> 00:15:11.546
Switch at a natural break. The cache belongs to the previous model, so expect the first turn on the new model to pay the write price on the whole conversation. Run /compact first, or start a fresh session with a short written plan, to make that turn smaller.

79
00:15:11.666 --> 00:15:22.286
Run /model with an alias or a model name to switch. /model also saves your choice as the default for new sessions, so switch back when the hard part is done.

80
00:15:23.086 --> 00:15:24.525
Moving down for lookups.

81
00:15:24.976 --> 00:15:47.071
Move down to Sonnet or Haiku for lookups, not for writing code: subagents that search and summarize, reading logs and test output, and "where is this defined" questions. For a mechanical edit across many files, keep Opus 5.5 and set effort to low. The edit stays on the model that writes the rest of your code, at a lower cost per turn.

82
00:15:47.521 --> 00:16:09.708
To put a subagent on a smaller model, set model: haiku or model: sonnet in its definition. To put every subagent on one model, set the CLAUDE CODE SUBAGENT MODEL environment variable. A model named in a subagent's definition overrides the variable. A subagent with no model setting runs on your main model, unless the variable is set.

83
00:16:10.158 --> 00:16:23.214
Each subagent runs in its own context window and hands back a summary, so its file reads stay out of your main conversation. It still pays for its own tokens, so the model setting decides what that spend costs.

84
00:16:23.664 --> 00:16:39.208
The tradeoff: a small model that misreads a search result sends the main model after the wrong file, and the main model pays for the detour. Keep the small model on work where a mistake is cheap to spot, like finding files, running tests and reading logs.

85
00:16:39.658 --> 00:16:56.937
Keep judgment calls on the main model. The opusplan alias splits the work a different way: Opus plans in plan mode, and Sonnet carries out the plan. That puts the code edits on Sonnet, the opposite of the advice above. Measure it on your own tasks before you make it a default.

86
00:16:57.737 --> 00:16:59.323
Check your prompts when you migrate.

87
00:16:59.773 --> 00:17:20.295
Instructions written for an older model can make Opus 5.5 write more and repeat tool calls. Run /claude-api prompt-audit in Claude Code to check your Claude Code setup, such as your skills and CLAUDE.md file, for these prompting anti-patterns. It also checks the code of an app you build on the Claude Platform.

88
00:17:20.745 --> 00:17:44.421
We tested this on a migration from Opus 4.8 to Opus 5.5, using an internal customer support benchmark of 44 tickets whose prompt had several of these patterns. The move to Opus 5.5, at low effort, cut the benchmark's cost by about 18 percent. Running prompt-audit cut it by a further 9 percent, to about 25 percent below the Opus 4.8 starting point.

89
00:17:44.541 --> 00:17:57.804
The audit removed ritual instructions that made the model write more and repeat tool calls: a mandatory six-step procedure, a scratchpad rule, a verify-twice rule, and instructions that contradicted each other.

90
00:17:58.254 --> 00:18:09.401
Figure 2: Fig D. Migration from Opus 4.8 at default effort to Opus 5.5 at low effort, with prompt-audit, on the customer support benchmark.

91
00:18:09.851 --> 00:18:22.007
That result comes from one benchmark, so treat it as an example rather than a number to expect. Run the audit, then compare /usage on a real task before and after (see Measure it yourself).

92
00:18:22.807 --> 00:18:24.148
Caching and compaction.

93
00:18:24.598 --> 00:18:30.440
Claude Code handles caching and compaction for you. How you run a session decides how much they save.

94
00:18:31.240 --> 00:18:32.366
How the cache works.

95
00:18:32.816 --> 00:18:40.858
Claude Code caches the parts of a request that repeat, such as the system prompt, tool definitions, and the conversation so far.

96
00:18:41.308 --> 00:19:00.934
On Opus 5.5 a cached read costs 5 percent of a fresh input token. Writing to the cache costs more than a fresh read, at 1.25 times the input price for a five-minute cache and twice the input price for a one-hour cache, on today's pricing. Each hit resets the lifetime at no charge.

97
00:19:01.384 --> 00:19:16.094
In Claude Code the lifetime depends on how you pay. On a Claude subscription it's an hour. On an A P I key or a cloud provider it's five minutes by default, and a subscription drops to five minutes once it's drawing on usage credits.

98
00:19:16.544 --> 00:19:39.561
At 120 thousand tokens of context, a five-minute write on Opus 5.5 costs about 0.60 dollarsand a read about 0.02 dollars. One write costs as much as 25 reads. On an A P I key, a six-minute coffee break turns the next 0.02 dollarsread into a 0.60 dollarswrite.

99
00:19:39.681 --> 00:19:48.434
A one-hour write at the same size costs about 0.96 dollars, and on the A P I you can pay that premium to cover the gaps in your day.

100
00:19:49.234 --> 00:19:50.768
Session shape and hit rate.

101
00:19:51.218 --> 00:19:57.621
The cache stores a prefix, so it can reuse only the part of a request that matches the previous one from the start.

102
00:19:58.071 --> 00:20:16.334
A steady session appends to the end of the conversation on every turn and keeps its hit rate high. Anything that changes an earlier part of the request lowers it. Changing the tool definitions clears the whole cache, and a change to the system prompt clears it from that point on, which is almost everything.

103
00:20:16.784 --> 00:20:19.157
In practice, expect a cache write when:

104
00:20:19.607 --> 00:20:21.541
You pause longer than the cache lifetime.

105
00:20:21.781 --> 00:20:27.621
You change effort or thinking settings (see the effort section), which can clear the cached conversation.

106
00:20:27.861 --> 00:20:33.898
You connect or disconnect an M C P server, which can change what loads at the start of each request.

107
00:20:34.138 --> 00:20:38.101
You switch models, since the new model starts from an empty cache; and.

108
00:20:38.341 --> 00:20:42.458
The conversation is compacted, which rewrites the history the cache matched.

109
00:20:42.908 --> 00:20:46.811
So set these up when the session starts, and leave them alone while it works.

110
00:20:47.611 --> 00:20:49.674
Why long sessions cost more per turn.

111
00:20:50.124 --> 00:21:21.340
Every turn resends the whole context, so a turn costs more as the context grows, even with a warm cache. At 20 thousand tokens of context a turn's cache read costs about 0.004 dollarson Opus 5.5. At 150 thousand it costs about 0.03 dollars, and 30 turns at that size spend 0.90 dollarson reads alone. The same 30 turns at 20 thousand cost about 0.12 dollars.

112
00:21:21.460 --> 00:21:31.233
On Claude 4.6 and later models a bigger context window doesn't change the price per token, so the cost comes entirely from resending the conversation.

113
00:21:31.683 --> 00:21:43.493
Much of that context is left over from earlier work: a stack trace from an hour ago, a file you've finished with, the output of a test run you've since fixed. It's all still sent on every turn.

114
00:21:44.293 --> 00:21:46.793
Compaction, /compact and /clear.

115
00:21:47.243 --> 00:22:00.958
When a session gets close to its context limit, Claude Code summarizes older history so later turns send less. Run /autocompact with a token count to change how full the context gets before that happens.

116
00:22:01.408 --> 00:22:22.249
Two commands let you do this yourself. /clear empties the conversation and costs nothing, so use it when you move to unrelated work. /compact keeps continuity and costs one request. It reads the conversation it summarizes, and you can say what to keep, for example /compact keep the failing test names and the schema change.

117
00:22:22.699 --> 00:22:46.997
A rough price for compacting at 150 thousand tokens is about 0.25 dollars. That's the read, a summary of a few thousand output tokens, and a new cache write on the shorter context. Each later turn saves about 0.025 dollarsin reads, so the compaction pays for itself within about ten turns. A compaction just before you finish costs more than it saves.

118
00:22:47.447 --> 00:23:02.487
The summary also loses detail. A compaction in the middle of a debugging session can drop the one log line that mattered. Compact at a natural break, and when the next step depends on something specific, say so in the /compact instruction.

119
00:23:03.287 --> 00:23:04.773
What loads before you type.

120
00:23:05.223 --> 00:23:26.386
Your CLAUDE.md file loads into the context at the start of every session, so each line in it is part of what every turn resends. The costs docs suggest keeping it under 200 lines. M C P tool definitions are deferred. Only tool names and server instructions load at the start, and a full definition loads when its tool is used.

121
00:23:26.506 --> 00:23:32.070
Run /mcp to see which servers are connected, and turn off the ones you aren't using.

122
00:23:32.870 --> 00:23:33.924
The rest of the bill.

123
00:23:34.374 --> 00:23:40.527
The table lists the other billing rules that affect a Claude Code session, with a link to the docs where one exists.

124
00:23:41.327 --> 00:23:42.456
Measure it yourself.

125
00:23:42.906 --> 00:23:51.553
The figures in this post are illustrations. Your codebase, prompts and habits are different, so measure cost on your own tasks. Here's how to check.

126
00:23:52.003 --> 00:24:11.651
1. In a session, run /usage. /cost does the same thing. The Session block shows token use and an estimated dollar cost at list price. A prompt-cache line shows how much of your input came from cache. On a Pro, Max, Team or Enterprise plan, the same screen shows your plan usage bars.

127
00:24:11.771 --> 00:24:19.186
The dollar figure is computed on your machine at list price, so on a subscription it is a guide to how much work you did, not a bill.

128
00:24:19.426 --> 00:24:36.571
2. Run the same task twice. Pick something from your backlog, not a toy example. Use /model to switch between Opus 5 and Opus 5.5. Note turns, output tokens and cost for each run. Do three or four tasks before you draw a conclusion.

129
00:24:36.811 --> 00:24:51.146
3. For a team, use the usage and cost reports. The Claude Code Analytics A P I gives estimated cost per user. The Usage and Cost A P I breaks spend down by model and by cached versus uncached tokens.

130
00:24:51.386 --> 00:24:58.273
4. Try the effort ladder. Run one hard task at medium and then at high. Run one mechanical task at low.

131
00:24:59.073 --> 00:25:00.075
Reading a session.

132
00:25:00.525 --> 00:25:03.676
Check three things in /usage at the end of a task.

133
00:25:04.126 --> 00:25:14.267
Cache share. For a long session it should be high. If it's low, look for a long pause, a change of effort or model, or an M C P server connected partway through.

134
00:25:14.507 --> 00:25:23.396
Output against input. A lot of output on a small change usually means the effort level is too high for the task, or the model is retrying.

135
00:25:23.636 --> 00:25:36.134
Total input against the size of the conversation. If the total is many times the size of the conversation, the session took many turns, and the conversation is worth reading to find where the loop repeated.

136
00:25:36.584 --> 00:25:53.715
For a baseline, the Claude Code costs docs give an average across enterprise deployments of about 13 dollarsper developer per active day, and under 30 dollarsper active day for 90 percent of users. A session that costs well above your own normal level is worth reviewing.

137
00:25:54.515 --> 00:25:55.438
Keep in mind.

138
00:25:55.888 --> 00:25:58.291
Use medium effort for well-scoped daily work.

139
00:25:58.531 --> 00:26:03.560
Give the model a way to check its work, and start changes that span files in plan mode.

140
00:26:03.800 --> 00:26:09.659
When medium stalls, raise effort to high. Change it at a break, since the change can cost a cache write.

141
00:26:09.899 --> 00:26:15.844
If high hits the same problem twice, switch to Fable 5.1. Switch back once it's solved.

142
00:26:16.084 --> 00:26:22.289
Put search and log-reading subagents on Sonnet or Haiku. Keep code edits on Opus 5.5.

143
00:26:22.529 --> 00:26:25.514
Keep a long session moving, so its cache stays warm.

144
00:26:25.754 --> 00:26:31.521
Use /clear between unrelated tasks, and /compact at a break with a note on what to keep.

145
00:26:31.761 --> 00:26:40.399
The one that matters most: run one real task on each model and compare what /usage reports. Your own numbers are the ones to trust.

146
00:26:40.849 --> 00:26:48.894
I hope this post was helpful. If your limits don’t go further on Opus 5.5 than on Opus 5, tell us with /feedback.

147
00:26:49.344 --> 00:27:01.226
Further reading: Manage costs effectively · Model configuration · Choosing a Claude model and effort level in Claude Code · Effort · Prompt caching · Maximizing the value of your Claude Code sessions

148
00:27:01.676 --> 00:27:06.233
With thanks to Michael Segner, Kacie Jenkins and Molly Vorwerck for their reviews.

149
00:27:07.233 --> 00:27:24.296
That was What a task costs on Opus 5.5, from Claude Blog, published September 22, 2026. Read the original at claude dot com. This unofficial audio edition was generated automatically for the podcast Anthropic, Read Aloud.