Claude Opus 5 is Anthropic’s newest bid to make frontier-grade AI agents practical at everyday API prices. This Claude Opus 5 review looks beyond launch benchmarks to answer the more useful question for builders: where does the model genuinely save time, and where should you route work to another model?

Anthropic positions Opus 5 as a substantial step up from Opus 4.8 for deep reasoning, agentic coding, long-horizon execution, and professional knowledge work. It launches at the same base API rate as Opus 4.8—$5 per million input tokens and $25 per million output tokens—while sitting at half the listed price of Claude Fable 5. That makes it less of a conventional flagship replacement story and more of a capability-per-dollar story.

The supplied video review adds an important counterweight. On its custom KingBench suite, Opus 5 was exceptional when a task demanded planning, logic, code execution, self-checking, and persistence. Yet it was less convincing on the visual and 3D tasks that require a refined final product, nuanced motion, or strong aesthetic judgment. That split is the real takeaway: Opus 5 may be an outstanding worker model without being the universal best model for every creative or conversational task.

What Claude Opus 5 is—and why the positioning matters

Anthropic released Claude Opus 5 on July 24, 2026, presenting it as an Opus-tier model designed for serious coding, AI agents, enterprise workflows, and high-value knowledge work. The company says the model approaches the intelligence of its higher-priced Claude Fable 5 while delivering stronger results on selected coding and knowledge-work evaluations.

That description matters because it sets different expectations than the word “flagship” normally does. A universal flagship should be the obvious choice for nearly everything: writing, coding, image understanding, ideation, research, analysis, design, and chat. Opus 5 instead looks more specialized. Its core promise is that it can take more responsibility inside a workflow: inspect a repository, use tools, make a plan, complete multiple dependent steps, test the result, and continue until it reaches a usable outcome.

For developers, that is potentially more valuable than an incremental improvement in one-shot answers. A model that can reliably close the loop on a real task can reduce coordination overhead, repeated prompting, and the number of manual handoffs required from an engineer.

Anthropic’s own documentation emphasizes this agentic orientation. Opus 5 has a one-million-token context window, up to 128,000 output tokens, adaptive thinking enabled by default, and effort controls intended to let customers decide how much inference work is appropriate for each request. The company also added beta support for changing tools mid-conversation while preserving prompt cache behavior—an especially relevant feature for long-running systems that need to shift from research to coding to verification.

In practical terms, Opus 5 is aimed at workflows such as:

Diagnosing and fixing a difficult bug across a large codebase.
Building a feature from a product specification, including tests and documentation.
Running a multi-tool research or operations workflow with checkpoints.
Reviewing complex pull requests and tracing root causes rather than only spotting superficial issues.
Producing structured business analysis that involves tables, source material, and iterative validation.

That is a more ambitious job description than “answer questions well.” It also explains why an independent benchmark can find the model brilliant at autonomous implementation while less impressive at a polished 3D object or everyday conversation.

Claude Opus 5 pricing: the strongest part of the launch

The pricing is one of the clearest reasons to pay attention to Opus 5. Anthropic lists standard API pricing at $5 per million input tokens and $25 per million output tokens. That matches Opus 4.8, while Claude Fable 5 is listed at $10 per million input tokens and $50 per million output tokens.

On paper, this means Opus 5 offers a cheaper route to advanced agentic behavior without requiring teams to reserve their most expensive model for every difficult task. Pricing is especially important for agent workflows because agents naturally consume more tokens than chatbots. They inspect files, read tool output, formulate plans, retry failed steps, write tests, and verify work. Even a small token-efficiency difference can compound quickly at scale.

The output-token caveat

However, API list price is only one part of the cost calculation. The video reviewer’s practical complaint was that Opus 5 can be verbose, inclined to inspect more files than necessary, and prone to touching extra parts of a project. If that pattern holds in a specific workload, the lower per-token price may not automatically create a lower cost per completed task.

This is the distinction teams should measure:

Cost per token: What the provider charges for input and output.
Tokens per successful task: How much model activity is required to reach a correct, accepted result.
Cost per accepted outcome: The total spend after retries, human review, failures, regressions, and cleanup.

A model can be cheap per token but expensive in production if it over-explores, produces long reasoning traces, or expands a simple task into an unnecessary project. Conversely, a model with a higher token rate can be cheaper overall if it finishes the job correctly on the first attempt.

