Anthropic has officially released Claude Opus 5.

The most important part of this launch is not another collection of higher benchmark scores.

It is the direction behind the model:

AI systems are being designed to stay with a task for longer and complete more of the work themselves.

Anthropic describes Opus 5 as a major upgrade for long-running agents, software development, and professional knowledge work. It is now the default model for Claude Max and the strongest model available to Claude Pro users. Anthropic also reports substantial gains across software engineering, automation, and computer-use evaluations.

For much of the past year, AI coding competition has been reduced to a simple question:

Which model writes the best code?

After spending the past several months building with Cursor, Codex, and other AI development tools, I no longer think that is the most useful question.

What matters in real development is whether a model can:

  • understand an existing and increasingly complex codebase;
  • identify the root cause instead of patching the visible symptom;
  • maintain context across multiple files;
  • run tests after making changes;
  • recognize when its first attempt failed;
  • and deliver a complete, verifiable result.

These are exactly the kinds of behaviors Anthropic emphasizes with Opus 5.

From Generating Code to Finishing the Task

Anthropic says Opus 5 performs significantly better on long-running, multi-step work.

Its examples include a model building its own computer-vision pipeline when it could not directly inspect a mechanical drawing, identifying the root cause of a real bug that an existing community patch had missed, and creating a test harness when no live data source was available to validate its implementation.

The important point is not that the model learned another isolated skill.

It is that the model behaved more like an engineer working toward an outcome:

When it encountered an obstacle, it tried to create the missing tool or verification step required to complete the objective.

Earlier AI coding systems behaved primarily like code generators.

A developer described a task, and the model produced code.

Whether that code worked, broke existing behavior, or missed an important dependency remained largely the human’s responsibility.

The emerging agent model expands that unit of work:

understand the requirement, inspect the system, implement the change, run validation, detect failure, and iterate.

The basic unit of AI coding is moving from a code snippet to a complete task.

Reliability Matters More Than the First Answer

I have felt this shift directly while rebuilding the Toket Admin system.

The first implementation is rarely what consumes the most time.

The difficult questions come afterward:

Did the field actually save?

Are Chinese and English values handled independently?

Which field is the public page really reading?

Will removing an old component break another workflow?

Does a passing test reflect the intended product behavior?

These questions are rarely solved by a single prompt.

They require the model to preserve the original objective across a long sequence of code inspection, implementation, testing, and human feedback.

For real development, the quality of the first answer may matter less than whether the model still understands the goal on step five, step ten, or step twenty.

Anthropic’s migration guidance says Opus 5 verifies its work more actively, narrates progress more frequently during agentic sessions, and delegates to subagents more readily. The company even recommends removing old prompts that explicitly ask the model to perform a final verification step, because those instructions may now cause unnecessary over-verification.

That tells us something important:

Prompting practices must change as model behavior improves.

In the past, developers repeatedly had to remind the model to test its work, check the result, and avoid leaving unfinished placeholders.

Over time, those behaviors may become part of the model’s default operating pattern.

Cost Is Still a Product Question

Claude Opus 5 is priced at $5 per million input tokens and $25 per million output tokens, unchanged from Opus 4.8. Its Fast mode runs at roughly 2.5 times the default speed but costs twice the base rate.

This pricing also reflects a broader change in AI coding.

Users are no longer paying only for a more intelligent model.

They are paying for:

  • less human supervision;
  • fewer interrupted tasks;
  • fewer rounds of rework;
  • higher completion rates;
  • and more reliable long-running execution.

A more expensive model may still reduce the total cost of a task if it completes work that previously required multiple attempts and hours of manual review.

A cheaper model that repeatedly loses context or produces surface-level fixes may not be cheaper in practice.

Model cost therefore cannot be judged only by its price per million tokens.

The more useful question is:

What does it cost to finish a real task?

Stronger Agents Require Stronger Boundaries

Another notable part of Opus 5 is the balance between capability and safeguards.

Anthropic says the model has become much better at identifying software vulnerabilities, while remaining substantially behind its more restricted Mythos 5 model at converting those vulnerabilities into working exploits. The company is also using classifiers and automatic model fallbacks for certain cybersecurity requests.

This connects directly with the recent OpenAI and Hugging Face security incident.

When an agent can run for a long time, use tools, and actively search for alternative routes, security can no longer depend only on whether a chatbot refuses a sentence.

Builders must decide:

  • which files an agent may access;
  • which commands it may execute;
  • which actions require human confirmation;
  • how abnormal behavior is stopped;
  • whether model fallbacks are visible;
  • and who ultimately owns the result.

The more independently an AI system can complete work, the more important its permission boundaries become.

Toket’s View

Claude Opus 5 reinforces something I increasingly believe:

The next phase of AI coding will not be defined only by code-generation quality.

The most valuable models will understand complex projects, sustain multi-step work, verify their own results, and find root causes when something goes wrong.

For builders, intelligence alone is no longer enough.

The more important quality is:

reliability.

Can the model finish the task?

Does it know when it should stop and ask a human?

Can it prove that a change did not break the rest of the product?

Can it turn a conversation into a deliverable result?

In the past, we used AI to write code.

Increasingly, we will use AI to take responsibility for complete pieces of work.

AI coding is shifting from writing faster to finishing reliably.

Estimate task cost in the AI Cost Estimator or refine prompts in the Prompt Optimizer.