Claude Opus 5 Review: What Anthropic's New Model Actually Delivers — and Whether You Need It

The 30-second version

On July 24, Anthropic released Claude Opus 5. It costs $5 per million input tokens and $25 per million output tokens — exactly half of Fable 5's $10 and $50. Both models share the same 1M-token context window. Opus 5's knowledge is reliable through May 2026; Fable 5's cuts off at January.

On Anthropic's official coding benchmark, Opus 5 landed within 0.5% of Fable 5's peak score. If you're building a site or an app with AI, that's the actual headline: nearly the same coding ability at half the cost. That said, Anthropic isn't calling Opus 5 a replacement for its flagship. Fable 5 remains the pick for tasks that demand maximum available capability.

You can try Opus 5 for free. The model ships on the Free plan alongside Claude Code, with a weekly limit at half of Pro's. The loud headlines about "42/42 at the olympiad" and a shooter built from a single prompt tell only part of the story. In both cases the result is interesting, but how it was produced changes what it means.

What Claude Opus 5 is

Claude Opus 5 is Anthropic's model for complex agentic coding and enterprise work. "Agentic" means the AI isn't limited to a single reply: it can work through a task step by step, revisit files, check intermediate results, and keep following a plan. In the API the model goes by claude-opus-5. On Amazon Bedrock it's anthropic.claude-opus-5; on Google Cloud, claude-opus-5.

The model is available on claude.ai, in the Claude API, Claude Cowork, Amazon Bedrock, Google Cloud, and Microsoft Foundry. Another way to use it is Claude Code, Anthropic's tool for building and modifying projects with Claude.

API pricing is split into input and output. Input tokens are everything you feed the model: your request, instructions, conversation history, project materials. Output tokens are its reply. Opus 5 charges $5 per million input tokens and $25 per million output tokens. That's the same price as Opus 4.8 — and half of Fable 5.

Think of the 1M-token context as the working memory of a single run. A token is a small chunk of text, not a message and not a file. The bigger the context, the more instructions, code, conversation, and decisions the model can hold at once. For a beginner, the practical upshot is simple: you can hand the AI a large project and spend less time re-explaining what's done, which constraints apply, and where things broke.

A big context doesn't guarantee the model will read every file flawlessly. It just lets you fit more material into its working area. Verifying the output is still part of the job. Opus 5's maximum response is 128k tokens, and via the Batch API with the beta header output-300k-2026-03-24 it can reach 300k.

The knowledge cutoff matters in practice too. Opus 5's reliable knowledge runs through May 2026; Fable 5's ends in January 2026. That gap can be the difference between current library guidance and advice for a version that has since changed. It's not real-time access to events, but the odds of starting from stale information go down.

Opus 5 ships with adaptive thinking enabled. In the API and Claude Code, the effort parameter, which sets how hard the model works, defaults to high. There's also a Fast mode: 2.5x faster, at double the price.

Anthropic's positioning here is more precise than the word "flagship." The company keeps Fable 5 for maximum available capability and offers Opus 5 as the cheaper workhorse. If you're building a typical project, the question isn't "which model tops the leaderboard" — it's "do I need a small bump at the capability ceiling for double the price."

The "42/42 at the olympiad" claim: what's really behind it

Telegram channels claimed Opus 5 aced the 2026 International Mathematical Olympiad: 42 points out of 42, no tools, no agentic scaffolding. Phrased that way, it sounds like the model sat an official exam and got a result verified by the organizers. The confirmed picture is different.

The official, organizer-verified 42/42 scores went to Huawei Celia and Xiaohongshu dots-note-3.0. The exams took place July 15–16, 2026, in Shanghai. The models received the problems after the human contestants finished, worked within a fixed window, and no humans intervened. It's precisely the organizers, the pre-set conditions, and the human grading that make that result certified.

Separately, there was an independent test by venture investor Deedy Das, run after the official exam. In it, 42/42 went to Claude Fable 5, GPT-5.6 Sol, Kimi K3, and Axiom AxiomProver. The published list names Fable 5 — not Opus 5. The models got a minimal toolset: bash, write_file, and read_file. Each problem had a 150-minute window, and the answers were graded by AI agents — not IMO organizers, not humans.

The author of the independent test himself asks that the results be treated as strong but not authoritative. That's a fair caveat. It doesn't diminish what the models did, but it does forbid quietly equating two different events: an official exam with organizer verification, and a post-hoc experiment with a different grading procedure.

There's one more reason to stay calm about the number 42. In the independent run, the maximum wasn't hit by one system but by several at once. A test like that no longer separates the leaders — they're all pinned at the top of the scale. When four participants max out, a single number says nothing about stability, cost, ergonomics, or how well a model will handle your project.

There's a simple routine for checking loud claims. First, find out who ran the test. Then check whether the conditions were uniform and who graded the answers. After that, separate the official result from the independent replication. "IMO gold" only applies where there's organizer certification — not where a matching number shows up in a third-party test.