Caching and batch processing change the math

Anthropic says prompt caching can reduce eligible costs by up to 90%, while batch processing can reduce costs by 50%. The company also lowered Opus 5’s minimum cacheable prompt length to 512 tokens, compared with 1,024 tokens for Opus 4.8. That could make a meaningful difference for applications that repeatedly send shared instructions, repository context, policy documents, product catalogs, or standardized tools.

For a creator or startup, the sensible approach is not to make a model decision from a rate card alone. Build a small evaluation set of your real requests, record input tokens, output tokens, retries, acceptance rate, and human correction time, then compare the completed-task cost across models.

Claude Opus 5 review: what the KingBench results reveal

The original video source tested Opus 5 on a custom eight-task evaluation called KingBench. The tasks spanned front-end simulation, 3D modeling, SVG creation, game mechanics, mathematics, a long-horizon local fine-tuning workflow, and a difficult 3D watch build.

The reviewer awarded Opus 5 62 out of 80 points, or 77.5%. That placed it in a tie with Kimi K3 in the reviewer’s chart, below Qwen 3.8 Max, Claude Fable 5, and—most notably—Claude Opus 4.8, which reportedly scored 80% on the same suite.

A custom benchmark is not a substitute for a standardized, independently audited evaluation. Its scoring is shaped by the task design, judging criteria, test environment, model settings, and the reviewer’s own evaluation decisions. Still, it is valuable because it tests something launch charts often do not: whether a model creates an artifact a human can directly use.

The result was not simply “Opus 5 is worse.” It showed a sharper pattern.

Where Opus 5 excelled

Opus 5 received perfect scores on the elevator simulation, bow-and-arrow game, mathematics problem, and local fine-tuning workflow. These tasks share a common structure: each requires multi-step logic, maintaining constraints, implementing behavior, and checking whether the work functions.

The elevator simulation required people to queue, elevators to transport only one person at a time, and passengers left behind to catch a later elevator. According to the review, Opus 5 produced correct logic plus useful details such as live counters and hover tooltips. That is exactly the kind of task where software correctness and state management matter more than artistic taste.

The bow-and-arrow game also earned a reported 10 out of 10. A functioning game involves input handling, timing, interaction, physics-like behavior, success conditions, and a leaderboard. It is a compact example of agentic coding: many pieces must interoperate, and a visually attractive static interface is not enough.

The math task offers a simpler but important confirmation. Opus 5 reportedly got the target answer of 2460 on a difficult counting problem that many models fail. This supports Anthropic’s broader claim that the model’s improvements are concentrated in reasoning and novel problem-solving.

The standout local fine-tuning task

The most revealing KingBench result was the autonomous local workflow. The model was asked to generate panda facts, create a dataset, fine-tune a Gemma 2B model locally, and build a local web interface that served a new fact on refresh.

The reviewer described this as the strongest attempt they had seen on the task. Opus 5 reportedly created 134 facts across themed files, assembled a dataset pipeline, ran a QLoRA fine-tune using MLX on a Mac, built a local interface, wrote a detailed README, and added 99 tests with approximately 95% coverage.

Whether every implementation choice was necessary is open to debate. But this is precisely why the result matters. The model did not merely produce code snippets. It operated like an overachieving junior engineer with a mandate to deliver a running project and document its work.

For teams building agents, that behavior can be far more useful than a model that offers elegant advice but stops before executing the plan.

Why visual and 3D tasks appear to be the weakness

The KingBench review also found a meaningful gap in visual and 3D polish. Opus 5 performed well on a 3D contact-lens case, earning an 8 out of 10 in the reviewer’s scoring, but its results on a folding-table animation, an SVG panda, and a complex 3D wristwatch were weaker or stagnant.

The folding-table task was the clearest reported regression. Opus 5 earned a 5 out of 10, compared with Opus 4.8’s previously reported 8. The table existed and the interaction was present, but the folding movement was not seamless or mechanically convincing.

The panda SVG received a 6, matching previous Opus-family results but trailing models that the reviewer regarded as better at visual composition. The 3D watch earned a 3 despite a large amount of implementation effort: dual time zones, date and day controls, smooth-seconds options, a GMT hand, night mode, and a dedicated debugging page. The problem was not lack of features. The requested finished object never fully cohered into a convincing, functional 3D wristwatch.

