How Good Is Opus 4.8 For Cybersecurity?

Claude Opus 4.8 ↗, released by Anthropic on May 28, 2026, is a strong static code analysis assistant for security work, but it does not test software in runtime, which means it cannot confirm whether a vulnerability is actually exploitable against a live system.

Is Opus 4.8 good at security?

Yes, as an analyst. It reads CVEs and patch diffs and tells you what's exploitable, catches auth bypasses, injection, broken access control, and business-logic bugs in code review, and drafts patches and threat models you can hand to an engineer. The real upgrade for that work is honesty: Anthropic reports 4.8 is about four times less likely than 4.7 ↗ to let flaws in its own code pass unremarked, with a tenfold-plus drop in overconfidence and the lowest hallucination rate of the models tested. A model that won't confidently call a non-exploitable finding exploitable is worth more in a SOC than one that's a few benchmark points smarter. The Cyber Verification Program from 4.7 is still the path for credentialed pros, and Trend Micro's TrendAI ↗ is already evaluating 4.8 under it.

But be clear on what it's doing: reading code, not exercising your running app. This is static analysis with a smarter reader on top. It can say a sink looks reachable; it can't tell you whether that path is actually reachable in your deployed config, with real auth state and live data flows. That gap is where the false positives (exploitable-looking in source, not in reality) and the false negatives (bugs that only appear when components interact at runtime) live, and a static read never sees them.

Where does Opus 4.8 land on MindFort's NexBench?

We put Opus 4.8 through NexBench, MindFort's internal evaluation, alongside ten other models. Each one runs an authorized full-breadth web-app pentest against a controlled target, and an independent GPT-5.5 validator reproduces every finding before it counts toward the score.

Opus 4.8 finished third of eleven. At its max reasoning effort it scored 45, behind GPT-5.6 Sol (61) and Grok 4.5 (52), and 68 of its findings survived validation, the second-highest count in the entire field. That second number is the one that fits its reputation as an analyst: Opus surfaces a lot, and a high share of what it surfaces holds up under reproduction.

Opus is not the cheapest way to reach that score. It runs at max effort for its best result, which costs both tokens and wall-clock time. Plotting score against cost per run shows where it sits: strong on the score axis, toward the pricier end on cost.

Is Opus 4.8 better than Mythos?

No, and it's not meant to be. The runtime safeguards that block prohibited or high-risk cyber prompts are still on, and the system card frames those safeguards, not raw capability, as what closes the practical gap between 4.8 and Mythos. Don't expect 4.8 to chain a multi-stage exploit against a live target or autonomously find unknown bugs at scale. It's trained not to.

Mythos does exactly that, and it's nearly here. Under Project Glasswing ↗, partners found more than 10,000 vulnerabilities in a month, including 6,202 high- or critical-severity flaws across 1,000 open-source projects. Two weeks ago, researchers at the Palo Alto firm Calif used Mythos Preview to chain two macOS bugs into a privilege-escalation exploit that bypassed Apple's Memory Integrity Enforcement on M5 silicon, as The Wall Street Journal reported ↗. That capability was locked behind a dozen partners; Anthropic now says it's weeks from general release, so defenders and adversaries get it at roughly the same time. When we covered 4.7, that model was walled off entirely, and 4.8 is the moment the wall starts coming down. We cover the full defender playbook in What Is Claude Mythos? Why Security Teams Need to Act Now.

But notice what those numbers are: bugs flagged by reading code, not exploits proven against a running system. Grade hundreds of thousands of lines and a model can't hold every cross-service interaction, runtime state, and auth path in context at once, and that's exactly where most real vulnerabilities live. So you get a flood of plausible findings a human still has to triage and disprove, plus the dangerous ones that only surface at runtime and never show up in a static pass. AISI even noted its Mythos evals ran without live defenders, EDR, or active incident response. Ten thousand findings is a triage problem, not a security outcome.

Capability	Opus 4.8 (static reader)	Claude Mythos (autonomous)	MindFort AXR
Reads code, CVEs, patch diffs	Yes	Yes	Yes
Drafts patches and threat models	Yes	Yes	Yes (as merge-ready PRs)
Confirms exploitability at runtime	No	No (findings are code-flagged, not run-proven)	Yes (reproduces the exploit live)
Autonomous multi-stage exploit chaining	No (trained not to)	Yes	Yes
Availability	Generally available	Gated, weeks from release	Available now

Source: capability framing per Anthropic's Opus 4.8 release ↗ and system card; Mythos discovery figures via Project Glasswing ↗; MindFort capabilities per MindFort's product.

What should security teams actually do now?

Opus 4.8 is not a replacement for testing your software in runtime. It reads code, it doesn't run attacks against your live system, so it can't tell you which of its findings actually hold once the app is deployed, authenticated, and handling real traffic. Treating a model's code review as a security test means shipping on unproven findings while the bugs that only exist at runtime go untouched.

That's what MindFort is: autonomous security agents that find vulnerabilities and fix them continuously, across every surface. The difference from a model reading your code is that our agents work against your running application. They probe your apps, APIs, and infrastructure the way an attacker would, run the exploit in runtime to reproduce it before anything reaches you, and ship each proven finding back as a verified patch PR you can merge. It's a new category we call AXR (Autonomous Exploitation and Remediation). For how to evaluate vendors, see our 2026 AI Pentesting Buyer's Guide. You don't need Mythos access to defend against Mythos-class discovery; you need a system that proves what's exploitable and fixes it, not one that hands you ten thousand maybes.

FAQ

Is Claude Opus 4.8 good at security?

Yes, as an analyst. Opus 4.8 reads CVEs and patch diffs, catches auth bypasses, injection, broken access control, and business-logic bugs in code review, and drafts patches and threat models. Anthropic reports it is about four times less likely than 4.7 to let flaws in its own code pass unremarked, with a tenfold-plus drop in overconfidence and the lowest hallucination rate of any tested model.

Is Opus 4.8 better than Claude Mythos?

No, and it is not meant to be. The runtime safeguards that block prohibited or high-risk cyber prompts are still on, and Anthropic's system card frames those safeguards, not raw capability, as what closes the practical gap between 4.8 and Mythos. Opus 4.8 is trained not to chain multi-stage exploits against live targets or autonomously discover unknown bugs at scale.

Can Opus 4.8 replace runtime security testing?

No. Opus 4.8 is a smarter static code reader, not a runtime tester. It can say a sink looks reachable, but it cannot tell you whether that path is actually reachable in your deployed config, with real auth state and live data flows. False positives that look exploitable in source and false negatives that only appear at runtime both live in that gap.

What should security teams do now that Opus 4.8 is out?

Use Opus 4.8 for code review, patch drafting, and threat modeling, but pair it with runtime testing against your live application. Static findings without runtime validation become a triage firehose, and the bugs that only exist at runtime stay untouched. Continuous, validation-first testing is what proves which findings actually hold once the app is deployed and authenticated.

How does MindFort compare to using Opus 4.8 directly?

MindFort runs autonomous security agents against your running application instead of just reading your code. The agents probe your apps, APIs, and infrastructure the way an attacker would, reproduce the exploit in runtime, and ship each proven finding back as a verified patch PR. The category is AXR (Autonomous Exploitation and Remediation).