For Opus 5, the honest phrasing goes like this: channels reported a 42/42, but the official perfect scores belong to other models, and the independent test lists Fable 5 among those that maxed out. That's not a reason for a gotcha tone. It's a reason not to mistake a short headline for a full description of the experiment.

The one-prompt shooter: what actually happened

A published breakdown pointing to developer mshumer's repository describes a browser shooter called Claude of Duty. Per the demo's author, it's a first-person game on WebGL2 and Three.js, roughly 55,000 lines of code. Geometry, textures, and sounds are generated procedurally — no pre-made art assets.

The game reportedly has WASD movement, jumping, crouching, shooting, aiming, and reload on R. The player can also lean with Q and E. From that description alone, it's easy to conclude the author typed a magic phrase and got a finished project a moment later.

But the work went differently. The repository's own description talks about a fleet of AI agents run by an orchestrator: three rounds of six agents each, with the 55,000 lines split across 11 subsystems. The model didn't produce the code in one shot — the result went through repeated passes where problems were found and pieces rewritten. Neither the exact build time nor the original prompt text was published.

So "a shooter from one prompt" is true only in the loosest sense: a human may have set the initial direction with a single command. Behind that command stood multiple passes, division of labor, and automated reworking of parts of the project. Comparing that process to an ordinary single chat reply doesn't hold up.

For vibe coding, this is more useful than the game itself. The big result came not from a secret prompt phrasing but from how the work was structured. A large goal was broken into subsystems, tasks ran in parallel, and the output went through repeated critique. Someone with no programming background can apply the same principle at a smaller scale: build one screen first, verify it, then wire up the next feature, and only then move on.

The demo shows off the strength of current models while also setting the right limit. AI can write a huge volume of code if the process maintains structure and feeds errors back for fixing. Line count by itself doesn't tell you a product is finished, usable, or reliable. Those qualities emerge through testing — which a short headline typically doesn't show.

Opus 5, Fable 5, and Opus 4.8: which one to pick

The three models are easiest to compare on the parameters that affect real work. There's no point rehashing a benchmark table here: for a beginner's choice, price, context size, and intended use matter more.

For everyday project building, Opus 5 looks like the practical choice. Per Anthropic's announcement, it landed within 0.5% of Fable 5's peak score on CursorBench 3.2 while costing half as much. That's a concrete argument for Opus 5 when you work with code but don't know in advance whether you'll need the absolute maximum.

For the hardest problems, Anthropic keeps Fable 5. Paying the premium makes sense once Opus 5 has actually hit its limit and the extra capability matters more than the cost. Buying Fable 5 up front, just because it sits higher in the lineup, isn't necessary.

To save money, start with Free. If you move to the API, Opus 5 cuts the price relative to Fable 5 without shrinking the context. Opus 4.8 has no edge over Opus 5: both cost $5 in and $25 out, both take a 1M-token context, but Opus 4.8's knowledge ends in January 2026. There's no reason to stay on it deliberately.

If you want a broader breakdown of the differences, bookmark our comparison of Fable 5, GPT-5.6, and Opus 4.8. For the current decision, one short rule is enough: Opus 5 for daily work, Fable 5 only after the cheaper model has genuinely failed.

Do you need Opus 5 if you're not a programmer

Switching models won't build your product for you. Opus 5 won't pick a useful idea on your behalf, won't know your unstated requirements, and won't decide which result is acceptable. It can write code and carry out long chains of actions, but whether your site or app is done is still determined by verification.

The first real change is the cost of mistakes. Opus 5 costs half of Fable 5 and nearly matches it on Anthropic's official coding benchmark. When the model heads down a wrong path and you have to redo a task, the lower price shrinks the cost of iteration. On the free plan an attempt has no dollar cost, though every attempt eats into your weekly limit.

The second change is the 1M-token context. It fits a large volume of project material: requirements, code, prior decisions, and the history of fixes. A beginner doesn't have to re-narrate the whole backstory every time. But you do need to organize the material so the model sees current instructions rather than several contradicting versions.

The third change is knowledge freshness. May 2026 instead of January 2026 means a smaller gap between what the model was trained on and the current state of your libraries. That lowers the odds of stale advice, but it doesn't remove the need to check the docs and the output.

What doesn't change is the core: you have to define what to build, break the work into understandable parts, and accept each part against an observable criterion. A button needs an expected outcome, a form needs a clear scenario, a fix needs a check that the bug is gone. The Claude of Duty story illustrates the principle well: the impressive volume came from decomposition, parallel work, and repeated self-critique.

The skill of specifying tasks for an AI and accepting its work step by step doesn't depend on which model shipped this week. That's the skill we teach at skillmake. A new model can speed up an individual step, but a solid process carries over between Opus, Fable, and whatever comes next.

If you're just starting out, you don't need Opus 5 because it's "the newest." It's useful as an affordable workhorse with a long context and fresher knowledge. Start with the free tier, build one small finished piece of a project, and watch where you hit a limit. Paying for a higher plan makes sense after that observation — not before it.