Features are not the same as finish

This distinction is central for creators and product teams. A model can generate extensive functionality while missing the final 15% that makes an interface feel intentional. That last stage often depends on:

Spatial and mechanical intuition.
Visual hierarchy and proportion.
Animation timing and easing.
Consistent textures, materials, shadows, and typography.
Restraint: knowing which features to omit.
Iterative critique from the perspective of a user, not a checklist.

Agentic models are often rewarded for being thorough, persistent, and verifiable. Visual work often rewards taste, composition, and the ability to recognize when a technically valid output still feels wrong. Those are different optimization targets.

Anthropic’s launch materials say Opus 5 can generate stronger visual outputs, including interactive visual demonstrations. That may be true across the company’s internal examples and selected evaluations. But the KingBench result is a reminder that visual capability is not a single dimension. A model may make a working visualization, dashboard, or interactive physics demo while still struggling with product-grade 3D execution or refined creative illustration.

Official benchmarks are impressive—but interpret them correctly

Anthropic’s official claims are substantial. The company says Opus 5 leads on Frontier-Bench v0.1, performs within 0.5% of Fable 5’s peak score on CursorBench 3.2 at maximum effort for half the cost per task, and scores strongly across ARC-AGI 3, OSWorld 2.0, GDPval-AA, AutomationBench, DeepSearchQA, and other evaluations.

The reported Frontier-Bench result is especially striking. Anthropic says Opus 5 more than doubles Opus 4.8’s result while outperforming other models at a lower cost per task. On ARC-AGI 3, the company says Opus 5 achieved roughly three times the score of the next-best model. It also claims that Opus 5 is more cost-efficient than competing models on computer-use and business-automation tests.

These numbers are meaningful signals, especially when a vendor publishes methodology and identifies the benchmark conditions. But they should not be treated as a universal ranking.

Every benchmark rewards a different behavior

A coding benchmark may emphasize issue resolution, repository navigation, test completion, or patch acceptance. A computer-use benchmark may emphasize clicking, typing, and state tracking across software interfaces. An automation benchmark may reward successfully completing multi-step business tasks. A visual benchmark may emphasize layout, appearance, fidelity, or interactive polish.

A model can dominate one domain while producing mediocre outcomes in another. This is not necessarily a contradiction. It is a reminder that “best model” is an incomplete question.

The better questions are:

Best model for what task?
Under what effort setting?
At what latency and cost?
With which tools and prompt scaffold?
How often does a human need to intervene?
What failure modes are unacceptable for this workflow?

The KingBench review and Anthropic’s official benchmark story can both be true at once. Opus 5 may be a major advance for high-effort, long-horizon agentic work while showing uneven quality on visual tasks that require polish rather than operational completeness.

Effort settings are a routing tool, not a magic quality button

One of the most important Opus 5 additions is the effort control. Anthropic frames it as a way to balance intelligence, token use, latency, and cost. Higher effort lets the model devote more computation to difficult tasks, while lower effort is intended for routine work where the full reasoning budget is unnecessary.

This is useful, but it changes how teams should deploy the model. Rather than selecting a model once for an entire product, teams can make a routing decision per request.

A practical effort-setting framework

Use low or medium effort when the task is straightforward, bounded, and easy to validate. Examples include rewriting copy to a house style, extracting fields from clean documents, creating a simple SQL query, summarizing a meeting, or generating a predictable UI component.

Use high or maximum effort when a mistake is expensive or the problem requires searching through ambiguity. Examples include debugging a production incident, planning a migration, investigating a security-relevant code path, reconciling conflicting research sources, building a complex feature, or coordinating multiple tools.

A useful routing pattern looks like this:

Start low for classification, extraction, simple drafting, and cheap triage.
Escalate to medium for structured content, routine code edits, and moderate analysis.
Escalate to high for multi-file coding, difficult reasoning, or tasks with uncertain requirements.
Use maximum effort only when the expected value of a better result exceeds the added token cost and latency.
Require automated tests, schemas, validators, or human review at the end of high-impact workflows.

