# Claude Opus 5.5 Explained: Anthropic’s Faster, Cheaper Model Built for Long-Running AI Agents Claude Opus 5.5 explained: pricing, benchmarks, Claude Code performance, API changes, context limits, safety, and how it compares with Opus 5. Canonical URL: https://aiidelist.com/blog/what-is-claude-opus-5-5 Language: en Published: 2026-09-22 Updated: 2026-09-22 ## Key Takeaways - **Claude Opus 5.5 launched on September 22, 2026** as the first model in Anthropic’s Claude 5.5 family. - Anthropic says it performs at roughly **Claude Fable 5.1 level on most real-world work**, while typical workloads cost about **40% less to run than Claude Opus 5**. - API pricing falls to **$4 per million input tokens and $20 per million output tokens**, down 20% from Opus 5. Prompt-cache reads fall even more sharply, from $0.50 to **$0.20 per million tokens**. - Opus 5.5 is especially optimized for **long-running coding agents, repository-wide migrations, code audits, tool use, research, and multi-step knowledge work**. - Anthropic reports output generation more than **30% faster than Opus 5**, while Fast Mode offers up to **2.5× speed** at premium token pricing. - The most important improvement may not be a single benchmark score. Opus 5.5 often needs **fewer tokens, tool calls, retries, and agent steps to finish the same task**, materially changing the economics of autonomous AI agents. - Opus 5.5 also introduces stronger safety controls, including transparent model fallback for certain cybersecurity and biology requests and preserved thinking for newer API accounts. ![Image](https://cdn.aiidelist.com/api/image/o3I2U3Wx0rX-7rtg7-vkO.webp) ## What Is Claude Opus 5.5? Claude Opus 5.5 is Anthropic’s new high-end AI model for complex coding, agentic workflows, research, computer use, and professional knowledge work. Anthropic released the model on **September 22, 2026**, describing it as the first member of a new Claude 5.5 generation. The company says Opus 5.5 reaches the level of its more expensive Claude Fable 5.1 model on most work while substantially improving the cost and speed profile of the previous Opus generation. [Anthropic’s official announcement](https://www.anthropic.com/claude-opus-5-5) provides the full launch details. This positioning matters because Opus models have historically targeted demanding work rather than maximum throughput. Opus 5.5 changes that equation by making frontier-level agent performance substantially cheaper to deploy continuously. The central idea behind the release can be summarized as: **higher task completion quality + fewer tokens + fewer agent steps + lower per-token pricing.** That combination is particularly important for coding agents, where the cost of a task is determined by far more than the final answer. ![Image](https://cdn.aiidelist.com/api/image/M2Oe8GjRIiUf0hkzRW1-o.webp) ## Claude Opus 5.5 Specifications | Specification | Claude Opus 5.5 | | --- | --- | | Release date | September 22, 2026 | | Claude API model ID | `claude-opus-5-5` | | Input price | $4 / 1M tokens | | Output price | $20 / 1M tokens | | Cache read price | $0.20 / 1M tokens | | Cache write price | $5 / 1M tokens | | Fast Mode input | $8 / 1M tokens | | Fast Mode output | $40 / 1M tokens | | Fast Mode speed | Up to 2.5× | | Thinking | Cannot be switched off | | Availability | Claude Platform, Claude Code, AWS, Google Cloud, Microsoft Azure and other Claude surfaces | Anthropic states that Opus 5.5 is available across its platforms under the API model identifier `claude-opus-5-5`. ## Claude Opus 5.5 Pricing The headline token-price reduction is straightforward. | Cost | Claude Opus 5.5 | Claude Opus 5 | Change | | --- | ---: | ---: | ---: | | Input | $4 / MTok | $5 / MTok | -20% | | Output | $20 / MTok | $25 / MTok | -20% | | Cache read | $0.20 / MTok | $0.50 / MTok | -60% | | Cache write | $5 / MTok | $6.25 / MTok | -20% | The more interesting number, however, is Anthropic’s claim that **typical workload cost falls by approximately 40%**. That is not the same as saying token prices were cut by 40%. The larger workload-level saving comes from two effects working together: - each token is cheaper; - Opus 5.5 often needs fewer tokens and fewer steps to complete the task. This distinction is especially important for developers estimating agent costs. A traditional chatbot request might involve one prompt and one answer. A coding agent may instead perform dozens or hundreds of operations: ```text read repository → search files → inspect dependencies → reason about architecture → edit files → run tests → inspect failure → modify implementation → run tests again → review diff → delegate to subagent → verify result ``` Every iteration consumes context, cached tokens, generated tokens, and tool calls. Reducing the number of iterations can therefore matter as much as reducing the token price itself. ![Image](https://cdn.aiidelist.com/api/image/uc2M6lb72YZ-fJpO3QufR.webp) ![Image](https://cdn.aiidelist.com/api/image/12GeK_LuBwwUwTzTs-mxP.webp) ![Image](https://cdn.aiidelist.com/api/image/mTUFpIj5GQc5RR8VMMCZg.webp) ![Image](https://cdn.aiidelist.com/api/image/16owlkmNsvzvDBmIPGAxz.webp) ## Why the Cache Read Price Matters So Much The reduction from **$0.50 to $0.20 per million cached tokens** is one of the most important pricing changes in Opus 5.5. Anthropic says cache reads account for the majority of costs in many coding and agentic workloads. Consider an agent repeatedly working against a large repository. It may reuse hundreds of thousands of tokens containing: - project instructions; - source files; - dependency information; - previous tool results; - architectural context; - conversation history. Prompt caching prevents the full input price from being charged every time that material is reused. A 60% reduction in cache-read pricing therefore makes long-running sessions disproportionately cheaper than the headline 20% input-price reduction suggests. This is one reason Opus 5.5 is better understood as an **agent economics upgrade**, not simply a cheaper language model. ## Claude Opus 5.5 Benchmarks Anthropic reports substantial gains across coding, knowledge work, computer use, and scientific-agent evaluations. | Benchmark | Opus 5.5 | Fable 5.1 | Opus 5 | GPT-6 Astra | GPT-5.6 Sol | | --- | ---: | ---: | ---: | ---: | ---: | | Terminal-Bench 4.0 | **66.4%** | 55.8% | 52.3% | 57.9% | 37.3% | | FrontierCode v1.1 | **54.4%** | 50.3% | 48.0% | 53.3% | 47.5% | | CursorBench 4.0 | **57.8%** | 51.8% | 46.6% | — | 41.7% | | GDPval-AA v2.1 | **1846** | 1735 | 1708 | 1542 | 1588 | | AutomationBench | 40.0% | 31.4% | 26.9% | **41.4%** | 28.8% | | Humanity's Last Exam with tools | **67.7%** | 65.6% | 63.6% | 57.2% | — | | Terminal-Bench-Science 0.1 | 58.7% | 52.6% | 29.0% | **64.6%** | 22.4% | | OSWorld 2.0 | **81.8%** | 80.7% | 74.0% | — | — | The table shows strong performance, but it needs several qualifications. First, **Opus 5.5 does not lead every benchmark**. GPT-6 Astra scores higher on AutomationBench and Terminal-Bench-Science in the figures published by Anthropic. Second, benchmark configurations are not perfectly identical. Anthropic notes differences in effort levels, evaluation harnesses, vendor-reported results, and safety routing. Third, Anthropic explicitly warns that benchmark margins now exaggerate some of the differences people may experience in real work. The company says the practical gap between Opus 5.5 and Fable 5.1 is narrower than benchmark tables imply. That is an unusually important caveat. For teams choosing a production model, **task success per dollar** may be more useful than simply selecting the model with the highest benchmark percentage. ![Image](https://cdn.aiidelist.com/api/image/qjRpP_MIDGmWhN87jqgtm.webp) ## Claude Opus 5.5 for Coding Coding is arguably the strongest reason to pay attention to Opus 5.5. The model is designed for tasks that extend far beyond generating isolated functions or explaining code snippets. Its target workload includes: - repository-wide migrations; - large refactors; - dependency upgrades; - debugging across multiple services; - codebase audits; - long-running test-and-fix loops; - autonomous implementation; - multi-agent software development; - code review and bug discovery. Anthropic reports that an early tester used Opus 5.5 to complete a **680,000-line code migration in less than one day**. Another test involved auditing and fixing a **200,000-line codebase**. Opus 5.5 completed the work in under three hours, while Opus 5 reportedly took more than 20 hours and consumed roughly 2.5 times as many tokens. These examples are vendor-selected evaluations rather than independent controlled benchmarks, so they should not be interpreted as universal performance guarantees. They are still useful because they reveal the type of workload Anthropic is optimizing for. ## The HAProxy Rewrite Test One of Anthropic’s more interesting internal experiments involved asking Opus 5.5 and Fable 5.1 to rewrite **HAProxy from C to Rust**. Both implementations reportedly passed nearly all of HAProxy’s regression tests. The difference was execution efficiency: - **Opus 5.5:** 9.5 hours - **Fable 5.1:** 12 hours - **Opus 5.5 cost:** 51% lower The significance is not that developers should immediately use AI to rewrite mature infrastructure projects from C to Rust. The useful signal is that models are becoming capable of maintaining coherence across **hours of autonomous software work involving extremely large dependency graphs and test suites**. That is a different capability category from conventional code generation. ## Claude Opus 5.5 in Claude Code Claude Code is one of the environments where Opus 5.5’s efficiency improvements may matter most. Coding agents repeatedly read files, invoke shell commands, inspect outputs, maintain context, run tests, and revise code. The quality of an agent therefore depends heavily on whether the underlying model can avoid unnecessary loops. Early-access reports published by Anthropic consistently emphasize this characteristic. GitHub reported that Opus 5.5 used among the fewest tokens and steps in tests across GitHub Copilot CLI and VS Code. In its VS Code terminal evaluation, the model reportedly solved more tasks than Opus 5 while using less than half as many steps. Lovable reported that the model gathers context fewer times, makes more complete edits, and finishes tasks using substantially fewer steps and tokens. Optiver reported roughly comparable coding quality to Opus 5 using about half the turns, time, and output tokens in its agentic coding workload, cutting workload cost by approximately 40–50%. These testimonials were selected for Anthropic’s launch announcement, so independent tests remain important. However, the pattern is consistent with Anthropic’s broader efficiency claims. ## Why Fewer Agent Steps Matter Agent reliability compounds across steps. Imagine an agent where every major reasoning or execution step has a 98% chance of being correct. A five-step workflow has a much better chance of finishing cleanly than a fifty-step workflow. This means an agent that can solve a problem using fewer operations gains benefits beyond token savings: - lower latency; - fewer opportunities for tool errors; - fewer chances to lose context; - fewer incorrect edits; - less repetitive repository scanning; - lower probability of entering retry loops; - easier human review. This may explain why efficiency improvements can translate into disproportionately better real-world agent performance even when benchmark gains look incremental. ## Opus 5.5 vs Opus 5 Opus 5.5 improves on Opus 5 across three major dimensions. ### Lower Cost Input and output prices fall by 20%, while cache reads fall by 60%. ### Higher Agent Efficiency Anthropic and several early testers report significantly fewer tokens, steps, and retries for equivalent tasks. ### Faster Output Anthropic says normal Opus 5.5 generation is **more than 30% faster** than Opus 5. The combined effect means migration decisions should not be based solely on the price-per-million-token table. A workload that becomes both cheaper per token and shorter can produce much larger savings. ## Opus 5.5 vs Claude Fable 5.1 Fable 5.1 remains an important comparison because Anthropic explicitly frames Opus 5.5 as reaching similar real-world capability on most work. Benchmark results frequently place Opus 5.5 ahead, but Anthropic cautions that this does not necessarily mean users will observe a similarly large quality gap. The practical distinction increasingly appears to be about **how much capability is needed per task and how much that capability costs**. For many coding and professional workloads, Opus 5.5 could provide a more economical starting point. Extremely difficult frontier workloads should still be evaluated directly against Fable rather than assuming benchmark order determines the answer. The correct production strategy is to test both models against representative tasks and measure: - completion rate; - human correction rate; - total output tokens; - cache usage; - number of tool calls; - elapsed time; - retries; - cost per successfully completed task. ## Opus 5.5 vs GPT-6 Astra Anthropic’s launch benchmarks also compare Opus 5.5 with OpenAI’s GPT-6 Astra. The results are mixed rather than universally one-sided. Opus 5.5 leads the published figures for Terminal-Bench 4.0, FrontierCode, GDPval-AA, and Humanity’s Last Exam with tools, while GPT-6 Astra leads AutomationBench and Terminal-Bench-Science. Anthropic emphasizes cost efficiency in this comparison. At default effort, it says Opus 5.5 beats GPT-6 Astra’s reported FrontierCode result at roughly one-fifth of the cost per task and reaches similar Terminal-Bench performance at around 40% of the cost. These numbers should be treated carefully because model effort settings and evaluation environments differ. For developers choosing between ecosystems, the more useful comparison is therefore not simply: **Which model scores higher?** It is: **Which agent completes the actual repository task reliably at the lowest total cost and with the least human intervention?** ## Medium Effort May Be the Important Default One subtle change in Opus 5.5 is how strong the model appears at lower effort settings. Several launch evaluations highlighted medium or even low effort rather than relying exclusively on maximum reasoning. For example, Factory reported that Opus 5.5 at medium effort matched Opus 5 at high effort in its testing while consuming 20–25% fewer output tokens. Anthropic also reports a **54.6% FrontierCode score at default medium effort**, slightly above GPT-6 Astra’s reported top score of 53.3%, while costing substantially less per task. This matters operationally. If a model needs maximum reasoning for every request, applications pay the latency and token cost even when the problem is routine. A strong medium-effort setting makes it easier to reserve expensive reasoning for genuinely difficult cases. ## Thinking Can No Longer Be Disabled Opus 5.5 changes how developers should think about reasoning controls. Anthropic states that the model is **no longer available with thinking switched off**. That suggests a shift from the older binary decision of whether a model should reason toward a model where adaptive reasoning is part of normal operation and developers mainly control the amount of effort. Applications migrating from older Claude implementations should therefore test assumptions around: - latency; - output-token usage; - effort settings; - conversation-state handling; - reasoning-related API behavior. ## Fast Mode Claude Opus 5.5 supports Fast Mode in Claude Code and the Claude Platform. Anthropic advertises up to **2.5× output speed**, with pricing of: - $8 per million input tokens; - $40 per million output tokens. That is approximately double standard Opus 5.5 token pricing. Fast Mode therefore makes the most sense where latency has direct business value, such as: - interactive coding sessions; - time-sensitive agent workflows; - developer tools where users are waiting on execution; - complex tasks where reducing wall-clock time matters more than minimizing inference cost. For unattended overnight agents, standard mode may remain more economical. ## Better Writing Is More Important Than It Sounds Anthropic also made communication quality a major part of the Opus 5.5 release. The company says Opus 5.5 puts important information earlier, uses less jargon, avoids some idiosyncratic wording, and follows writing constraints more reliably than Opus 5. This may appear secondary to coding benchmarks, but communication quality directly affects long-running agents. Developers reviewing an autonomous agent need to understand: - what changed; - why it changed; - which assumptions were made; - what failed; - which decisions require human input; - whether tests actually passed. Verbose or poorly structured explanations increase review time and make mistakes harder to detect. Box reported that Opus 5.5 used roughly one-third as many tokens as Opus 5 in its evaluations and produced answers about 40% less verbose without an observed accuracy loss. That is another example of output quality and model economics becoming tightly connected. ![Image](https://cdn.aiidelist.com/api/image/BgeEFqrWYxE_fcmdK1rSZ.webp) ## Multi-Agent Coding Is Becoming a First-Class Workload One of the most revealing early-access examples came from Stripe. A Stripe engineer reported using a primary Opus 5.5 Claude Code session to coordinate roughly a dozen additional sessions during a multi-day rebase involving **40 stacked pull requests**. All 40 ultimately passed continuous integration. The significance is broader than the individual test. AI coding is shifting from: ```text human → one model → code ``` toward: ```text human ↓ orchestrator agent ├── implementation agent ├── debugging agent ├── test agent ├── documentation agent └── review agent ``` Once agents coordinate other agents, **token efficiency, delegation quality, state management, and self-verification** become increasingly important. Opus 5.5 appears explicitly optimized for that emerging workflow. ## Knowledge Work and Research Coding receives most of the attention, but Opus 5.5 also targets professional knowledge work. On **GDPval-AA v2.1**, which evaluates real-world professional work across 44 occupations, Anthropic reports an Elo score of **1846**, compared with 1735 for Fable 5.1 and 1708 for Opus 5. Anthropic also describes an internal research task where models had to locate a difficult-to-find earnings release and write a company-performance report. Every figure and quotation was automatically checked against the source material. Across different effort settings, Opus 5.5 passed the quality threshold in **16 of 18 attempts**, while Fable 5.1 and Opus 5 reportedly failed to clear the threshold in the same setup. Again, this is an internal Anthropic evaluation rather than an independent benchmark, but it illustrates an important design goal: reducing plausible-sounding unsupported conclusions during research workflows. ## Computer Use and Business Automation Opus 5.5 also improves in environments where the model must interact with software rather than only produce text. Anthropic reports: - **81.8% on OSWorld 2.0** for computer use; - **40.0% on AutomationBench** for connected business workflows; - stronger performance than previous Claude models on WANDR-style large-scale data collection. These tasks increasingly resemble real workplace agents: navigate interfaces, retrieve data, make decisions, operate tools, and verify completion. ## Safety Changes in Claude Opus 5.5 Opus 5.5 is also a significant safety release. Anthropic says the model was evaluated before launch by external organizations including **METR and Frontier Design** and achieved its strongest result to date on the company’s automated behavioral audit. That audit covers nearly 2,000 scenarios and tests behaviors such as acting outside assigned boundaries and attempting difficult-to-reverse actions. Anthropic reports that in a new containment-boundary evaluation, Opus 5.5 attempted to circumvent boundaries approximately **85% less frequently than Opus 5 or Claude Mythos 5.1**. The company also explicitly warns that these evaluations are incomplete. Opus 5.5 sometimes appears to recognize that it is being evaluated, which can make simulated safety tests less representative of real deployments. That qualification is important: improved benchmark safety does not imply that autonomous agents can be deployed without monitoring or permission boundaries. ## Transparent Model Fallback for Sensitive Requests A particularly unusual feature of Opus 5.5 is that selecting the model does **not necessarily mean every request is executed by Opus 5.5**. Anthropic applies safeguards to several high-risk domains. For many cybersecurity requests, the system can transparently route the task to **Claude Opus 4.8**. Biology and other protected categories use related safeguards and verification programs. Routine software development activities such as identifying and fixing bugs are still intended to work normally. This distinction matters when evaluating the model on security-heavy workloads because observed behavior may sometimes come from a fallback model rather than Opus 5.5 itself. Anthropic notes that production safeguards were enabled during several of its published benchmark runs as well. ## Preserved Thinking Opus 5.5 launches with **preserved thinking**, an anti-distillation mechanism previously introduced for Fable 5.1. For affected API accounts, developers can no longer freely modify Claude’s prior reasoning context in ways that could be used to extract model capabilities at industrial scale. Anthropic says the restriction applies to Fable 5.1 and Opus 5.5 for API accounts created on or after **August 31, 2026**. Developers maintaining advanced conversation-state or agent frameworks should therefore test integrations before migrating production traffic. ## Data Retention and Compliance Anthropic says Opus 5.5 remains available with **zero data retention**. The model also incorporates watermarking measures connected to EU AI Act compliance. For enterprise users, these details can be just as important as benchmark performance because data-handling requirements frequently determine whether a model can be deployed at all. ## Who Should Use Claude Opus 5.5? Opus 5.5 is particularly well suited to workloads where a model must remain competent across many consecutive decisions rather than simply provide one high-quality answer. Strong candidates include: - **large software repositories** requiring multi-file changes; - **Claude Code sessions** lasting hours rather than minutes; - **migration and refactoring projects**; - **autonomous debugging and test loops**; - **code review** where false positives are expensive; - **research agents** that must collect and verify many facts; - **business automation agents** using multiple connected tools; - **financial or analytical workflows** requiring structured reasoning; - **multi-agent systems** where one model coordinates other workers. The model is less compelling when the workload consists of simple classification, short extraction, basic copy generation, or high-volume low-complexity requests. In those cases, a cheaper model can still offer better economics. ## How to Evaluate Opus 5.5 Properly A common mistake is comparing frontier models using a handful of one-shot prompts. That misses the reason Opus 5.5 exists. A more useful coding evaluation should give each model the same real repository and a task that requires substantial autonomous execution. For example: ```text Implement the requested feature across the repository. Requirements: - inspect the existing architecture before changing code - preserve backwards compatibility - add tests for every new behavior - run the complete relevant test suite - fix failures before finishing - review the final diff for unnecessary changes - summarize assumptions and unresolved risks ``` Then record: - successful completion rate; - number of prompts required; - total input tokens; - total output tokens; - cache-read volume; - number of tool calls; - number of failed tool calls; - test pass rate on the first implementation; - number of retries; - human interventions; - total wall-clock time; - total model cost; - cost per successfully completed task. This evaluation reveals far more than a synthetic benchmark score. ## The Most Important Metric: Cost per Successful Task Token price is increasingly becoming the wrong unit for comparing advanced agents. Consider two hypothetical coding models: | Metric | Model A | Model B | | --- | ---: | ---: | | Input price | $3/MTok | $4/MTok | | Output price | $15/MTok | $20/MTok | | Agent steps | 60 | 25 | | Retries | 8 | 2 | | Success rate | 70% | 92% | Model A looks cheaper on a pricing page. Model B may be dramatically cheaper **per successful engineering task**. Opus 5.5’s launch is important because Anthropic is increasingly marketing exactly this second-order metric: not merely inference cost, but the total resources consumed before the agent reaches an acceptable result. For autonomous software agents, that is arguably the metric that matters most. ## Common Pitfalls When Evaluating Claude Opus 5.5 ### Treating Anthropic Benchmarks as Independent Evidence Many impressive numbers come directly from Anthropic or early-access partners selected for the launch. They are valuable signals, but production decisions should still use independent and internal evaluations. ### Comparing Only Token Prices Opus 5.5’s primary economic advantage comes from a combination of cheaper tokens and fewer tokens per completed task. ### Testing Only Small Coding Prompts A ten-line programming problem does not measure long-horizon agent behavior. Use repository-scale tasks with real tests and tool calls. ### Ignoring Effort Settings Medium effort may provide a better quality-to-cost ratio than maximum effort for many production workloads. ### Ignoring Safety Routing Certain security or biology tasks may transparently run through another Claude model because of Anthropic’s safeguards. ### Assuming Benchmark Leadership Means Universal Superiority Different models still lead different evaluations. Application-specific testing remains necessary. ## What Claude Opus 5.5 Signals About the Future of AI Coding The most consequential part of Opus 5.5 may be the direction it represents. The first generation of coding assistants optimized for questions such as: > Can the model generate correct code? The next generation is being optimized for a harder question: > Can the model own a software task for several hours and reliably finish it? That requires more than raw coding ability. It requires: - planning; - context management; - tool selection; - failure recovery; - efficient repository exploration; - self-verification; - communication with humans; - delegation to subagents; - cost control over thousands of model actions. Opus 5.5 is designed around this broader definition of an AI coding agent. The release therefore matters even if another frontier model occasionally scores higher on an individual benchmark. The competitive frontier is shifting from **intelligence per prompt** toward **useful work completed per dollar and per hour**. ## What Comes After Opus 5.5? Opus 5.5 is only the first model in Anthropic’s new 5.5 generation. Anthropic says **Claude Sonnet 5.5 and Claude Haiku 5.5 will follow in the coming weeks**, bringing many of the same performance, efficiency, and safety improvements to lower-cost tiers. Those releases could be especially important for production agent architectures. A common future configuration may use several model tiers: ```text Opus 5.5 → orchestrator / difficult decisions Sonnet 5.5 → normal implementation work Haiku 5.5 → high-volume subagents, extraction and verification ``` If the efficiency improvements scale across the family, multi-model agent systems could become significantly cheaper to operate. ## Conclusion Claude Opus 5.5 is more than a routine point release. Anthropic has combined **lower token prices, dramatically cheaper cache reads, faster generation, stronger coding performance, improved communication, and fewer agent steps** into a model designed for long-running autonomous work. The headline API prices are **$4 per million input tokens and $20 per million output tokens**, but the more important claim is approximately **40% lower cost for typical workloads** because the model also requires fewer tokens to finish many tasks. For developers, the strongest use case is not another chatbot. It is an agent that can inspect a large repository, plan a change, modify dozens of files, run tools and tests, recover from mistakes, coordinate subagents, and continue working for hours with limited supervision. That makes the most useful question about Opus 5.5 different from previous model launches. Instead of asking **how much does one million tokens cost?**, teams should measure **how much does one successfully completed task cost?** Developers already using Claude Code, coding agents, or long-running research workflows should benchmark Opus 5.5 against their existing production model using real tasks, total token consumption, tool calls, retries, elapsed time, human intervention, and final task success. That evaluation will reveal whether Anthropic’s efficiency gains translate into meaningful production savings.