How to try Opus 5 for free

The Free plan costs $0. It includes Claude Code and the Fable, Opus, Sonnet, and Haiku families. The weekly limit is 50% of Pro's. That means your first test of Opus 5 requires no subscription and no API spend.

You can try the model on claude.ai in a regular chat or in Claude Code on your own project. The first is handy for explanations and small tasks. The second shows you how the model works on a project in agentic mode. Start with a task whose finished state you can describe up front — otherwise you won't be able to tell whether the new model actually helped.

If the free limit isn't enough, Pro is $17/month billed annually or $20 monthly. Max 5x and Max 20x start at $100/month and give 5× and 20× the Pro limits respectively. Team is $20 per seat billed annually or $25 monthly; a premium seat is $100 or $125. Enterprise is $20 per seat plus usage at API rates.

One caveat from our own situation: we build skillmake from Russia, and for readers there Claude requires a non-Russian IP and won't take Russian cards — we've covered the details in our (Russian-language) guide to accessing Claude AI from Russia, so we won't repeat it here.

Search results also surface reseller access. That setup means you pay a third party, and that third party gets to route your requests through its infrastructure. The risk isn't just about payment: the contents of your prompts also pass through the reseller's pipeline. Don't send private project material through such access unless you understand who processes it and how.

If direct access to Claude is inconvenient where you are, look at our breakdown of Kimi K3 as a free alternative. It doesn't change the method: set a verifiable task first, review the result, then fix the next specific failure.

What it costs in practice

The $5/$25 price applies neither to a single request nor to a subscription. It's the API rate per million tokens. Picture tokens as small chunks of text that make up your request, project files, history, and the model's reply. The more material you send and the longer the answer, the more tokens get processed.

Input and output are billed separately. Input covers everything the model reads; output covers everything it produces. So a long project history and a big generated file affect different parts of the bill. The 1M-token context is the ceiling of working memory — not a mandatory cost of every request.

For a beginner, the difference between Free, Pro, and Max usually matters more than the API rate. If you work on claude.ai or in Claude Code on a plan, what you run into first is the weekly limit. On Free it's half of Pro's. API pricing becomes the main question once you wire the model into your own app and pay per processed token.

The free plan is enough to check three things: whether Opus 5 understands your instructions, whether it holds your project's context, and whether it helps carry a task to a verifiable result. If the limit runs out before you can finish working cycles, then compare Pro and Max. Until that point, a subscription buys usage headroom — it doesn't fix a vague task definition.

The difference from Fable 5 in the API is simple: the same amount of work costs half as much on Opus 5's rate card. Meanwhile Anthropic's official benchmark shows near-identical coding results. For your first projects, that's reason enough to start with Opus 5 and reach for Fable 5 only after hitting an actual limit.

FAQ

Did Opus 5 really win the math olympiad?

There is no confirmation that Opus 5 earned an official 42/42 at the IMO. Telegram channels claimed exactly that, but the only models with organizer-verified perfect scores are Huawei Celia and Xiaohongshu dots-note-3.0. In Deedy Das's independent test, 42/42 went to Claude Fable 5, GPT-5.6 Sol, Kimi K3, and Axiom AxiomProver. That test ran after the official exam, the answers were graded by AI agents, and the author himself doesn't consider the result authoritative.

Is Opus 5 better than Fable 5?

Not across the board. Anthropic keeps Fable 5 as the model for maximum available capability and positions Opus 5 as the cheaper option for complex agentic coding and enterprise work. On CursorBench 3.2, Opus 5 landed within 0.5% of Fable 5's peak score at half the price. Opus 5 also has fresher knowledge: May 2026 versus January.

Can I use Claude Opus 5 for free?

Yes. The $0 Free plan includes models from the Fable, Opus, Sonnet, and Haiku families, and Claude Code is included. The Free weekly limit is 50% of the Pro limit. That's enough to try Opus 5 before deciding on a subscription.

Does Opus 5 work in Russia?

Claude requires a non-Russian IP and doesn't accept Russian cards. The free tier still needs a foreign IP, and a Russian card won't work for a paid plan. Reseller access adds risk: a third party handles your payment and may be able to see your prompts.

Should I switch to Opus 5 if I'm just starting out?

Yes, if it's available to you on Free — but don't turn the switch into a project of its own. Pick one well-defined task and compare the result to what you were getting before. Opus 5 offers a 1M-token context window, knowledge through May 2026, and API pricing at half of Fable 5. Those advantages pay off once you already have a clear definition of done.

Will Opus 5 replace a programmer?

Opus 5 can run complex agentic workflows and write large volumes of code, but it doesn't decide whether a product is useful and doesn't catch unstated requirements. The Claude of Duty demo, per its author, took a self-critique loop and subagents working across 11 subsystems. The result came from an organized process, not one flawless answer.

This article is part of skillmake.ru — a Russian-language project about building real products with AI agents. The article you're reading is a translated case study from our production experience.