CodeRabbit’s early evaluation of Opus 5 supports this idea. Its reviewers found that effort acted as a routing decision rather than a setting that improved every metric at once. Higher effort could improve precision while reducing coverage, illustrating why teams should not assume that “maximum” is always the optimal production setting.

Fast mode solves a latency problem, not a capability problem

Anthropic also offers Fast mode for Opus 5 as a research preview. It uses the same underlying model behavior and capabilities but runs with an inference configuration designed to prioritize speed. The company says it can deliver up to 2.5 times higher output tokens per second.

The tradeoff is price. Fast mode is listed at $10 per million input tokens and $50 per million output tokens—double the standard Opus 5 rates. It is not a cheaper way to run the model; it is a premium latency option.

For an interactive coding loop, live debugging session, or collaborative session where users are staring at a cursor, faster output can be worth the premium. For background jobs, overnight research, batch content processing, or queued agent work, standard mode will usually make more economic sense.

There are also availability details that matter. Anthropic’s platform documentation says Fast mode is available as a research preview on the Claude API, including Claude Managed Agents, and is not available through Amazon Bedrock, Google Cloud, or Microsoft Foundry. In Claude Code, it can be toggled with /fast, but subscription users consume usage credits rather than included plan limits.

The practical lesson is simple: use Fast mode for human wait time, not for the illusion of a better answer. If the job is asynchronous, invest the savings in better evaluation, more reliable tool calls, or a second verification pass instead.

The verbosity problem: why agent success can still feel inefficient

The video reviewer’s biggest experiential criticism was not that Opus 5 could not solve hard tasks. It was that the model sometimes appeared overly ceremonial: listing directories, inspecting additional files, modifying more files than needed, and consuming tokens on actions that did not materially improve the result.

This behavior is understandable in context. A model trained to self-check, avoid hidden errors, and finish difficult tasks may develop a tendency to investigate broadly before acting. In a long-horizon coding environment, that caution can be productive. In a small, narrow task, it can feel wasteful and intrusive.

How to contain scope creep

Prompting alone will not fix every tendency, but teams can reduce unnecessary expansion by defining boundaries explicitly. Give the model a task contract that includes the permitted files, acceptance criteria, expected output, test command, and a rule against modifying unrelated code.

For example:

“Modify only src/auth.ts and its direct tests unless you first explain why another file is required.”
“Do not refactor unrelated modules.”
“Before changing files, return a five-bullet plan and wait for approval.”
“Use existing dependencies; do not add packages.”
“Stop after the test suite passes and summarize only changed files.”

This is not just prompt hygiene. It is a governance mechanism. The more autonomous a model becomes, the more important it is to specify what it must not do.

CodeRabbit’s testing similarly observed that Opus 5 can produce longer default output, follow instructions very literally, verify its work unprompted, and expand task scope. For code review and agent workflows, those qualities can either be strengths or liabilities depending on the harness around the model.

General chat and multimodal work may require a different model

The supplied review argues that Opus 5 feels weaker in day-to-day chat, broad knowledge discussions, and multimodal use than leading alternatives. That is a subjective finding, not a definitive public benchmark result, but it deserves attention because many people expect a premium AI model to excel everywhere.

A model optimized around agentic completion can feel different in conversation. It may offer more process than a user wants. It may be overly literal. It may prioritize task decomposition over a fluid, concise response. And if its strongest gains come from reasoning-time compute rather than broad conversational quality, a lighter or more generalist model may feel better for brainstorming, first drafts, lightweight customer support, or quick personal questions.

This suggests a portfolio approach rather than a winner-take-all strategy:

Use Opus 5 for deep coding, complex agents, tool use, difficult analysis, and high-value implementation.
Use a faster, cheaper model for classification, routing, structured extraction, and bulk generation.
Use the model that performs best in your own tests for design-heavy, image-aware, or highly visual tasks.
Keep a separate model option for general chat if concise, natural interaction matters more than autonomous execution.

The right architecture may involve several models. That is not a failure of any one model; it is a realistic response to specialization in the AI market.

Safety routing and fallback behavior deserve monitoring

The original review mentions reports that some requests triggering safety filters might be answered through an older or weaker model. The reviewer did not independently confirm that behavior, so it should not be treated as a settled claim.

