Claude Opus 5 vs Fable 5: Test before you pay double
Choosing Claude Opus 5 vs Fable 5? Compare API cost, long-agent performance, fallbacks, Copilot access, and cost per accepted task.
Anthropic released Claude Opus 5 on July 24, 2026, with an unusually clear buying argument. It delivers performance close to Claude Fable 5 on demanding coding and professional work while charging half as much per input and output token.
That pricing gap makes Opus 5 the model most Claude users should test first. Fable 5 can still make financial sense for unusually long autonomous projects, especially when it prevents failed runs or hours of human intervention. The premium has to prove itself on the workload, though. A higher benchmark score does not pay the bill. Fewer retries, cleaner patches, better tool choices, and less review time might.
The practical decision is therefore less about choosing the model with the highest position in Anthropic’s lineup and more about measuring total cost per accepted result. For many teams, Opus 5 will be the economical default. Fable 5 should be a deliberate promotion for tasks that repeatedly exceed Opus 5’s reliable operating range.
Claude Opus 5 vs Fable 5: quick verdict and key takeaways
Start with Claude Opus 5 for most professional and coding work. Standard API pricing is $5 per million input tokens and $25 per million output tokens, exactly half Fable 5’s $10 and $50 rates.
Anthropic’s benchmark case for Opus 5 is strongest on value. At maximum effort, the company says Opus 5 comes within 0.5 percent of Fable 5 on CursorBench while costing half as much per task.
Use Fable 5 for proven long-horizon work. It is designed for ambitious, asynchronous projects that can run for many hours or days with less supervision.
Treat safeguard fallbacks as part of the product. A session requested on Fable can be routed to an Opus model, so teams need to record which model actually executed the work.
Do not confuse Opus 5 Fast mode with a discount. Fast mode doubles Opus pricing, which gives it the same raw input and output token rates as standard Fable 5.
Measure cost per accepted result. Include retries, tool calls, failed patches, interrupted agents, human review, repair time, and any operational delay.
Use Opus 5 for ordinary professional work, most coding and debugging, repository changes that take minutes or hours, computer-use agents, document analysis, research, cost-sensitive API workloads, and initial testing in Claude Code or GitHub Copilot.
Pay for Fable 5 when a task runs autonomously for many hours or days, Opus repeatedly loses the plan or stops before completion, Fable requires materially fewer retries, or the cost of human intervention dwarfs the token bill.
Bottom line: Start with Opus 5. Promote individual workloads to Fable only after a controlled comparison shows that Fable saves more money or human time than its higher token price consumes.
That conclusion broadly matches Anthropic’s own public guidance. A company representative told Reuters that users should choose Opus 5 for value and Fable 5 for days-long, highly autonomous projects.
What Anthropic released
Claude Opus 5 became available on July 24, 2026. It is a closed, hosted model available through Claude, Claude Code, Anthropic’s API, Amazon Bedrock, Google Cloud, Microsoft Foundry, and supported third-party products. Anthropic positioned it as the everyday high-end choice for coding, knowledge work, and enterprise tasks.
Both Opus 5 and Fable 5 support a 1 million-token context window, up to 128,000 output tokens, text and image input, adaptive thinking, tool use, and access through major cloud platforms. Those shared specifications make the comparison look simple at first. They also explain why buyers should focus on operating behavior rather than feature checkboxes.
The important differences are positioning, comparative latency, safeguards, retention requirements, and price. Anthropic’s current model documentation recommends Opus 5 as the starting point for complex agentic coding and enterprise work. It describes Fable 5 as the more capable widely released model for workloads that need the highest available capability. Fable is listed as slower, while Opus has moderate comparative latency and an optional Fast mode.
Those descriptions matter, but they remain product positioning. A team still needs to determine whether its own tasks resemble the work where Fable’s extra capability pays off. Many difficult prompts are short-lived, tightly scoped, and easy to inspect. They can demand high intelligence without requiring a model designed to maintain a plan for days.
Opus 5 costs exactly half as much as Fable 5
Anthropic’s API pricing is straightforward. Claude Opus 5 costs $5 per million input tokens, $0.50 per million cached input tokens, and $25 per million output tokens. Claude Fable 5 costs $10 per million input tokens, $1 per million cached input tokens, and $50 per million output tokens.
A run using 200,000 uncached input tokens and producing 20,000 output tokens would cost approximately $1.50 on Opus 5 and $3 on Fable 5. Opus 5 Fast mode would also cost approximately $3 because it doubles the standard Opus rates.
That clean two-to-one difference does not mean Opus will always cost half as much to finish a project. It means an equivalent token trace costs half as much. Real agent runs rarely produce equivalent traces.
A weaker model can consume more tokens, make more tool calls, require another attempt, or leave a human with an hour of cleanup. A stronger model can finish in fewer steps and produce a result that is easier to accept. The opposite can also happen. A premium model can overthink a simple task, generate expensive output, and deliver no meaningful improvement.
The useful metric is:
Completed-task cost = model charges + tool and infrastructure charges + failed attempts + human review and repair time
For an API team, model charges are only one line in that equation. Tool execution can consume paid browser sessions, cloud resources, database calls, CI minutes, and third-party API credits. A coding agent that creates a plausible but incorrect patch can also shift the largest cost to an engineer who must diagnose and repair it.
This is why a nominally expensive model can be cheaper for one workload and wasteful for another. The right comparison is not cost per invocation. It is cost per accepted task under a consistent definition of acceptance.
Anthropic’s benchmarks favor Opus 5 on value
Anthropic reports several strong results for Opus 5. On Frontier-Bench v0.1, the company says Opus 5 more than doubles Opus 4.8’s performance while lowering cost per task. On CursorBench 3.2 at maximum effort, Opus 5 reportedly performs within 0.5 percent of Fable 5’s peak score at half the cost per task.
The company also says Opus 5 exceeds Fable 5’s best OSWorld 2.0 result at a little more than one-third of the cost. On Zapier AutomationBench, Anthropic reports a pass rate around 1.5 times the next-best model at the same task cost. It also says the model is better at checking its work, building test harnesses, finding root causes, and continuing until a result succeeds.
Those results create a persuasive case for testing Opus first. They do not establish that every company will see the same advantage. Benchmark tasks, harnesses, effort settings, time limits, retry policies, tool access, and scoring rules can all shape the result.
The launch data is largely vendor-run or supplied by early-access customers. Anthropic also notes that its Frontier-Bench results used five attempts per task and allowed Opus 4.8 to serve as a fallback when Opus 5 or Fable 5 triggered safety classifiers.
That footnote changes how the headline numbers should be read. A benchmark row labeled Opus 5 or Fable 5 can partly measure the fallback model and the product routing around it. The result can still be useful, but it represents a deployed system rather than a pure model checkpoint.
The careful interpretation is that Anthropic has produced strong evidence that Opus 5 deserves testing. Independent, task-level evidence should determine whether a production workload deserves Fable.
Fable’s advantage begins where ordinary comparisons stop
Fable 5 is designed for ambitious, long-running, asynchronous work. Anthropic says it can operate for days in an agent harness, plan across stages, delegate work to subagents, check its own output, and sustain complex projects with less supervision.
That is a different promise from answering one difficult prompt correctly. A model can produce an excellent response in ten minutes and still struggle to maintain scope across a two-day migration. Long-horizon work creates failure modes that ordinary prompt comparisons barely capture.
A multi-day migration can fail because the agent forgets an early requirement, silently changes scope, stops after producing a plan, modifies the wrong files, or neglects the relevant tests. It can repeatedly choose an unsuitable tool, generate a superficially plausible patch that misses the root cause, or get stuck while continuing to consume tokens.
An agent can also finish the implementation but leave behind a large review burden. The code may work on the happy path while introducing unnecessary changes, missing compatibility requirements, or creating a diff that is difficult to understand.
Fable is worth its premium when it reduces these failures enough to change the economics of the project. Suppose Opus completes a task after two attempts while Fable completes it in one attempt using a similar number of tokens per attempt. The raw model charges would be roughly equal.
Fable becomes the cheaper option when it also reduces tool charges, wall time, engineer intervention, or post-run repair. Fable remains the more expensive option when both models finish successfully and the only meaningful difference is a slightly more polished explanation.
This distinction is important for buyers. A model designed for days-long autonomy should be evaluated on days-long autonomy. Testing it only on brief coding prompts can hide the capability that might justify its price. It can also encourage buyers to pay a premium for tasks where the premium has no economic role.
Independent agent testing exposes the fallback problem
The RuBench repository-level coding benchmark provides a useful warning about evaluating Fable. Researchers ran Claude Code with Fable 5 on 25 repository tasks. On five tasks, the product’s safeguard system switched execution to Opus 4.8. The affected work included routine HTTP protocol and cache-handling fixes.
After excluding the substituted runs, Fable resolved 17 of 20 measured tasks in a single run. On the same 20-task subset, the three-run means for Opus 4.8 and Sonnet 5 were both 86.7 percent. The sample was too small to establish a statistically meaningful advantage between the stronger models.
This was not an Opus 5 versus Fable 5 head-to-head because Opus 5 had not been released when the benchmark was conducted. It still establishes two valuable evaluation rules.
First, measure the deployed product rather than relying on the model name selected in a menu. Second, record which model actually executed each step.
Popular AI previously covered the same comparability problem in our analysis of Kimi K3 benchmark and fallback claims. A benchmark becomes difficult to interpret when the system can substitute another model during the run, especially when the substitution happens after the agent has already started planning or reading files.
The implication extends beyond Fable. Any agent platform with server-side routing, automatic fallbacks, hidden model mixtures, or safety-driven substitutions should expose requested-model and executing-model data in its logs. Without that information, teams can compare product labels while measuring different underlying systems.
More on how to assess AI benchmark claims:
Fable’s safeguards are part of its effective cost
Fable 5 uses stronger safeguards around cybersecurity, biology, chemistry, and some frontier model-development work. Anthropic says flagged prompts may automatically route to an Opus model.
Automatic model switching is enabled by default when a user first selects Fable 5, although users can disable it. When switching is disabled, a flagged request pauses rather than being rerun on another model.
Billing depends on when the switch happens. When a request is blocked before Fable produces output, the response is charged at Opus rates. When a block occurs during generation, the input and initial streamed tokens are charged at Fable rates, while the remainder is charged at Opus rates.
Anthropic says Opus 5’s classifiers should intervene around 85 percent less often than Fable’s. Flagged Opus 5 requests can still fall back to Opus 4.8 in Claude, Claude Code, and Claude Cowork. The difference is therefore one of frequency and scope rather than a guarantee that Opus will never switch.
This creates a practical reason to prefer Opus 5 for security-adjacent software work. Fable may be more capable in principle while being less dependable as the executing model for the task. A team working on HTTP behavior, authentication, vulnerability analysis, or low-level infrastructure could encounter fallbacks on benign work.
Teams evaluating either model should log the requested model, executing model, fallback events, the point in the trajectory where a fallback occurred, tokens charged before and after the switch, and whether the substitution changed the result.
Without those records, a successful Fable run may partly be an Opus run. An unsuccessful run may reflect product policy rather than the underlying model’s capability. Both cases matter because buyers pay for the product that actually operates, not an abstract model separated from routing and safeguards.
The data-retention difference can decide the purchase
Using Fable carries a special 30-day retention requirement for safety monitoring. GitHub says prompts and outputs sent to Fable through Copilot may be retained by Anthropic for up to 30 days, after which Anthropic deletes them. GitHub says the retained data is not used to train Anthropic’s models.
Anthropic says Opus 5 does not have Fable’s additional retention requirement for general access. That difference can settle the comparison before performance testing begins.
A company with contractual, legal, regulatory, or internal requirements for zero data retention may be unable to use Fable for sensitive code, customer records, research material, or proprietary documents. The stronger model becomes irrelevant when its data terms disqualify the workflow.
Teams should also avoid treating retention as a small footnote after technical evaluation. Data handling belongs in the entry criteria. Before running a benchmark on real company material, confirm whether the selected product surface, account type, cloud partner, and organization policy meet the required retention terms.
A workload that cannot legally or contractually be sent to Fable should stay on Opus or another approved model, regardless of benchmark performance.
Opus 5 Fast mode costs as much as Fable
Anthropic says Opus 5 Fast mode produces output at around 2.5 times the standard speed. The price also doubles to $10 per million input tokens and $50 per million output tokens. That is the same raw token price as standard Fable 5.
Fast mode therefore creates a separate buying decision. Choose standard Opus 5 for value. Choose Fast Opus 5 when response latency has measurable operational value. Choose Fable 5 when additional autonomy or difficult-task reliability has measurable value.
Fast mode should not be enabled globally merely because it feels better. A faster wrong patch still needs review. A fast model can make a budget disappear more pleasantly without improving the accepted result.
Reserve it for interactive coding, time-sensitive agents, customer-facing workflows, incident response, or pipelines where waiting creates a real bottleneck. For batch work, background analysis, and tasks where a human will not inspect the result immediately, standard speed may be the better trade.
The cleanest way to evaluate Fast mode is to assign a value to latency. Measure how much shorter response time reduces labor, queueing, abandonment, or downstream delay. If the speed has no measurable value, paying Fable-level rates for it is difficult to defend.
Claude subscriptions make Opus the default
Anthropic’s consumer pricing page lists Claude Pro at $20 per month, or $17 per month with annual billing. Max starts at $100 per month. Opus 5 is the strongest model included on Pro and the default model on Max.
Fable access works differently. On Pro, Fable uses separately purchased usage credits. On Max, Fable can use up to 50 percent of the weekly plan limit. Further use can move to usage-credit billing at standard API rates.
That makes upgrading to Max solely for Fable difficult to justify without a sustained workload. Max can still make sense for higher overall usage, priority access, and larger output limits. Fable alone should earn the jump through real completed work.
Anthropic recommends a cheaper mixed-model approach inside Claude Code. Its guidance says teams can use Opus for planning and Sonnet for more mechanical execution. The reasoning-heavy plan receives the premium model, while lower-cost execution follows the approved structure.
Opus 5 can fill the same middle position between Sonnet’s lower cost and Fable’s specialized premium. A team might use Opus 5 for difficult planning, debugging, and cross-cutting changes, then reserve Fable for the subset of projects where maintaining a long autonomous trajectory is the main challenge.
Subscription buyers should still watch usage rather than assuming the monthly fee makes marginal cost irrelevant. Fable usage credits, weekly limits, and model routing can change the practical cost of a workflow even when the account begins with a flat subscription.
GitHub Copilot provides an immediate test path
Claude Opus 5 became available in GitHub Copilot on July 24 for Pro+, Max, Business, and Enterprise users. GitHub lists support across Visual Studio Code, Visual Studio, Copilot CLI, the Copilot cloud agent, the Copilot app, GitHub.com, JetBrains, Xcode, Eclipse, and mobile apps. Business and Enterprise administrators must enable the model policy.
Fable 5 is available to the same broad Copilot plan groups. GitHub bills both at provider list rates under its usage-based system. One GitHub AI credit equals $0.01, and token use is converted into credits according to the selected model’s input, cached-input, and output rates.
GitHub’s supported-model documentation says Opus 5 and Fable 5 support a 1 million-token context option and configurable reasoning in supported Copilot clients. Larger context windows and higher reasoning settings consume more credits, so GitHub recommends using ordinary context and reasoning by default, then enabling extended settings for tasks that need them.
For existing Copilot customers, this creates a low-friction evaluation path. Select ten difficult tasks from recent completed work. Recreate each task from the same repository state. Give Opus and Fable the same instructions, tools, permissions, context size, and reasoning level.
Record the requested model, executing model, total credits, wall time, tool calls, test results, review time, and whether the result was accepted. Repeat each task enough times to expose run-to-run variance.
The resulting data will tell you more about your buying decision than a general leaderboard. Copilot also lets a team test the models inside a familiar workflow rather than building a custom API harness before learning whether the comparison matters.
How to test whether Fable is worth paying for
A useful comparison needs more than a few prompts that feel better. It needs representative tasks, controlled conditions, full cost accounting, and a promotion rule established before the results arrive.
▪ Choose representative tasks
Use work that resembles what you actually pay people or agents to complete. Good candidates include a multi-file bug fix, a dependency migration, a feature that requires tests, a repository-wide refactor, a research report using several sources, a spreadsheet or document workflow, a browser task, and a long-running agent project with checkpoints.
Include tasks with different failure costs. A typo fix and a production migration should not carry the same acceptance threshold. The comparison should reflect the consequences of a wrong answer, not merely whether the model generated something plausible.
Avoid selecting only tasks that favor one model’s public reputation. A fair test should include ordinary work, difficult bounded work, and genuinely long-horizon work. That distribution will show where the premium begins to matter.
▪ Freeze the environment
Both models should receive the same repository snapshot, prompt, files, tools, permissions, time limit, context limit, and reasoning or effort setting where comparable.
A test becomes difficult to interpret when Fable receives more context, more attempts, broader permissions, or a longer time budget. Those changes may be reasonable in production, but they should be evaluated as separate configurations.
Store the starting state so every run can be reproduced. For coding tasks, pin dependencies where possible and use the same test commands. For research or browser tasks, record the date because live web content can change between runs.
▪ Record the full cost
For every run, track input tokens, cached tokens, output and thinking tokens, number of attempts, tool calls, tool failures, wall-clock duration, agent interruptions, safeguard fallbacks, files changed, tests passed, human review minutes, human repair minutes, and whether the result was accepted, revised, or discarded.
The final comparison should use cost per accepted task. A cheap invocation that fails three times is not cheap. A premium invocation that produces a mergeable result can be economical when it eliminates retries and repair.
Separate model charges from infrastructure and labor. That makes it possible to see which part of the workflow changed. Fable may cost more in tokens while saving enough engineer time to win. It may also cost more everywhere.
▪ Count human verification as a first-class metric
A model that finishes in one run can still be expensive when its work takes an hour to verify. Measure the time needed to understand the diff, the number of unsupported claims, unnecessary changes, missed requirements, tests the model failed to run, regressions found during review, follow-up questions, and time required to make the result publishable or mergeable.
The growth of agent-generated code has already made review capacity a major constraint. Popular AI’s coverage of AI-generated pull requests and maintainer workload explains why producing more code does not automatically produce more useful work. Review remains expensive because responsibility remains human.
A team should define what good review looks like before measuring it. One reviewer may accept a patch after reading the diff, while another may rerun tests, inspect dependencies, and reproduce the original bug. Use the same review protocol for both models.
More on AI-assisted coding:
▪ Set a promotion rule before testing
Decide what Fable must achieve before it becomes the default for a workload. A team might require it to reduce failed tasks by 30 percent, cut human review time by 25 percent, complete a class of projects Opus cannot finish, reduce attempts enough to offset the two-times token rate, shorten total project duration, produce fewer high-severity defects, or require fewer interventions during long runs.
The exact threshold depends on the organization. A regulated company may value fewer unsupported claims more than lower token spend. A small development team may value uninterrupted agent runs because engineers cannot supervise every step.
Setting the rule first reduces the temptation to rationalize an expensive model after seeing a few impressive outputs. The promotion decision should follow the precommitted metric, with exceptions documented rather than improvised.
Who should use Opus 5
Opus 5 is the better default for individual developers, Claude Pro subscribers, most Claude Max users, API teams watching inference spend, coding-agent developers, professional document and research workflows, computer-use agents, and organizations that have not yet built task-level model evaluations.
It is also a strong choice for security-adjacent coding that frequently triggers Fable safeguards, teams that need to avoid Fable’s special retention requirement, and workloads where tasks are difficult but usually complete within minutes or hours.
Opus 5 can serve as the planner in a mixed-model system, with Sonnet or a cheaper model handling mechanical execution. It can also be the baseline against which every Fable promotion is measured.
The central advantage is optionality. Starting with Opus does not prevent a team from escalating a task. It simply avoids paying the premium before the workload has shown why it needs one.
Who should pay for Fable 5
Fable deserves serious testing for multi-day autonomous coding projects, large migrations across complex repositories, research agents that must maintain a plan over long periods, and expensive professional workflows where one missed detail creates substantial rework.
It may also make sense for teams whose engineers spend more on intervention than the models consume in tokens, projects where Fable demonstrates materially fewer retries or tool mistakes, and organizations equipped to audit model routing, retention, and full agent trajectories.
The key word is demonstrates. A workload should move to Fable because repeated controlled runs show a measurable benefit. The model’s place in Anthropic’s lineup is not sufficient evidence.
Fable should remain an exception attached to a proven workload rather than an organization-wide default. Over time, the exception can expand if the data supports it.
Can Opus 5 or Fable 5 run locally?
No. Neither model has downloadable weights. They remain hosted services controlled by Anthropic and its cloud or product partners.
Access depends on an account, pricing, availability, usage policies, data terms, and the provider’s routing decisions. Even when a local application or terminal agent sends the request, the model itself runs on hosted infrastructure.
Developers who need a fallback can connect Claude to a broader tool stack, preserve portable prompts and tests, and keep at least one open or self-hosted coding model available. Popular AI’s guide to building a more independent AI development stack covers provider routing, local models, and workflows designed to reduce lock-in.
A local alternative may be weaker or harder to maintain. It can still provide continuity when a hosted model becomes unavailable, changes its terms, triggers an unexpected safeguard, or becomes too expensive for routine work.
The goal is not to pretend a local model is identical to Opus or Fable. It is to avoid making one hosted service the single point of failure for prompts, tests, workflows, and institutional knowledge.
More on AI coding agent lock-in:
FAQ
Is Claude Opus 5 half the price of Fable 5?
Yes. Standard API pricing is $5 per million input tokens and $25 per million output tokens for Opus 5. Fable 5 costs $10 per million input tokens and $50 per million output tokens.
Is Fable 5 better than Opus 5 for coding?
Fable is positioned as the stronger model for unusually ambitious, long-running coding projects. Anthropic reports that Opus 5 comes within 0.5 percent of Fable’s peak CursorBench score at half the task cost. Most coding workloads should start with Opus and move to Fable only after controlled testing.
Is Claude Opus 5 available in GitHub Copilot?
Yes. It began rolling out on July 24, 2026, for Copilot Pro+, Max, Business, and Enterprise users. Availability depends on the client, plan, rollout status, and organization model policy.
Does Claude Opus 5 Fast mode save money?
No. Fast mode runs around 2.5 times faster according to Anthropic, but it costs twice the standard Opus rate. Its raw input and output pricing is the same as standard Fable 5.
Is Fable 5 included with Claude Pro?
Claude’s pricing page lists Fable as available through usage credits on Pro. Max subscribers can use Fable for up to 50 percent of their weekly plan limits, with additional use potentially moving to credit-based billing.
Does Fable 5 retain prompts and outputs?
Fable carries a 30-day retention requirement for safety monitoring. Anthropic and GitHub say retained data is deleted after that period and is not used for model training.
Can Fable switch to another model during a task?
Yes. Its safeguard system can automatically route flagged requests to an Opus model. Automatic switching can be disabled, but a flagged request will then pause instead of continuing on Fable.
How can I tell whether Fable is worth the extra cost?
Compare cost per accepted task. Include retries, tool calls, fallback events, wall time, tests, review time, repair work, and the model that actually executed each step. Fable is worth paying for when the complete result is cheaper or materially better after accounting for its higher token rate.
Claude Opus 5 is the default until Fable proves the premium
Claude Opus 5 is the Anthropic model most users should pay for first. It offers the same context capacity as Fable, broad tool and cloud access, lower comparative latency, fewer safeguard interventions, no special Fable-style 30-day retention requirement for general access, and a raw API price exactly 50 percent lower.
Fable 5 remains the model for the hardest long-running projects. That description should be treated as a qualification requirement rather than a status symbol.
Do not upgrade because Fable is the top model in Anthropic’s menu. Upgrade a particular workload because your own runs show that Fable completes more tasks, makes fewer damaging mistakes, maintains plans longer, or saves enough human time to overcome the premium.
The burden of proof belongs to the model that costs twice as much. Start with Opus 5, measure complete task economics, and let Fable earn each workload.
Explore more from Popular AI:
Start here | Local AI | Fixes & guides | Builds & gear | Popular AI podcast