One read of Claude Developer Platformapi-20261023T233709Z
47 pages moved out of 821 read.
Pages moved
47
significant first
Pages read
821
in this capture
Captured
23:37 UTC
Corpus hash
19303c727ce1
index-hash
What this read moved
1-25 of 47, page 1 of 2This capture is too large to show at once. Changes 1-25 of 47 are below, significant first; the rest are on the following screens.
about-claude/models/optimizing-for-cost-and-intelligence Changed · +49 / -39 lines
from line 61
6161* Deep in a task, a well-built loop pays full price on under 1% of its input.
6262* Below about 80%, look for something breaking the cache (see [What breaks the cache](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#what-breaks-the-cache)).
6363
64Anthropic priced the DeepResearch Bench II[7](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) runs with and without caching:
64Anthropic priced the DeepResearch Bench II[7](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) runs with and without the cache discount:
6565
6666<Frame>
6767 
from line 69
6969
7070The cache's default lifetime is 5 minutes and an agent loop's turns are seconds apart, so the discount applies to most tokens on every turn. The caching chart's runs read 84% to 90% of their input tokens from the cache.
7171
72Pricing other runs' recorded token counts the same way, with each model at its default effort, gives the average token cost per task without caching (none of these runs was made with caching off):
72Pricing other runs' recorded token counts the same way, each model at its default effort, gives the average token cost per task without caching:
7373
7474| Benchmark | Model | Without caching |
7575| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------------- |
from line 81
8181The saving varies with how many turns a task takes, because shorter loops re-read less.
8282
8383<Note>
84 On Claude Haiku 5.5, [compact a long session](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) at a task boundary, before its requests pass 100,000 prompt tokens. A request whose prompt is over 100,000 tokens pays 5 times as much for each of its tokens, output included. Cache reads and cache writes count toward the 100,000 tokens, so a request with a large cached prefix can still be over. See [Long context pricing](https://platform.claude.com/docs/en/about-claude/pricing#long-context-pricing).
84 With Claude Haiku 5.5 on the Messages API, [compact a long conversation](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) between tasks, before its prompt passes 100,000 tokens. Past that, every token of the request costs 5 times as much, output included. Cache reads and writes count toward the 100,000 (see [Long context pricing](https://platform.claude.com/docs/en/about-claude/pricing#long-context-pricing)).
85
86 If you use [compaction at a token threshold](https://platform.claude.com/docs/en/build-with-claude/compaction-threshold#parameters) instead, set its `trigger` a little below 100,000 minus your prompt's largest growth between requests (the default is 150,000). In Anthropic's test with 10,000-token turns, a trigger of 90,000 cost 70% less per request than the default[18](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs).
8587</Note>
8688
8789#### Pick the cache duration
from line 92
9092
9193The 1-hour duration costs more to write (2x the input price instead of 1.25x). A miss on either duration bills the whole prefix at the write price instead of the read price.
9294
95Choose the cache duration when a conversation starts. In Anthropic's test, the first turn added at 1 hour to a conversation cached at 5 minutes wrote the whole prompt again, once: $0.80 USD at 100,000 tokens on Claude Opus 5.5, compared with $0.02 USD of input for a turn that read the cache[16](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs).
96
9397Anthropic measured a small agent that triages bug reports ([Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)) with pauses inserted before some turns to simulate a person's delay[16](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs). Accuracy stayed within run-to-run noise at every setting measured. Anthropic also measured extra requests that keep the 5-minute cache warm (keep-alive requests).
9498
9599To decide, count the gaps between consecutive requests in a conversation, and find your row in the following table:
from line 219
215219
216220 * [Dynamic filtering](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering) in the web fetch tool keeps boilerplate out of fetched pages.
217221 * [Image resizing](https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size) right-sizes vision inputs.
218 * [Tool search with deferred loading](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) loads tool definitions only when needed (measured later in this section).
222 * [Tool search with deferred loading](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) loads tool definitions only when needed (see [Defer unused tool definitions](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#defer-unused-tool-definitions)).
219223 * [Programmatic tool calling](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling) lets Claude run several tool calls from code so only the filtered result enters the context; its documentation reports 24% fewer input tokens on agentic search benchmarks, with a higher score.
220224 * [Manage tool context](https://platform.claude.com/docs/en/agents-and-tools/tool-use/manage-tool-context) compares tool search, programmatic tool calling, prompt caching, and context editing.
221225
from line 241
237241
238242* With every definition loaded, the run cost rose as the catalog grew, tracking the schema tokens on each request.
239243* With tool search, the run cost stayed flat at every catalog size.
240* Accuracy was in the same range either way, and the model never called a wrong tool, so at this scale the catalog costs money, not correctness.
241* On the same earlier model, with a public GitHub MCP server attached through the [MCP connector](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector), deferring its toolset (`default_config: {defer_loading: true}`) cut the run cost at the same accuracy.
244* Accuracy was in the same range either way, and the model never called a wrong tool, so at this scale unused definitions cost money, not correctness.
245* [Keep your 3 to 5 most used tools loaded](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool#deferred-tool-loading), so Claude can call them without searching first.
246* On the same earlier model, deferring a public GitHub MCP server's toolset (`default_config: {defer_loading: true}` on the [MCP connector](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector)) cut the run cost at the same accuracy. With no tool search tool in the request, no run then called the server's tools.
242247
243248#### Keep data files out of the prompt
244249
from line 272
267272* Run-wide, the prune and context editing cache about equally well. If you use context editing, [clear in a few large batches](https://platform.claude.com/docs/en/build-with-claude/context-editing#context-editing-and-prompt-caching).
268273
269274<Note>
270 On Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5, rewriting an earlier tool result [invalidates every thinking block after it](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#prefix-check), so use compaction instead. The prune was measured on an earlier model without [preserved thinking](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking); on these four models, [context editing](https://platform.claude.com/docs/en/build-with-claude/context-editing) and [compaction](https://platform.claude.com/docs/en/build-with-claude/compaction) run on the server and don't invalidate thinking blocks.
275 On Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5, rewriting an earlier tool result [invalidates every thinking block after it](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#prefix-check), so use compaction instead. The prune was measured on an earlier model without [preserved thinking](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking); on these four models, [context editing](https://platform.claude.com/docs/en/build-with-claude/context-editing) and [compaction](https://platform.claude.com/docs/en/build-with-claude/compaction) run on the server and don't invalidate thinking blocks. [Send assistant turns back exactly as returned](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#append-assistant-turns-exactly-as-returned): dropping their thinking blocks costs output tokens on every turn, because Claude [re-creates the reasoning](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#drop-block-cost).
271276</Note>
272277
273278The prune, adapted from the triage agent's code:
from line 312
307312Route every request no one is waiting on through the [Batch API](https://platform.claude.com/docs/en/build-with-claude/batch-processing), and keep the interactive path for the rest. The Batch API takes 50% off every token of a request, including cached ones, in exchange for results arriving any time within 24 hours.
308313
309314* Batching is the second-largest free lever after caching for unattended agent work: evaluation runs, backfills, and scheduled jobs such as a recurring run of the issue-triage agent from the [token-trimming measurement](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens).
310* Batching combines with everything on this page except interactivity, but is not available for Claude Managed Agents sessions, which are interactive by design (see [Claude Managed Agents pricing](https://platform.claude.com/docs/en/about-claude/pricing#claude-managed-agents-pricing)).
315* Batching combines with most of this page, but not with [fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode) or Claude Managed Agents sessions (see [Claude Managed Agents pricing](https://platform.claude.com/docs/en/about-claude/pricing#claude-managed-agents-pricing)).
311316
312317### Audit prompts against the current model
313318
from line 518
513518* At the cap, or a fraction past it, the session pauses with `stop_reason: budget_reached`; raising the budget resumes it. It is platform-enforced and works on any model with a list price. Deployments apply the same budget to each session they start.
514519* **`max_tokens`** caps a single response, invisibly to the model, so lowering it does not make the model economize. The turns that needed the room are discarded and still billed. Retrying capped attempts rarely helps: at the same cap most of them fail again, and at a higher one you also pay for the wasted attempt.
515520* Set `max_tokens` to 64,000 for agentic work, or to 128,000, the maximum, when a single cut-off attempt is costly. [Stream responses](https://platform.claude.com/docs/en/build-with-claude/streaming) that large, treat [`stop_reason: max_tokens`](https://platform.claude.com/docs/en/build-with-claude/handling-stop-reasons#max-tokens) as a failure, and save money with effort, which the model can see.
521* On Claude Haiku 5.5, raise a small `max_tokens` or lower effort: thinking is on by default and counts toward the cap, so a response can end before any text (see the [Claude Haiku 5.5 migration guide](https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide#configure-thinking)).
516522
517523The following table shows what each model solved and what a solved task cost at each cap on an internal repository-task benchmark[12](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs), one attempt per task, each model at its default effort. The rows at 16,384 average two runs, and the other rows are one run each:
518524
from line 571
565571 
566572</Frame>
567573
574To pay for speed instead, set `speed: "fast"` on Claude Opus 5.5. [Fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode) gives up to 2.5x higher output tokens per second at twice the standard token prices. Switching speed mid-conversation misses the prompt cache.
575
568576## Combine models
569577
570578Tune one model before you add a second: sweep effort on your current model first, because most workloads end there, and if the sweep shows a gap, price the stronger model alone at low effort. Build a pairing only if it beats the single model's whole curve of score against spend. The multi-model results on this page were judged against the same model at lower effort and against the next model down running alone, which is the comparison to run on your own workload.
from line 660
6526603. If the curve shows a gap effort can't close, add the multi-model strategy that fits and re-run the suite.
6536614. Run the winner in shadow on a traffic slice before cutover, then keep the suite running.
654662
655**How to price a task.** Each response's `usage` has five priced token counts. Price each at its own rate: uncached input, 5-minute and 1-hour cache writes at 1.25x and 2x the input price, cache reads, and output. Sum them across the task's requests (the [Usage and Cost API](https://platform.claude.com/docs/en/manage-claude/usage-cost-api) reports the aggregate). On Claude Haiku 5.5, price each request at the rates for its prompt length, counting cache reads and writes (see [Long context pricing](https://platform.claude.com/docs/en/about-claude/pricing#long-context-pricing)).
663**How to price a task.** Price each of the five token counts in a response's `usage` at its own rate: uncached input, 5-minute and 1-hour cache writes at 1.25x and 2x the input price, cache reads, and output. Sum them across the task's requests (the [Usage and Cost API](https://platform.claude.com/docs/en/manage-claude/usage-cost-api) reports the aggregate). On Claude Haiku 5.5, use the rates for each request's prompt length, counting cache reads and writes (see [Long context pricing](https://platform.claude.com/docs/en/about-claude/pricing#long-context-pricing)). When `usage.speed` is `"fast"`, use the [fast mode rates](https://platform.claude.com/docs/en/about-claude/pricing#fast-mode-pricing).
656664
657665The following example computes one request's cost at Claude Opus 5.5's list prices. Change the three prices for another model:
658666
from line 854
846854* **Cache-read share.** In agent loops most input tokens should be cache reads. If `cache_read_input_tokens` is small next to `input_tokens` plus `cache_creation_input_tokens`, check that caching is engaged and that the prefix stays the same between requests.
847855* **Advisor tool and compaction.** When the [advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool#usage-and-billing) or [compaction](https://platform.claude.com/docs/en/build-with-claude/compaction-threshold#understanding-usage) is enabled, some tokens are reported only in `usage.iterations` and not in the top-level totals. Sum over `usage.iterations` instead, and price `advisor_message` entries at the advisor model's rates.
848856
849The following table lists the levers in the order to try them. The figures are from Anthropic's own tests; each linked section and its references give the model and the method:
857The following table lists the levers in the order to try them. The figures come from Anthropic's tests, launch posts, and published prices and speeds:
850858
851| Lever | Saving in Anthropic's tests | Quality cost | Latency | Where |
852| ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
853| Prompt caching | Cost cut by a factor of 2.7 to 5.5 on a research agent, and by 83% to 86% on a small triage agent | None | Faster | [Cache repeated context](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) |
854| 1-hour cache duration | With 1 turn in 10 after a pause, the 5-minute default cost 54% more; with 1 in 20, about the same | None | Stayed warm after a pause[16](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) | [Pick the cache duration](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration) |
855| Input trimming | A further 21% to 26% off a small triage agent's bill | None | Neutral | [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
856| Prune stale tool results at task boundaries | 39% on a long agent task; nothing on short ones. On the models named in that section, use compaction instead | None measured | Neutral | [Manage the context lifecycle](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) |
857| Tool search | 45% with 500 tool definitions attached; 20% from deferring a GitHub MCP server's toolset | None | Neutral | [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
858| Data files through code execution | 92% on a data task of 25 questions, with prompt caching off | A gain: 25 of 25 correct instead of 7 | Faster | [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
859| Batch API | 50% | None | Results within 24 hours | [Batch work that can wait](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#batch-work-that-can-wait) |
860| Prompt audit against the current model | 14% on both model upgrades tested | None; a gain on one | Faster (fewer tool rounds) | [Audit prompts against the current model](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#audit-prompts-against-the-current-model) |
861| Upgrade the model | Usually less: up to 40% less on typical workloads, and up to 87% less per solved task on a coding benchmark | None; a gain on most | Neutral | [Upgrade the model](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) |
862| Lower effort | On long coding tasks, `medium` cost about 30% to 52% less than `high`, and `low` about two thirds less | Up to 15 points lower, depending on the task; none on one research agent | Faster | [Tune effort](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) |
863| Re-run failures | About 40% less than running everything at `high`, at the same pass rate or slightly better | None | A second attempt on the tasks that fail | [Re-run failures at higher effort](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) |
864| Ask for shorter answers | About 13% less, from 39% fewer output tokens | None | Faster | [Set budgets and output caps](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
865| Raising `max_tokens` | None: cost per solved task stayed about the same | A gain: up to 22 points more tasks solved on one coding benchmark; none on another | Neutral | [Set budgets and output caps](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
866| Advisor | None: about 2.1 times the cost of the model alone, on a coding benchmark | On coding, a small gain that may be chance; on chart reading, a loss | About 1.4 extra calls per attempt, on coding | [Advisor strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) |
867| Orchestrator | About half the cost of the orchestrator's model alone, on work larger than one context window; on routine work, measure first | 10 to 12 points lower on that work | Much faster on that work | [Orchestrator strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) |
859| Lever | Saving | Quality cost | Latency | Where |
860| -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
861| Prompt caching | Cost cut by a factor of 2.7 to 5.5 on a research agent, and by 83% to 86% on a small triage agent | None | Faster | [Cache repeated context](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) |
862| 1-hour cache duration | With 1 turn in 10 after a pause, the 5-minute default cost 54% more; with 1 in 20, about the same | None | On earlier models, stayed warm after a pause[16](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) | [Pick the cache duration](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration) |
863| Input trimming | A further 21% to 26% off a small triage agent's bill | With tool search, accuracy in the same range as without[27](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Neutral | [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
864| Tool search | 45% with 500 tool definitions attached; 20% from deferring a GitHub MCP server's toolset | None for tools the task never needs | Neutral | [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
865| Data files through code execution | 92% on a data task of 25 questions, with prompt caching off | A gain: 25 of 25 correct instead of 7 | Faster | [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
866| Batch API | 50% | None | Results within 24 hours | [Batch work that can wait](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#batch-work-that-can-wait) |
867| Prompt audit against the current model | 14% on both model upgrades tested | None; a gain on one | Faster (fewer tool rounds) | [Audit prompts against the current model](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#audit-prompts-against-the-current-model) |
868| Upgrade the model | Usually less: up to 40% less on typical workloads, and up to 87% less per solved task on a coding benchmark | None; a gain on most | Neutral | [Upgrade the model](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) |
869| Lower effort | On long coding tasks, `medium` cost about 30% to 52% less than `high`, and `low` about two thirds less | Up to 15 points lower, depending on the task; none on one research agent | Faster | [Tune effort](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) |
870| Re-run failures | About 40% less than running everything at `high`, at the same pass rate or slightly better | None | A second attempt on the tasks that fail | [Re-run failures at higher effort](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) |
871| Ask for shorter answers | About 13% less, from 39% fewer output tokens | None | Faster | [Set budgets and output caps](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
872| Raising `max_tokens` | None: cost per solved task stayed about the same | A gain: up to 22 points more tasks solved on one coding benchmark; none on another | Neutral | [Set budgets and output caps](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
873| Advisor | None: about 2.1 times the cost of the model alone, on a coding benchmark | On coding, a small gain that may be chance; on chart reading, a loss | About 1.4 extra calls per attempt, on coding | [Advisor strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) |
874| Orchestrator | About half the cost of the orchestrator's model alone, on work larger than one context window; on routine work, measure first | 10 to 12 points lower on that work | Much faster on that work | [Orchestrator strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) |
875| Fast mode | None: twice the standard token prices | None | Up to 2.5x higher output tokens per second | [Show the model elapsed time](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time) |
868876
869877### Automate the search with the Claude API skill
870878
from line 931
923931 * **Upgrade the model, runs:** The Claude Fable 5 point in Upgrade the model pools three runs at the default effort, run August 26, 2026, priced as a customer's organization is metered. The upgrade ladder counts every model over the 478 problems, each at its shipped defaults. It uses one run per model except Opus 5, Opus 5.5, Sonnet 5, and Sonnet 5.5 (two runs each) and Fable 5 (the three runs described above). The Opus 4.7, Opus 4.8, Sonnet 4.6, and Sonnet 5 runs ran August 17 to 19, 2026, and the Opus 5 runs on August 4, all in one harness and organization; the Opus 5.5 and Sonnet 5.5 runs are the ones described earlier in this reference.
924932 * **Upgrade the model, cost per solved task:** Claude Opus 5 costs 21% more per solved task than Claude Opus 4.8 when those Claude Opus 5 runs are compared with one Claude Opus 4.8 run at its shipped defaults from the August 17 to 19 series, counted over the same 478 problems; the chart's SWE-bench Pro panel shows neither Claude Opus 4.7 nor Claude Opus 4.8. In the same measurements, priced as a customer is billed, Claude Opus 5 solves 12 more points of tasks than Claude Opus 4.8 at that 21% more per solved task, Claude Opus 4.8 solves the same share of tasks as Claude Opus 4.7 for 14% less per solved task, and Claude Opus 5 at `low` effort beats Claude Opus 4.8's default on this benchmark for about 30% of its cost per solved task.
925933 * **Upgrade the model, prices:** Claude Sonnet 5's saving over Claude Sonnet 4.6 in Upgrade the model comes from its lower per-token price, which more than offsets the extra tokens it uses per task. Claude Sonnet 5.5 charges the same as Claude Sonnet 5 for everything but cache reads, which cost half as much. Claude Opus 5.5's token prices are lower than Claude Opus 5's, most of all for cache reads. Like Claude Sonnet 5, the frontier tier gained through price: most of Claude Fable 5.1's saving is the lower cache-read price.
926 * **Cost without caching, priced from recorded token counts:** Anthropic also re-priced the recorded token counts of the Claude Opus 5.5 and Claude Sonnet 5.5 runs described earlier in this reference, over the 478 problems, for the caching factors in [Why caching comes first](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first); it made no run with caching off.
934 * **Cost without caching, priced from recorded token counts:** Anthropic re-priced the recorded token counts of the Claude Opus 5.5 and Claude Sonnet 5.5 runs, over the 478 problems, for the caching factors in [Why caching comes first](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first).
927935 * **The factors, by model:** Each factor is the token cost with every input token at the input price, output tokens unchanged, divided by the cost priced as a customer's organization is metered: for Claude Opus 5.5, 3.3 at `medium`, 2.4 at `low`, 3.8 at `high`, and 5.4 at `xhigh` (one run); for Claude Sonnet 5.5, with cache reads at $0.10 USD per million tokens, 3.1 at `high` and 2.4 at `medium`, or 2.8 at `high` at the launch price of $0.20 USD. Unlike the caching chart's runs, these incurred no web-search fees, and a task's first request is priced as a cache write.
928936
9299374. **BrowseComp:** Wei et al., "BrowseComp: A Simple Yet Challenging Benchmark for Browsing Agents," OpenAI, 2025. Effort figures use a 500-problem cut, one to three runs per setting, run August 3, 2026, with the default point pooling two runs from July 26 to 27, 2026. The measurement of routine work with a long cost tail in [Orchestrator strategy](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) uses 10 problems that the model reliably solved on its own when the protocol was fixed, from a 26-problem slice, 50 delegated runs (5 per problem; August 1 to 2, 2026) and 70 runs of the model alone (50 from August 2 to 3, 2026; 20 archived from July 12 to 13 and August 1, 2026), $6.45 USD compared with $11.99 USD per run in expectation; delegated figures carry a measurement band of about 20%. The 10 problems are those on which the delegated configuration, a Claude Fable 5 orchestrator with one Claude Sonnet 5 worker, was right in all 5 runs and Claude Fable 5 alone in both archived runs; the delegated runs are those same runs, and only Claude Fable 5 alone was run again on the ten. Over its 70 runs, archived and new, Claude Fable 5 alone was right in 68. On those problems the delegated configuration cost about half as much as Claude Fable 5 alone on average (the $6.45 USD and $11.99 USD given earlier) and about a third as much at the 90th percentile ($12 USD compared with $33 USD per run), and its most expensive run cost $42 USD compared with $84 USD; that $84 USD run was also wrong. On the full, harder BrowseComp set, Claude Fable 5 alone reached the accuracy of the orchestrator configuration measured on that set at 22% to 30% lower cost.
from line 950
942950 * **Results, Claude Opus 5:** Claude Opus 5 at its default effort ran on the same surface and subset, three runs, on August 28, 2026: 68.8% on the raw 50 tasks, 70.8% on the 33-task basis, and 71.1% on the 21-task set, at $6.28 USD per task ($23.72 USD without caching); none of its attempts was cut short by the safety classifiers, under a safeguards deployment newer than the one the other models ran under.
943951 * **Compare models:** The research comparison in [Compare models](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) rests on these figures: Claude Fable 5.1 at `low` scored 10 points above Claude Sonnet 5 on the 33-task basis (66% against 56%) at about four times the cost per task over all 50 tasks ($4.48 USD against $1.18 USD); Claude Opus 5 at its default, whose scores and cost are given earlier in this reference, scored above Claude Fable 5.1 at its default, which scored 65% on the 33-task basis and cost $6.89 USD per task over all 50 tasks, so on research, Claude Fable 5.1 earns its price only at `low`.
944952 * **Caching chart:** The caching chart re-prices the same requests with every input token at the uncached rate.
945 * **Not measured:** Claude Sonnet 5.5 was not measured on this benchmark.
946953
9479548. **Corpus defect sweep:** Anthropic-internal, for work larger than one context window: a 21.6-million-token corpus from 14 public Python package sources with 130 planted defects and deterministic grading; protocol fixed before the runs and internally reviewed; three runs per configuration. Every configuration ran on Claude Managed Agents. The charted team configuration is one in which the Claude Fable 5.1 orchestrator ran the whole sweep inside the platform at its documented limit of 25 concurrent Claude Sonnet 5 workers, run August 30, 2026; its three runs scored F1 0.764, 0.825, and 0.791 after the extras audit (raw 0.751, 0.821, and 0.781) for $225 USD, $234 USD, and $283 USD. The team configuration cost about half as much as Claude Fable 5.1 alone at `low`, `medium`, or `high` (47% to 55% less), scored 10 to 12 points below it, and took about 2.3 hours per run, compared with 15 to 20 hours. The team configuration read about 560 million cached tokens per run, nearly all of them at Claude Sonnet 5's cache-read rate. That is about one and a half times the roughly 365 million that Claude Fable 5.1 read alone. Claude Fable 5.1 alone at `high` effort still holds peak accuracy, at about 2.2 times the team configuration's cost, so delegation here buys most of the accuracy, not all of it. The configuration with Claude Sonnet 5 alone ran August 3 to 4, 2026; the configurations with Claude Fable 5.1 alone ran August 24 to 25, 2026, under the platform's launch serving settings, three seeds per effort setting, on the same corpus build. The sandbox image carried installed copies of part of the corpus, and Claude Fable 5.1's final assembly step compared against them in 7 of 9 runs; re-grading without those additions moved the affected seeds by up to 3 points. Absolute F1 is specific to this corpus build, not comparable across benchmarks; configuration comparisons are like for like.
948955
from line 1021
10141021 * **Keep-alive requests, Claude Sonnet 5.5, by run:** Comparing each run's keep-alive session with the same run's 1-hour session instead, keep-alive cost from about the same to 10% more at 6 minutes (runs 1 and 2; 4% more on their average), from about the same to 16% more at 20 minutes, and 64% to 80% more at 45 minutes.
10151022 * **Keep-alive requests, Claude Sonnet 5.5, sample size:** The keep-alive chart's 6-minute points average runs 1 and 2 for all three settings. Each cell is three sessions (two for the 6-minute figures above). With no pauses, keep-alive sends no extra requests and so matches the 5-minute setting, yet the two differed by as much as 23% within a single run, so a difference of a few percent in a three-run average is not a clear effect.
10161023 * **Caching off and on, Claude Sonnet 5:** On Claude Sonnet 5, the same job was run with caching off and with caching on, three runs each on August 19, 2026, with `max_tokens` at 700: $3.36 USD against $0.57 USD a session on average, a saving of 83%.
1017 * **Priced from recorded token counts, Claude Sonnet 5.5:** Anthropic also re-priced the recorded token counts of the three Claude Sonnet 5.5 sessions with the 5-minute cache and no pauses for the caching figure in [Why caching comes first](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first); it made no run with caching off on Claude Sonnet 5.5. Each of these three sessions is one conversation of 40 requests over the job's 20 issues. At list prices as of October 12, 2026, the sessions cost $0.51 USD each on average, from the usage fields, against $3.70 USD with every input token at the input price and output tokens unchanged: a saving of 86% (86% to 87% across the three sessions), or a factor of 7.3. At the launch cache-read price of $0.20 USD the saving is 82%, so the rise over the Claude Sonnet 5 figure comes from the lower cache-read price.
1018 * **Priced from recorded token counts, Claude Opus 5.5:** Re-priced the same way, the three Claude Opus 5.5 sessions at its default effort, `medium`, with the 5-minute cache and no pauses cost $1.02 USD each on average against $6.93 USD, a saving of 85%, or a factor of 6.8; Anthropic made no run with caching off on Claude Opus 5.5, and the model used thinking in 79% of requests.
1024 * **Priced from recorded token counts, Claude Sonnet 5.5:** Anthropic also re-priced the recorded token counts of the three Claude Sonnet 5.5 sessions with the 5-minute cache and no pauses for the caching figure in [Why caching comes first](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first). Each of these three sessions is one conversation of 40 requests over the job's 20 issues. At list prices as of October 12, 2026, the sessions cost $0.51 USD each on average, from the usage fields, against $3.70 USD with every input token at the input price and output tokens unchanged: a saving of 86% (86% to 87% across the three sessions), or a factor of 7.3. At the launch cache-read price of $0.20 USD the saving is 82%, so the rise over the Claude Sonnet 5 figure comes from the lower cache-read price.
1025 * **Priced from recorded token counts, Claude Opus 5.5:** Re-priced the same way, the three Claude Opus 5.5 sessions at its default effort, `medium`, with the 5-minute cache and no pauses cost $1.02 USD each on average against $6.93 USD, a saving of 85%, or a factor of 6.8; the model used thinking in 79% of requests.
10191026 * **How thinking was set, two sets of runs only:** The requests of the three Claude Sonnet 5.5 sessions with the 5-minute cache and no pauses set no thinking option, so thinking was left at the model's default, and the model used it in 38% of requests. The requests of the Claude Sonnet 5 runs with caching off and with caching on also set no thinking option, so thinking was left at the model's default, and the model used it in 41 of 121 requests with caching off and 40 of 120 with caching on.
1020 * **Latency after a pause:** On Claude Sonnet 5 and Claude Opus 5, the turn after a pause kept its warm-cache latency on the 1-hour setting. Claude Opus 5.5's time to first token after a pause was not measured. Claude Sonnet 5.5's time to first token after a pause was not measured.
1027 * **Latency after a pause:** On Claude Sonnet 5 and Claude Opus 5, the turn after a pause kept its warm-cache latency on the 1-hour setting.
1028 * **Changing the duration mid-conversation:** Measured October 21, 2026, on Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5, on the Messages API with no tools, adaptive thinking, `high` effort, a cache breakpoint on the system prompt, and [automatic caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#automatic-caching) or an explicit breakpoint on the last block. The conversations held about 5,000 or 100,000 tokens of filler text, with fixed one-word assistant turns and no thinking blocks. In a conversation cached at 5 minutes, the first 1-hour request that added a turn read nothing and wrote the whole prompt at the 1-hour price (55 of 55). The next 1-hour request read everything (36 of 36). A system prompt cached at 1 hour from the first request was still read (12 of 12). A 1-hour request that added nothing read the 5-minute entries (31 of 31) and did not extend them: 8 minutes later, the same request read nothing (12 of 12). In a conversation cached at 1 hour, a 5-minute request read everything and wrote only its new turn (12 of 12). The requests ran in one Anthropic-internal organization on the Claude API.
1029 * **Changing the duration mid-conversation, how priced:** From the `usage` fields at list prices, at just over 100,000 tokens, with `max_tokens` at 16, the first 1-hour request that added a turn cost $2.01 USD, $0.80 USD, $0.40 USD, and $0.10 USD on the four models in the order named. A turn that read the cache cost $0.026 USD, $0.020 USD, $0.010 USD, and $0.005 USD. Claude Haiku 5.5 is at its [long context prices](https://platform.claude.com/docs/en/about-claude/pricing#long-context-pricing).
10211030
1022103117. **Cache-read share in production:** Aggregated first-party Claude API usage for the 14 days ending August 23, 2026, direct API product only, Anthropic-internal organizations excluded, no organization identified. An organization-day counts as an agent loop when its requests carry tool definitions and tool results, its prompts hold 9 or more prior tool calls on average, caching was used, and it made at least 10 such requests (the API has no conversation identifier, so this stands in for conversation length): 303,003 organization-days across 106,487 organizations, median cache-read share 84.2% of all input tokens, upper quartile 91.7%. Use-case labels (the organization's declared use case, or otherwise its classified one) cover 74% of those organization-days and 99% of their tokens; about 72% of coding organization-days read 80% or more. The top decile of organization-days reads 95.9% or more for coding and 94.2% to 94.8% for support, research, data, and other agents. The request-level split at 25 or more prior tool calls comes from a six-hour sample: coding 92% read, 7% write, under 1% uncached.
10231032
from line 1041
10321041 * **Mid-session arm:** The mid-session arm paid $0.23 USD per session in cache re-writes; the difference between the mid-session and boundary arms was $0.20 USD with a 95% confidence interval of $0.11 USD to $0.29 USD. In the mid-session arm, the effort change and the added tool rewrote 39,000 and 60,000 cached tokens. One of its sessions ran cheap ($0.82 USD) after its model mis-called the search tool following compaction and got empty results; it is included, and without it the arm averages $0.98 USD.
10331042 * **Accuracy and cache reads:** Accuracy averaged 14.2 of 20 labels in each August 24 arm and 14.7 in the August 25 arm; cache reads were 91% of prompt tokens with no changes, 85% mid-session, 91% at the boundary, and 86% with the changes on the triggering request.
10341043 * **Separate measurement, status line:** A separate measurement on the 20-issue triage job from [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), run August 18, 2026, also on Claude Sonnet 5 with the 5-minute cache, priced the same way, three runs per arm: with a 25-token status line at the front of the system prompt, a run cost $4.24 USD on average ($4.12 USD to $4.47 USD across the three runs) and read nothing from the cache; with the same line at the end of the newest user turn, after the last cache breakpoint, a run cost $0.59 USD ($0.55 USD to $0.61 USD). The first is more than the same job cost with caching off. A later re-run with the same configuration gave $4.28 USD and $0.61 USD.
1044 * **Compaction trigger on Claude Haiku 5.5:** Measured October 21, 2026, on the Messages API with [compaction at a token threshold](https://platform.claude.com/docs/en/build-with-claude/compaction-threshold), no tools, adaptive thinking, the default effort (`medium`), the 5-minute cache, a cache breakpoint on the system prompt, and [automatic caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#automatic-caching). Each session was one conversation of 45 requests: a 5,000-token system prompt, 10,000 tokens of filler text with every user turn, and one-word assistant turns, except that a reply with a compaction block was sent back whole. Four settings ran three sessions each: triggers of 150,000 tokens (the default), 90,000, and 50,000 (the lowest allowed), and no compaction. Costs within a setting agreed to within 4%. With the default trigger, 15 of each session's 45 replies and all 3 summaries had prompts over 100,000 tokens. With a trigger of 90,000, the largest prompt held 97,269 tokens. Compaction ran at the first request whose whole prompt had reached the trigger, counting the system prompt, cache reads, and cache writes. The summary was written from that prompt plus 44 tokens, up to 7,269 tokens over the trigger. Three more sessions, with a 22,000-token system prompt and a trigger of 50,000, showed that the system prompt counts. The summaries were short (184 to 640 output tokens) because the text was filler. The requests ran in one Anthropic-internal organization on the Claude API.
1045 * **Compaction trigger on Claude Haiku 5.5, how priced:** From the `usage` fields at list prices, a session cost $0.272 USD with the default trigger, $0.082 USD at 90,000, $0.075 USD at 50,000, and $0.729 USD with no compaction. Per request, from the request after the first compaction through the last compaction, the three triggers cost $0.00605 USD, $0.00181 USD, and $0.00166 USD. With every prompt at the prices for prompts up to 100,000 tokens, the default would cost $0.00206 USD per request, and a trigger of 90,000 would save 12%. A compaction's summary and reply are each priced by their own prompt's size.
10351046
1036104719. **Cache duration measurement on Claude Fable 5.1:** The same 20-issue triage job and harness as reference 16, with `max_tokens` raised to 4,096, run August 23 and August 26, 2026, on the Claude Fable 5.1 launch snapshot at its launch prices ($10 USD input, $12.50 USD 5-minute write, $20 USD 1-hour write, $0.25 USD cache read, $50 USD output per million tokens), three settings per schedule: the 5-minute cache, the 1-hour cache, and the 5-minute cache kept warm by a `max_tokens: 0` request on the unchanged prefix every 4 minutes, timed from the previous request's start (the August 23 runs sent keep-alive requests with `max_tokens: 1`; in the August 26 cells reported here, every answered keep-alive request refreshed the cache and its response reported no output tokens). Schedules: no pauses, 10% of turns, and every turn at 6 minutes on all 20 issues, and 45-minute pauses on the 5-issue subset; three runs per cell (six for the August 26 keep-alive cell with 45-minute pauses), cost computed from each response's `usage` fields at list prices, accuracy against the same gold labels (12 to 18 exact labels of 20). Per-session means on August 26 for the 5-minute, 1-hour, and keep-alive settings: no pauses $2.42 USD, $3.09 USD, $2.29 USD; 10% paused $4.50 USD, $2.96 USD, $2.36 USD; every turn $22.89 USD, $3.01 USD, $2.62 USD; the August 23 cells agree within 6%. The 45-minute figures ($1.68 USD, $0.59 USD, and $0.71 USD per 5-issue session) are from later sessions of August 26: that day's first set of sessions was cut off when its machine was shut down, and the second was affected by a fault in the service and is set aside. The third set gives the 5-minute and 1-hour figures; its three keep-alive sessions sent each keep-alive request once, lost requests to rate-limit refusals, and are not in the mean. The keep-alive figure is the mean of six further sessions that sent any refused keep-alive request again within two seconds. The August 23 runs gave $1.67 USD, $0.58 USD, and $0.70 USD. The break-even between the 5-minute and 1-hour settings is 3.1% of turns, the same measure as reference 16. Claude Fable 5.1's cache read costs 0.025x the input price while its cache writes keep the standard multipliers, so a keep-alive request that re-reads the prefix is cheap and the 1-hour duration's write premium is the larger bill, except with 45-minute pauses, where the keep-alive requests cost more than the premium.
10371048
from line 1060
10491060 * **How timed:** Time is the wall-clock time of an attempt, from its first request to the end of the last request by any agent, including tool runs, averaged over a task's attempts. A typical-task figure is the median, over tasks, of each task's ratio between two configurations.
10501061 * **How priced:** Each task's cost is its requests priced at Claude Opus 5.5's public list prices, with prompt caching billed as it would be for a customer who sets a cache breakpoint at the end of each request and uses the 5-minute cache lifetime. Each request reads the previous request's prompt from the cache and writes the rest. An attempt's first request, and any request that starts more than 5 minutes after the one before it, writes its whole prompt. Costs cover model tokens only; the harness's tools add no charges.
10511062 * **How scored:** All intervals are 95% bootstrap intervals over tasks, and score changes are paired differences over tasks. Claude Opus 5 grades the answers, so Claude Opus 5.5 doesn't grade its own work, and each answer's score averages five judging runs.
1052 * **Caveats:** A production safety classifier stopped three attempts in each configuration, all on one task, and those attempts score 0; leaving that task out changes no finding. The runs also passed each agent's tool use through an Anthropic-internal safety check that customer requests don't have, which adds an unmeasured amount of time to each request in every configuration. On DRACO, the single agent without the changes made about twice as many requests, and the team about a third more, so the check probably makes the DRACO time savings look slightly larger.
1063 * **Caveats:** A production safety classifier stopped three attempts in each configuration, all on one task, and those attempts score 0; leaving that task out changes no finding. The runs also passed each agent's tool use through an Anthropic-internal safety check that customer requests don't have, which adds time to each request in every configuration. On DRACO, the single agent without the changes made about twice as many requests, and the team about a third more, so the check probably makes the DRACO time savings look slightly larger.
10531064 * **Results, single agent:** Results for [Show the model elapsed time](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): with the changes, the single agent took 47% less time at a 60% lower cost on the typical task, its average cost fell from $1.13 USD to $0.44 USD per task, and its score was 4.1 points lower (95% interval 2.9 to 5.2 lower).
10541065 * **Results, lower effort:** Lowering the single agent's effort saved more time and cost than the changes did, and lost more score. At `low` effort, it scored 13.3 points lower on DRACO, 3.4 on HLE, and 14.0 on the physics set than at `medium`, and the typical task took 84%, 30%, and 47% less time. With the changes at `medium` effort, it scored 9.2, 2.5, and 11.0 points higher than at `low`, and the typical task took longer than at `low` by a factor of 1.2 to 3.2.
10551066 * **Results, team, helpers:** The team's lead rarely started helpers. Without the changes, it started a helper in only 5 of 300 attempts on DRACO, 13 of 1,479 on HLE, and none of 280 on the physics set.
1056 * **Results, team:** So the team results mostly show the lead agent working alone, with the team's own instructions and tools, and Anthropic has no measurement of the changes on a team that works in parallel. Without the changes, the team already took about half the single agent's time on the typical DRACO task, and scored 3.3 points lower (95% interval 2.1 to 4.6 lower). With the changes, the team took 17% less time at a 20% lower cost on the typical DRACO task, and scored 1.6 points lower (95% interval 0.3 to 2.8 lower).
1057 * **Not measured:** Anthropic didn't measure the changes on Claude Managed Agents.
1067 * **Results, team:** So the team results mostly show the lead agent working alone, with the team's own instructions and tools. Without the changes, the team already took about half the single agent's time on the typical DRACO task, and scored 3.3 points lower (95% interval 2.1 to 4.6 lower). With the changes, the team took 17% less time at a 20% lower cost on the typical DRACO task, and scored 1.6 points lower (95% interval 0.3 to 2.8 lower).
10581068
1059106922. **HLE:** Phan et al., "Humanity's Last Exam," arXiv:2501.14249, 2025. Expert-written questions with exact answers, graded against the reference answers. Measured on the first 500 questions of the September 10, 2025, release, images included, with the benchmark's own sources blocked from search, and the same setup as reference 21. Each configuration made three attempts at each question, run September 24, 2026. Claude Opus 5 compares each answer with the reference answer, using the benchmark's published judge prompt, and the majority of three judgings counts. The scores cover 493 questions in every configuration. For five of the others, the grading request was over the judge's 1M-token limit, and the other two are left out because the run of the single agent without the changes stopped before three of its attempts on them finished. Time and cost ratios cover 492 questions for the single agent and 491 for the team, because one or two questions have no timing. A production safety classifier stopped 3% to 4% of each configuration's attempts, and those attempts score 0; leaving them out changes no finding. Results for [Show the model elapsed time](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): with the changes, the single agent took 14% less time at a 9% lower cost on the typical question. With the Claude Opus 5 judge, its score showed no clear change (0.9 points lower, 95% interval 2.5 lower to 0.7 higher). With a second grader, Claude Opus 4.6, its score was 1.9 points lower (95% interval 0.2 to 3.7 lower). Average time fell further than the typical question's: average time fell 43% and average cost 37%, because the changes cut a few very long questions short. The team's time on the typical question changed by 3% or less, and its score didn't change clearly.
10601070
from line 1076
10661076 * **When:** The two searches ran on September 6, 2026, driven by the Claude API skill's `hillclimb` command. The caching before-and-after pair ran on September 8, 2026.
10671077 * **How scored:** In the searches, the starting points and the confirmed configuration are the mean of three held-out runs, kept steps were judged on two runs, and other candidates were scored on one or two runs. The caching pair: three runs each on all 114 tasks with only the harness's cache breakpoints toggled, the configuration the `cost-optimize` command produced in an earlier run. Held-out numbers are on 57 tasks the search never read.
10681078 * **How priced:** Cost per task prices the agent's and the simulated user's token counts at list prices (Claude Opus 5 $5 USD and $25 USD, Claude Sonnet 5 $2 USD and $10 USD per million input and output tokens, cache reads and writes at their published rates) and excludes the judge; percent changes come from unrounded costs; the monthly figure is the agent's tokens alone, $0.135 USD and $0.047 USD per task, times 10,000. At 10,000 conversations a month, that is about $1,350 USD before the first search and $470 USD after.
1069 * **Caveats:** These measurements ran on the previous Claude Opus and Claude Sonnet models: the caching pair ran on Claude Sonnet 5, the second search started from Claude Sonnet 5, and the first search went from Claude Opus 5 to Claude Sonnet 5. Claude Fable 5.1 was not measured on this benchmark.
1079 * **Caveats:** These measurements ran on the previous Claude Opus and Claude Sonnet models: the caching pair ran on Claude Sonnet 5, the second search started from Claude Sonnet 5, and the first search went from Claude Opus 5 to Claude Sonnet 5.
10701080 * **Caching pair:** The pair ran on Claude Sonnet 5 at the default effort. The public harness, as shipped, sends the whole conversation uncached on every turn. The cached configuration has one breakpoint on the system prompt and one on the latest message. Both searches ran with that caching on. Cost per task went from $0.223 USD uncached to $0.062 USD cached, a 72% saving, and the pass rate from 79.2% to 76.0%. Identical cached runs of that configuration ranged from 85 to 93 of 114 across days. Every cached run scored at or below every uncached run, but the gap of under 4 tasks sits inside the spread of identical cached runs, so the accuracy change is too small to measure at this sample size.
10711081 * **How the search ran.** The `hillclimb` command asks four questions, presents a plan, and waits for approval before it spends anything. In the first search, the plan left the user simulator, grader, caching, temperature, and tasks unchanged. The last of the four questions began: `One pass over the full set is 114 cases x 1 rep on claude-opus-5, roughly 22 minutes.` Each round, the search proposes one change and runs the full set. It keeps the change only when the number moved and the predicted mechanism shows in the usage data. It stops when three rounds in a row bring nothing, then confirms the winner on fresh runs.
10721082 * **First search, result.** The search cut cost per task by 61% while holding the pass rate within a 2-point band set before the search: from Claude Opus 5 at the default effort ($0.142 USD a task, 76.0% passed) to Claude Sonnet 5 at `low` with one cost-neutral prompt edit ($0.055 USD, 74.3%). The search cost $179 USD in evaluation runs and $228 USD in its own tokens.
from line 1098
10881098 * **How priced:** Costs are token costs at list prices with 5-minute prompt caching, priced request by request, and exclude session runtime.
10891099 * **Results, token prices and cost:** Claude Haiku 4.5 did not cache 80% of its requests: each had a prompt of about 4,100 tokens or fewer, and its minimum cacheable prompt length is 4,096 tokens (512 for Claude Haiku 5.5). From Claude Haiku 4.5 to Claude Haiku 5.5, token prices fell by up to 90%, and the token cost of the 79 tasks fell by about 75%. The token cost fell less than the prices because about 5% of Claude Haiku 5.5's requests had prompts over 100,000 tokens, which pay higher prices ([Long context pricing](https://platform.claude.com/docs/en/about-claude/pricing#long-context-pricing)), and they carried 73% of its cost.
10901100 * **Thinking:** Anthropic set Claude Haiku 5.5's effort to `medium` and sent no thinking setting or output limit for either model, so thinking was left to Claude Managed Agents' own settings for each model. Claude Haiku 5.5 used thinking in 59% of requests, and Claude Haiku 4.5 in 22%. The comparison is of each model as served, not at equal settings.
1091 * **Cost without caching, priced from recorded token counts:** Anthropic also re-priced the recorded token counts of Claude Haiku 5.5's October 7 run for the caching factor in [Why caching comes first](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first); it made no run with caching off, and Claude Managed Agents applies prompt caching itself, so the factor compares two prices for the same requests, not two settings.
1101 * **Cost without caching, priced from recorded token counts:** Anthropic also re-priced the recorded token counts of Claude Haiku 5.5's October 7 run for the caching factor in [Why caching comes first](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first). Claude Managed Agents applies prompt caching itself, so the factor compares two prices for the same requests, not two settings.
10921102 * **The factor:** The factor, 1.7, is the run's token cost with every input token at the input price, output tokens unchanged, divided by its token cost with each session priced by itself: each request's prior prompt as a cache read and its new tokens as a 5-minute cache write. Each request is priced for its own prompt length in both costs, so the 87 requests over 100,000 tokens pay the higher prices in both. On the token counts as recorded, which this guide's costs for the run use, the factor is 1.9, because the five attempts of a task ran side by side and read each other's cache entries.
10931103 * **Why the factor is low:** The factor is low because the sessions are short, a median of 4 requests: most input tokens arrive as tool results on the second or third request and are read from the cache only once or twice. Eight long-context tasks hold three quarters of the cost. A second run, on October 8, also gives 1.7.
10941104
from line 1119
11091119 * **What was measured:** The 20-issue triage job from [Trim input and context tokens](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), run on Claude Sonnet 5 on August 19, 2026, with prompt caching on and no thinking setting in the request, so thinking was left at the model's default, three runs per configuration. The agent had its own two tools plus real tool definitions from public MCP servers, for a total of 7, 17, 52, 102, 252, or 502 tools, with every definition loaded or with the added ones marked `defer_loading` behind tool search.
11101120 * **How scored and priced:** Figures are the mean of the three runs at Claude Sonnet 5's list prices, and accuracy is exact match against the gold labels.
11111121 * **Results:** With every definition loaded, the run cost rose from $0.55 USD at 7 tools to $1.02 USD at 502 tools, nearly double. With tool search it was $0.55 USD to $0.56 USD at every catalog size, 45% less at 502 tools (from the chart's rounded costs, $0.56 USD and $1.02 USD; the unrounded means give 45.6%). Every run answered 15 to 18 of the 20 issues correctly, with or without tool search.
1112 * **Caveats:** No run called a tool from the catalog or the tool search tool: the agent's own two tools were always loaded, and every tool call went to one of them. The measurement shows what carrying unused definitions costs, not whether tool search finds a tool when one is needed.
1122 * **Caveats:** No run called a tool from the catalog or the tool search tool: the agent's own two tools were always loaded, and every tool call went to one of them. The measurement shows what carrying unused definitions costs.
11131123 * **Separate measurement:** In a separate measurement on the same model and date, with a public GitHub MCP server attached through the MCP connector and no catalog, three runs with the server's toolset deferred cost 20% less than three runs without ($0.56 USD and $0.70 USD per run), and the three runs of each arm answered 17, 16, and 16 issues correctly. The requests in this separate measurement included no tool search tool. With the toolset loaded, each run called one of the server's tools, `issue_read`, 3 or 4 times; with it deferred, no run called any of the server's tools.
11141124
1115112528. **Input trimming and context lifecycle measurements:**
agents-and-tools/mcp-connector Changed · +4 / -4 lines
from line 1276
12761276 <Tabs>
12771277 <Tab title="Gradle">
12781278 ```kotlin
1279 implementation("com.anthropic:anthropic-java:3.2.0")
1280 implementation("com.anthropic:anthropic-java-mcp:3.2.0")
1279 implementation("com.anthropic:anthropic-java:3.3.0")
1280 implementation("com.anthropic:anthropic-java-mcp:3.3.0")
12811281 ```
12821282 </Tab>
12831283
from line 1286
12861286 <dependency>
12871287 <groupId>com.anthropic</groupId>
12881288 <artifactId>anthropic-java</artifactId>
1289 <version>3.2.0</version>
1289 <version>3.3.0</version>
12901290 </dependency>
12911291 <dependency>
12921292 <groupId>com.anthropic</groupId>
12931293 <artifactId>anthropic-java-mcp</artifactId>
1294 <version>3.2.0</version>
1294 <version>3.3.0</version>
12951295 </dependency>
12961296 ```
12971297 </Tab>
api/beta Changed · +6 / -6 lines
This page is larger than the 256 KiB this site keeps, so one side of the diff below stops where the stored text does.
Nothing in the body moved in this read. What changed is above.
api/beta/organization Changed · +3 / -3 lines
This page is larger than the 256 KiB this site keeps, so one side of the diff below stops where the stored text does.
Nothing in the body moved in this read. What changed is above.
build-with-claude/claude-in-amazon-bedrock Changed · +4 / -4 lines
from line 102
102102 <Tabs>
103103 <Tab title="Gradle">
104104 ```kotlin
105 implementation("com.anthropic:anthropic-java:3.2.0")
106 implementation("com.anthropic:anthropic-java-bedrock:3.2.0")
105 implementation("com.anthropic:anthropic-java:3.3.0")
106 implementation("com.anthropic:anthropic-java-bedrock:3.3.0")
107107 ```
108108 </Tab>
109109
from line 112
112112 <dependency>
113113 <groupId>com.anthropic</groupId>
114114 <artifactId>anthropic-java</artifactId>
115 <version>3.2.0</version>
115 <version>3.3.0</version>
116116 </dependency>
117117 <dependency>
118118 <groupId>com.anthropic</groupId>
119119 <artifactId>anthropic-java-bedrock</artifactId>
120 <version>3.2.0</version>
120 <version>3.3.0</version>
121121 </dependency>
122122 ```
123123 </Tab>
build-with-claude/claude-models-on-google-cloud/anthropic-managed Changed · +4 / -4 lines
from line 175
175175
176176 <Tab title="Java">
177177 ```kotlin Gradle
178 implementation("com.anthropic:anthropic-java:3.2.0")
179 implementation("com.anthropic:anthropic-java-google-cloud:3.2.0")
178 implementation("com.anthropic:anthropic-java:3.3.0")
179 implementation("com.anthropic:anthropic-java-google-cloud:3.3.0")
180180 ```
181181
182182 ```xml Maven
from line 183
183183 <dependency>
184184 <groupId>com.anthropic</groupId>
185185 <artifactId>anthropic-java</artifactId>
186 <version>3.2.0</version>
186 <version>3.3.0</version>
187187 </dependency>
188188 <dependency>
189189 <groupId>com.anthropic</groupId>
190190 <artifactId>anthropic-java-google-cloud</artifactId>
191 <version>3.2.0</version>
191 <version>3.3.0</version>
192192 </dependency>
193193 ```
194194 </Tab>
build-with-claude/claude-models-on-google-cloud/google-managed Changed · +4 / -4 lines
from line 47
4747 <Tab title="Java">
4848 <CodeGroup exclude="shell, python, typescript, csharp, go, php, ruby">
4949 ```groovy Gradle
50 implementation("com.anthropic:anthropic-java:3.2.0")
51 implementation("com.anthropic:anthropic-java-vertex:3.2.0")
50 implementation("com.anthropic:anthropic-java:3.3.0")
51 implementation("com.anthropic:anthropic-java-vertex:3.3.0")
5252 ```
5353
5454 ```xml Maven
from line 55
5555 <dependency>
5656 <groupId>com.anthropic</groupId>
5757 <artifactId>anthropic-java</artifactId>
58 <version>3.2.0</version>
58 <version>3.3.0</version>
5959 </dependency>
6060 <dependency>
6161 <groupId>com.anthropic</groupId>
6262 <artifactId>anthropic-java-vertex</artifactId>
63 <version>3.2.0</version>
63 <version>3.3.0</version>
6464 </dependency>
6565 ```
6666 </CodeGroup>
build-with-claude/claude-on-amazon-bedrock-legacy Changed · +4 / -4 lines
from line 58
5858 <Tab title="Java">
5959 <CodeGroup exclude="shell, python, typescript, csharp, go, php, ruby">
6060 ```groovy Gradle
61 implementation("com.anthropic:anthropic-java:3.2.0")
62 implementation("com.anthropic:anthropic-java-bedrock:3.2.0")
61 implementation("com.anthropic:anthropic-java:3.3.0")
62 implementation("com.anthropic:anthropic-java-bedrock:3.3.0")
6363 ```
6464
6565 ```xml Maven
from line 66
6666 <dependency>
6767 <groupId>com.anthropic</groupId>
6868 <artifactId>anthropic-java</artifactId>
69 <version>3.2.0</version>
69 <version>3.3.0</version>
7070 </dependency>
7171 <dependency>
7272 <groupId>com.anthropic</groupId>
7373 <artifactId>anthropic-java-bedrock</artifactId>
74 <version>3.2.0</version>
74 <version>3.3.0</version>
7575 </dependency>
7676 ```
7777
build-with-claude/claude-platform-on-aws Changed · +4 / -4 lines
from line 308
308308
309309 <Tab title="Java">
310310 ```kotlin Gradle
311 implementation("com.anthropic:anthropic-java:3.2.0")
312 implementation("com.anthropic:anthropic-java-aws:3.2.0")
311 implementation("com.anthropic:anthropic-java:3.3.0")
312 implementation("com.anthropic:anthropic-java-aws:3.3.0")
313313 ```
314314
315315 ```xml Maven
from line 316
316316 <dependency>
317317 <groupId>com.anthropic</groupId>
318318 <artifactId>anthropic-java</artifactId>
319 <version>3.2.0</version>
319 <version>3.3.0</version>
320320 </dependency>
321321 <dependency>
322322 <groupId>com.anthropic</groupId>
323323 <artifactId>anthropic-java-aws</artifactId>
324 <version>3.2.0</version>
324 <version>3.3.0</version>
325325 </dependency>
326326 ```
327327 </Tab>
cli-sdks-libraries/cli/apply Changed · +82 / -1 lines
from line 208
208208
209209To point at a resource these files don't manage, write its ID (`agent_...`, `skill_...`) instead. Anything else, such as `{type: anthropic, skill_id: xlsx}`, is sent to the API as written. A skill reference can also be a GitHub URL of the form `https://github.com/<owner>/<repo>/tree/<branch>/<dir>`, for example a directory of Anthropic's open-source [skills repository](https://github.com/anthropics/skills): `ant apply` downloads and uploads that directory, pinned to the resolved commit until you run with `--upgrade` (set `GITHUB_TOKEN` for a private repository).
210210
211A path can also be a glob. Under `skills`, a glob references every skill it matches and skips anything else it matches, such as a README. Under an agent's `tools`, a path or glob names YAML or JSON files instead of resources: `ant apply` inserts each file's contents, one tool or a list of tools, into the list at that position. Put those files in a subdirectory such as `agents/tools/`, because `ant apply` refuses to insert a file that it would also read as an agent. A path or glob that matches nothing is an error.
212
213```markdown agents/reviewer.md
214---
215name: Code reviewer
216model: claude-opus-5-5
217tools:
218 - type: agent_toolset_20260401
219 - ./tools/*.json # the tools in these files are inserted here
220skills:
221 - ../skills/* # every skill under skills/
222---
223
224You review pull requests for correctness, security, and readability.
225```
226
227```json agents/tools/get_ci_status.json
228{
229 "type": "custom",
230 "name": "get_ci_status",
231 "description": "Get the CI status of a pull request",
232 "input_schema": {
233 "type": "object",
234 "properties": {
235 "pull_request": {
236 "type": "integer",
237 "description": "Pull request number"
238 }
239 },
240 "required": ["pull_request"]
241 }
242}
243```
244
211245### How ant apply infers a file's kind
212246
213247When `ant apply` walks a directory, it determines each file's kind from the first of these that matches:
from line 273
239273* Run one apply at a time, because nothing locks the lockfile.
240274* Authenticate with [Workload Identity Federation](https://platform.claude.com/docs/en/manage-claude/workload-identity-federation) rather than a stored API key, as an identity that reaches the organization and workspace recorded in `claude-lock.json`. `ant apply` refuses credentials that resolve to any other organization or workspace.
241275
242For a complete GitHub Actions workflow, see the [CI example in the CLI README](https://github.com/anthropics/anthropic-cli#in-ci).
276This GitHub Actions workflow does all of that except the pull request plan. It applies on every push to `main`:
277
278```yaml .github/workflows/ant-apply.yml
279name: ant apply
280on:
281 push:
282 branches: [main]
283 paths-ignore: [claude-lock.json] # so the lockfile commit doesn't start this workflow again
284
285jobs:
286 apply:
287 runs-on: ubuntu-latest
288 environment: agents-prod # protect it in GitHub: required reviewers, main only
289 concurrency: ant-apply # one apply at a time
290 permissions:
291 id-token: write # to request the identity token
292 contents: write # to push the lockfile commit
293 env:
294 ANTHROPIC_FEDERATION_RULE_ID: fdrl_...
295 ANTHROPIC_ORGANIZATION_ID: 00000000-0000-0000-0000-000000000000
296 ANTHROPIC_SERVICE_ACCOUNT_ID: svac_...
297 ANTHROPIC_IDENTITY_TOKEN_FILE: /tmp/gha-jwt
298 steps:
299 - uses: actions/checkout@v5
300 with:
301 ref: main # the tip of main, so a queued run has the previous run's lockfile commit
302 - uses: anthropics/setup-ant@v1 # installs the ant CLI
303 - name: Fetch GitHub OIDC token
304 run: |
305 curl -fsS -H "Authorization: Bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
306 "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=https://api.anthropic.com" \
307 | jq -r .value > "$ANTHROPIC_IDENTITY_TOKEN_FILE"
308 - name: Apply
309 run: ant apply --yes .
310 - name: Commit the lockfile
311 if: always() # a partial apply still records what it created
312 run: |
313 git diff --quiet claude-lock.json && exit 0 # nothing changed
314 git config user.name "github-actions[bot]"
315 git config user.email "github-actions[bot]@users.noreply.github.com"
316 git commit -am "Update claude-lock.json [skip ci]"
317 git pull --rebase # main can move during the apply, and a plain push would then be rejected
318 git push
319```
320
321Run the first `ant apply` on your machine and commit `claude-lock.json` before you turn the workflow on. The last step commits changes only to a lockfile that Git already tracks.
322
323To create the federation rule and service account that the `env` block names, see [Use WIF with GitHub Actions](https://platform.claude.com/docs/en/manage-claude/wif-providers/github-actions). Enable the rule for a single workspace, the one recorded in `claude-lock.json`, so that the token exchange doesn't need a workspace ID. Because the job names an environment, its identity token's `sub` claim is `repo:<owner>/<repo>:environment:agents-prod`, so that's the value the rule's `subject_prefix` must match.
243324
244325## Flags
245326
cli-sdks-libraries/middleware Changed · +16 / -12 lines
from line 130
130130 .build();
131131 ```
132132
133 ```php PHP
134 $loggingMiddleware = function (RequestInterface $request, callable $next): ResponseInterface {
135 // Before the request
136 error_log("-> {$request->getMethod()} {$request->getUri()}");
133 <CodeGroupItem>
134 ```php PHP
135 $loggingMiddleware = function (RequestInterface $request, callable $next): ResponseInterface {
136 // Before the request
137 error_log("-> {$request->getMethod()} {$request->getUri()}");
137138
138 // Forward the request to the rest of the chain
139 $response = $next($request);
139 // Forward the request to the rest of the chain
140 $response = $next($request);
140141
141 // After the request
142 error_log("<- {$response->getStatusCode()}");
142 // After the request
143 error_log("<- {$response->getStatusCode()}");
143144
144 return $response;
145 };
145 return $response;
146 };
146147
147 $client = new Client(requestOptions: ['middleware' => [$loggingMiddleware]]);
148 ```
148 $client = new Client(requestOptions: ['middleware' => [$loggingMiddleware]]);
149 ```
150
151 For middleware classes, the request options argument, and how middleware interacts with retries, errors, and request signing, see [Middleware in the PHP SDK](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/php#middleware).
152 </CodeGroupItem>
149153
150154 ```ruby Ruby
151155 logging_middleware = lambda do |request, call_next|
cli-sdks-libraries/overview Changed · +5 / -5 lines
from line 7
77Anthropic provides three kinds of official tooling for building with the Claude API:
88
99* **CLI:** The `ant` command-line tool for shell scripting and interactive use.
10* **Client SDKs:** General-purpose Messages API clients for Python, TypeScript, C#, Go, Java, PHP, and Ruby. Each SDK provides idiomatic interfaces, type safety, and built-in support for streaming, retries, and error handling.
10* **Client SDKs:** General-purpose Messages API clients for Python, TypeScript, C#, Go, Java, PHP, and Ruby. Each SDK provides idiomatic interfaces, type safety, and built-in support for streaming, retries, error handling, and [OpenTelemetry tracing](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
1111* **Libraries and integrations:** Packages and compatibility layers that expose Claude inside another framework's API surface rather than the Messages API directly.
1212
1313<Info>
from line 61
6161| Tool | Latest version | Package |
6262| ---------- | -------------- | ----------------------------------------------------------------------------------------------------------- |
6363| ant CLI | `2.2.0` | [`github.com/anthropics/anthropic-cli`](https://github.com/anthropics/anthropic-cli/releases) |
64| Python | `2.2.0` | [`anthropic` on PyPI](https://pypi.org/project/anthropic/) |
64| Python | `2.3.0` | [`anthropic` on PyPI](https://pypi.org/project/anthropic/) |
6565| TypeScript | `1.2.0` | [`@anthropic-ai/sdk`](https://www.npmjs.com/package/@anthropic-ai/sdk) |
6666| C# | `13.2.1` | [`Anthropic`](https://www.nuget.org/packages/Anthropic) |
67| Go | `2.2.0` | [`github.com/anthropics/anthropic-sdk-go/v2`](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go/v2) |
67| Go | `2.3.0` | [`github.com/anthropics/anthropic-sdk-go/v2`](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go/v2) |
6868| Java | `3.2.0` | [`com.anthropic:anthropic-java`](https://central.sonatype.com/artifact/com.anthropic/anthropic-java) |
69| PHP | `1.2.0` | [`anthropic-ai/sdk`](https://packagist.org/packages/anthropic-ai/sdk) |
70| Ruby | `2.2.0` | [`anthropic` on RubyGems](https://rubygems.org/gems/anthropic) |
69| PHP | `1.3.0` | [`anthropic-ai/sdk`](https://packagist.org/packages/anthropic-ai/sdk) |
70| Ruby | `2.3.0` | [`anthropic` on RubyGems](https://rubygems.org/gems/anthropic) |
7171
7272The same versions are available as JSON at `https://platform.claude.com/docs/sdk-versions.json`.
7373
cli-sdks-libraries/sdks/csharp Changed · +4 / -0 lines
### OpenTelemetry tracing
from line 403
403403export ANTHROPIC_LOG=debug
404404```
405405
406### OpenTelemetry tracing
407
408When your application adds the SDK's sources to its OpenTelemetry tracer provider with `AddSource("com.anthropic.sdk.csharp*")`, the SDK emits a span for each request that it sends. To send the spans to your observability platform, see [Set up OpenTelemetry with the Claude SDK](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
409
406410### Undocumented API functionality
407411
408412The SDK is typed for convenient usage of the documented API. However, it also supports working with undocumented or not yet supported parts of the API.
cli-sdks-libraries/sdks/go Changed · +4 / -0 lines
### OpenTelemetry tracing
from line 674
674674fmt.Printf("Headers: %+#v\n", response.Header)
675675```
676676
677### OpenTelemetry tracing
678
679When your application registers an OpenTelemetry tracer provider, the SDK emits a span for each request that it sends. To send the spans to your observability platform, see [Set up OpenTelemetry with the Claude SDK](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
680
677681### Making custom/undocumented requests
678682
679683This library is typed for convenient access to the documented API. If you need to access undocumented endpoints, parameters, or response properties, the library can still be used.
cli-sdks-libraries/sdks/java Changed · +6 / -2 lines
### OpenTelemetry tracing
from line 15
1515<Tabs>
1616 <Tab title="Gradle">
1717 ```kotlin
18 implementation("com.anthropic:anthropic-java:3.2.0")
18 implementation("com.anthropic:anthropic-java:3.3.0")
1919 ```
2020 </Tab>
2121
from line 24
2424 <dependency>
2525 <groupId>com.anthropic</groupId>
2626 <artifactId>anthropic-java</artifactId>
27 <version>3.2.0</version>
27 <version>3.3.0</version>
2828 </dependency>
2929 ```
3030 </Tab>
from line 1170
11701170
11711171 ProGuard and R8 should automatically detect and use the published rules, but you can also manually copy the keep rules if necessary.
11721172</Accordion>
1173
1174### OpenTelemetry tracing
1175
1176When your application registers an OpenTelemetry tracer provider, the SDK emits a span for each request that it sends. To send the spans to your observability platform, see [Set up OpenTelemetry with the Claude SDK](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
11731177
11741178### Undocumented API functionality
11751179
cli-sdks-libraries/sdks/php Changed · +38 / -0 lines
### OpenTelemetry tracing ### Middleware
from line 167
167167
168168## Advanced usage
169169
170### OpenTelemetry tracing
171
172When your application registers an OpenTelemetry tracer provider, the SDK emits a span for each request that it sends. To send the spans to your observability platform, see [Set up OpenTelemetry with the Claude SDK](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
173
170174### Undocumented properties
171175
172176You can send undocumented parameters to any endpoint, and read undocumented response properties, as follows:
from line 215
211215 body: ['hello' => 'world']
212216);
213217```
218
219### Middleware
220
221Middleware runs your code around every HTTP request the client sends. [SDK middleware](https://platform.claude.com/docs/en/cli-sdks-libraries/middleware) shows how to register a middleware and the order in which several run. This section covers the details that are specific to the PHP SDK.
222
223A middleware is a callable that takes the request and `$next`, or an instance of a class that implements `Anthropic\Middleware`, whose `handle()` method has the same signature. The `middleware` request option accepts both:
224
225```php
226use Anthropic\Middleware;
227use Psr\Http\Message\RequestInterface;
228use Psr\Http\Message\ResponseInterface;
229
230final class TracingMiddleware implements Middleware
231{
232 public function handle(RequestInterface $request, \Closure $next): ResponseInterface
233 {
234 return $next($request->withHeader('x-trace-id', bin2hex(random_bytes(8))));
235 }
236}
237
238$client = new Client(requestOptions: ['middleware' => [new TracingMiddleware()]]);
239```
240
241`$next` runs the rest of the chain and sends the request. Call it once to forward the request, skip the call to return your own response (such as a cached one), or call it several times to send follow-up requests (such as a custom retry).
242
243The SDK also passes every middleware a third argument: the request's `Anthropic\RequestOptions`, which merges the client's options with the options of the call. To read an option such as `fallbackState`, declare an optional third parameter, `?RequestOptions $options = null`. Treat the object as read-only, because every middleware and every retry of the request shares it. If your callable already has a third parameter with another purpose, rewrite it, because the SDK fills that parameter on every call.
244
245At runtime:
246
247* **Retries:** Middleware runs once for each HTTP attempt, inside the SDK's retry loop, so it runs again on each retry.
248* **Error responses:** `$next` returns a response for every HTTP status. The SDK throws its [typed exceptions](https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/php#error-handling) only after the whole chain returns, so a middleware can inspect or replace a 4xx or 5xx response.
249* **Exceptions:** An exception that a middleware throws reaches your code unchanged, except in two cases. The SDK handles a PSR-18 `ClientExceptionInterface` as a connection error, which surfaces as `APIConnectionException`. It retries the attempt after an `Anthropic\Core\Exceptions\RetryableException`, and throws that exception unchanged when no retries are left.
250* **Authentication:** The SDK refreshes OAuth tokens, and signs or authorizes Amazon Bedrock and Google Cloud requests, inside the innermost `$next`. A request that your middleware changes is therefore signed after the change, and again each time you call `$next`.
251* **Response bodies:** A middleware that reads the response body must rewind it, or return `$response->withBody(...)` with a new body, so that the SDK can still decode it. A streaming body can't be rewound, so pass it through unread.
214252
215253## Platform integrations
216254
cli-sdks-libraries/sdks/python Changed · +4 / -0 lines
### OpenTelemetry tracing
from line 641
641641export ANTHROPIC_LOG=debug
642642```
643643
644### OpenTelemetry tracing
645
646When your application registers an OpenTelemetry tracer provider, the SDK emits a span for each request that it sends. To send the spans to your observability platform, see [Set up OpenTelemetry with the Claude SDK](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
647
644648### Making custom/undocumented requests
645649
646650This library is typed for convenient access to the documented API. If you need to access undocumented endpoints, parameters, or response properties, the library can still be used.
cli-sdks-libraries/sdks/ruby Changed · +4 / -0 lines
## OpenTelemetry tracing
from line 341
341341
342342Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
343343
344## OpenTelemetry tracing
345
346When your application registers an OpenTelemetry tracer provider, the SDK emits a span for each request that it sends. To send the spans to your observability platform, see [Set up OpenTelemetry with the Claude SDK](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
347
344348## Making custom or undocumented requests
345349
346350### Undocumented properties
cli-sdks-libraries/sdks/typescript Changed · +4 / -0 lines
### OpenTelemetry tracing
from line 619
619619});
620620```
621621
622### OpenTelemetry tracing
623
624When your application registers an OpenTelemetry tracer provider, the SDK emits a span for each request that it sends. To send the spans to your observability platform, see [Set up OpenTelemetry with the Claude SDK](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
625
622626### Making custom/undocumented requests
623627
624628This library is typed for convenient access to the documented API. If you need to access undocumented endpoints, parameters, or response properties, the library can still be used.
manage-claude/analytics-api Changed · +12 / -1 lines
### Claude Code through Amazon Bedrock ### Claude Code and Cowork with customer-managed encryption keys
from line 101
101101* They had at least one Claude Code session (local or remote) associated with your Claude Enterprise organization that included tool use or git activity.
102102* They had at least one Cowork session with tool use or message activity.
103103
104**Chat and Cowork unified (beta).** Chat and Cowork unified brings Cowork's features into claude.ai chat. Most activity in Chat and Cowork unified is reported under the `chat_cowork_unified` product value, not `chat` or `cowork`.
104**Chat and Cowork unified.** Chat and Cowork unified brings Cowork's features into claude.ai chat. Most activity in Chat and Cowork unified is reported under the `chat_cowork_unified` product value, not `chat` or `cowork`.
105105
106106In user activity and in skill, connector, and plugin usage, this usage appears in the `chat_cowork_unified_metrics` object. In activity summaries, it is counted in `chat_cowork_unified_daily_active_user_count`, `chat_cowork_unified_weekly_active_user_count`, and `chat_cowork_unified_monthly_active_user_count`.
107107
from line 133
133133
134134## Known limitations
135135
136### Claude Code through Amazon Bedrock
137
136138If your organization uses Claude Code through Amazon Bedrock, the Claude Enterprise Analytics API does not return Claude Code activity for that usage.
139
140### Claude Code and Cowork with customer-managed encryption keys
141
142If your organization uses [customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek), Anthropic leaves some details of Claude Code and Cowork use out of its usage analytics, to protect your data. As a result, do not use the following Claude Enterprise Analytics API numbers to measure how much your organization uses Claude Code or Cowork. They can be zero or lower than actual use:
143
144* **Code changes:** In user activity, these fields in `claude_code_metrics.core_metrics` can be zero: `lines_of_code` (lines added and removed) and `commit_count`. The `pull_request_count` field can be lower than the real number of pull requests.
145* **Skills started with a slash command:** If a user starts a skill in Claude Code or Cowork by typing a slash command, such as `/skill-name`, that use is not counted. This applies to skill usage, and to Cowork skill counts in user activity. Skills that Claude invokes without a slash command are still counted.
146
147For other analytics changes with customer-managed encryption keys, see [Customer-managed encryption keys](https://platform.claude.com/docs/en/manage-claude/cmek#disabled-or-modified).
137148
138149## Next steps
139150
api/beta/files Changed · +1 / -1 lines
from line 137
137137
138138### Body parameters (form-data)
139139
140- `file: string`
140- `file: file`
141141
142142 The file to upload. Only the final path component of the part's `filename` is kept; an absent or empty `filename` is replaced with `unnamed` plus the extension for the file's stored `mime_type`, when known.
143143
api/beta/files/upload Changed · +1 / -1 lines
from line 135
135135
136136## Body parameters (form-data)
137137
138- `file: string`
138- `file: file`
139139
140140 The file to upload. Only the final path component of the part's `filename` is kept; an absent or empty `filename` is replaced with `unnamed` plus the extension for the file's stored `mime_type`, when known.
141141
api/beta/organization/plugin_marketplaces Changed · +1 / -1 lines
from line 1262
12621262
12631263### Body parameters (form-data)
12641264
1265- `archive: string`
1265- `archive: file`
12661266
12671267 A .zip of the marketplace directory (its contents at the root, or wrapped in one folder as a Git host's download produces), sent as a file part with a filename; DEFLATE- or STORE-compressed, at most 32 MB. A part sent without a filename, a second archive part, or any other form field is a 400; a larger archive is a 413.
12681268
api/beta/organization/plugin_marketplaces/validate_archive Changed · +1 / -1 lines
from line 142
142142
143143## Body parameters (form-data)
144144
145- `archive: string`
145- `archive: file`
146146
147147 A .zip of the marketplace directory (its contents at the root, or wrapped in one folder as a Git host's download produces), sent as a file part with a filename; DEFLATE- or STORE-compressed, at most 32 MB. A part sent without a filename, a second archive part, or any other form field is a 400; a larger archive is a 413.
148148
api/beta/organization/plugins Changed · +2 / -2 lines
from line 155
155155
156156### Body parameters (form-data)
157157
158- `files: array of string`
158- `files: array of file`
159159
160160 The version's files: one part per file, the part's filename being the file's path within the Plugin (for example `skills/review-pr/SKILL.md`), or a single `.zip` or `.plugin` archive holding them all. On the wire each part is named `files[]`, and a part named plain `files` is not read; with cURL, `-F 'files[][email protected];filename=skills/review-pr/SKILL.md'`. The files must include the manifest, `.claude-plugin/plugin.json`.
161161
from line 2368
23682368
23692369#### Body parameters (form-data)
23702370
2371- `files: array of string`
2371- `files: array of file`
23722372
23732373 The version's files: one part per file, the part's filename being the file's path within the Plugin (for example `skills/review-pr/SKILL.md`), or a single `.zip` or `.plugin` archive holding them all. On the wire each part is named `files[]`, and a part named plain `files` is not read; with cURL, `-F 'files[][email protected];filename=skills/review-pr/SKILL.md'`. The files must include the manifest, `.claude-plugin/plugin.json`.
23742374