What is confirmed is that Anthropic documents fallback capabilities for Opus 5. Its platform documentation describes a beta “default” fallback mode that applies Anthropic’s recommended fallback models by refusal category. Anthropic’s materials around its higher-capability Mythos and Fable models also explain that some cybersecurity and biology requests can be automatically routed to Opus models because of added safeguards.

For builders, the lesson is not to speculate about hidden model switching. It is to make model identity and fallback behavior observable in your application.

Track the requested model, returned model identifier where available, refusal category, fallback event, token usage, latency, tool-call pattern, and task result. If a workflow has strict quality, compliance, or reproducibility requirements, test it with the categories most likely to trigger safety controls before launch.

A fallback can be a reasonable safety feature. But if users expect one capability level and silently receive another, it can affect reliability, cost estimates, and evaluation results. Transparency in logs and user-facing handling is therefore essential.

Who should use Claude Opus 5?

Claude Opus 5 looks particularly compelling for teams whose bottleneck is difficult work that spans multiple steps rather than a lack of raw text generation.

Strong fits

Opus 5 is a strong candidate if you are building coding agents, internal developer tools, autonomous research pipelines, support systems that use multiple business tools, or enterprise workflows with long context and a need for verification. Its pricing makes the model more approachable than Fable 5 for workloads where advanced reasoning needs to run frequently.

It is also a promising option for technical founders. A founder who needs a model to inspect a repository, build a prototype, write tests, diagnose deployment errors, and explain tradeoffs may receive more value from Opus 5 than from a model optimized primarily for polished chat.

Use caution if visual polish is the deliverable

If your core product depends on expressive branding, illustration, high-fidelity interactive 3D, precise animation, or finished design systems, do not assume Opus 5 is your one-model answer. Test it against alternatives using the actual visual artifacts your team ships.

The same applies to narrow tasks with strict scope. If the model’s instinct to inspect and verify creates unnecessary work, a cheaper model—or a tighter agent harness—may be more efficient.

Final verdict: an agentic workhorse, not an automatic universal winner

Claude Opus 5 is best understood as a high-capability agentic workhorse with unusually attractive pricing for its tier. Anthropic’s official benchmarks suggest major improvements in software engineering, computer use, automation, deep reasoning, and knowledge work. The custom KingBench review reinforces the core theme: when the task involves logic, autonomy, implementation, validation, and persistence, Opus 5 can be outstanding.

But the same review cautions against treating the model as the best choice for every task. Its visual and 3D outputs did not consistently match its agentic performance, and the reviewer found it more verbose and less satisfying for general conversation than competing high-end models.

For builders, the decision is not whether Opus 5 is “better” in the abstract. The decision is whether its specific strengths map to your expensive problems. If your work involves agents that must reason, use tools, keep going, and verify themselves, Opus 5 deserves serious testing. If your work depends on refined visual execution or brief, natural, low-friction conversation, benchmark it carefully before making it your default.

FAQ

Is Claude Opus 5 better than Claude Opus 4.8?

For deep reasoning, long-horizon agentic work, software engineering, and cost-performance, Anthropic says Opus 5 is a major improvement over Opus 4.8. However, the custom KingBench review scored Opus 5 slightly below Opus 4.8 overall because of weaker performance on some visual and 3D tasks.

How much does Claude Opus 5 cost?

Standard API pricing is $5 per million input tokens and $25 per million output tokens. Fast mode is priced at $10 per million input tokens and $50 per million output tokens. Prompt caching and batch processing may reduce effective costs for eligible workloads.

What is Claude Opus 5 best for?

Claude Opus 5 is best suited to agentic coding, multi-step tool use, difficult debugging, long-context enterprise work, complex analysis, automation, and tasks where the model must verify and complete a workflow rather than only provide advice.

Does Claude Opus 5 have a fast mode?

Yes. Fast mode is a research-preview configuration that can provide up to 2.5 times higher output-token speed, but it costs twice the standard token rate. It is intended for interactive work where latency matters.

Should creators use Claude Opus 5 for design and visual work?

It can create working visual and interactive outputs, but the KingBench review found its visual polish and complex 3D performance uneven. Creators should test it against their own design tasks rather than assume its coding strength translates directly into the best visual results.

Claude Opus 5 Review: Great for Agents, Uneven for Creative Work