How to use Claude Mythos 5.2 to find and fix security bugs
Get Mythos 5.2 access, set up Claude Code, and use a bounded workflow to find, verify, and fix bugs in your own code.
By Nikhil Shukla ·
Claude Mythos 5.2 and Claude Fable 5.2 are the same model. Mythos is the copy Anthropic gives to people it has verified, with some of the cybersecurity locks taken off.
That one fact sets expectations for day one. If you already use Fable for code review, Mythos reads your code with the same eyes. What changes is that it stops handing your security work to an older model partway through, and it will follow a finding further: validate it, reproduce it locally, write the fix.
I am building Creadefy, a certificate platform where the verification page is the product, so I come at this from the defender's chair. This is the guide I would want on the day the approval email arrives: how to get access, set up Claude Code, scan within a written scope, and verify each finding before fixing it. For OpenAI's equivalent, see the Daybreak Blue guide.

Claude Security's managed findings interface, shown in Anthropic's product walkthrough. The Claude Code workflow below uses a separate interface.
What Mythos 5.2 is, in plain terms
Anthropic released Fable 5.2 and Mythos 5.2 together on 9 November 2026 and says outright that they share one underlying model. Fable is the public one. It carries safety classifiers that block high-risk cyber activity, and Anthropic gives penetration testing, exploit generation and vulnerability work on binaries as examples. When a request trips them, the answer comes from Opus 4.8.
Mythos is the version for verified users. It costs the same as Fable: $8 per million input tokens and $40 per million output tokens.
The headline number comes from Anthropic's CVE Rediscovery test. It gives a model a snapshot of a project from before a known vulnerability was fixed and checks whether the model finds the bug unaided. Across 1,829 CVEs, Mythos 5.2 found 89.6%. Mythos 5.1 found 78.3%, and Opus 5.5 with its safeguards switched off found 81.3%.
Read the footnotes, though. One says that on Anthropic's own evaluations "vulnerability identification is roughly on par with Opus 5.5", which sits oddly next to that table, and the page does not reconcile the two. The strongest claims come from outside testers. An unnamed security company reported that one in six confirmed bugs from Mythos 5.2 were missed by every other frontier model it tried. Mozilla's Brian Grinstead said it roughly doubled the discovery metrics of Mythos 5.1 across Firefox scanning campaigns.
Two outside data points arrived in the first ten days. XBOW, which builds autonomous offensive security agents, ran Mythos 5.2 and 5.1 against 65 real web application vulnerabilities. Both solved 61. The difference was cost: 5.2 reached 90% of them for about a third of the spend and a third of the output tokens. XBOW's own summary was that 5.2 is no giant leap on web apps but is more efficient, and it tested nothing except web bugs.
The other is an anecdote. Max Weinbach of Creative Strategies, who also holds Daybreak Blue, posted that Mythos 5.2 immediately found seven issues that none of his other models had found. That is one person and one codebase, though it matches what the outside testers told Anthropic.
My reading is that the gap in spotting bugs is real but modest, and the bigger differences come after the spot. Anthropic describes 5.2 as better at reproducing and fixing vulnerabilities. One tester found that earlier models overstated the seriousness of about 1 in 20 findings, where 5.2 overstated none. That figure is from a single audit, but for a small team, fewer inflated severities matter more than a few extra points of recall.
Do you need Mythos at all?
Maybe not yet, and Anthropic says so itself. Its programme announcement lists four things the generally available models already do with no verification: code review, patching known issues, finding vulnerabilities in source code you own, and triaging security alerts.
Mythos access comes through the Cyber Verification Program, which has three tiers.
| Tier | What it unlocks | Who can apply |
|---|---|---|
| Defense Access | Security operations, incident response, malware analysis, detection engineering, vulnerability triage and validation | Organisations and individuals |
| Red Team Access | Authorised pen testing, red teaming, offensive tooling and exploit development | Organisations only |
| Specialized Access | Offensive testing of critical infrastructure | A small number of organisations, reviewed with the US government |
A founder securing their own product wants Defense Access, and it helps to be realistic about what that is. Anthropic tested the tiers on a benchmark of multi-stage offensive operations, using Opus 5.5. With no programme access, every attempt was blocked on the first prompt. Under Defense Access, 46 of 50 trials were still blocked at some point. Under Red Team Access, none were. Defense Access is built for defensive work and behaves that way.
So the test for whether to apply is simple. If Fable or Opus keeps interrupting legitimate work on your own systems, such as validating a reported bug or picking apart a suspicious file, apply. If your scans already run to the end, the method will do more for you than the model.
Anthropic's launch posts say something similar about the model in general. The official Claude account recommends starting most coding work on Opus 5.5 and moving up when the scope calls for it. Felix Rieseberg of Anthropic wrote that he still prefers Opus for everyday work, because the bigger model thinks a little slower.
Getting access without losing a week
The application lives in Anthropic's Verification Portal, and the help article has the full detail. Felix Rieseberg of Anthropic said on launch day that access is now much easier to get, even for individuals, if you are a defender hardening your own work. These are the parts that trip people up:
- Choose individual or business carefully. Individuals can only get Defense Access, and you cannot change the account email later. For a company, one owner or admin submits one application for the whole organisation.
- Have a paid plan first. The programme is open on Pro, Max, Ultra, Team and Enterprise plans, and on the API with billing set up. It is not available on Free.
- Have your ID ready. Individuals need a physical government photo ID and a phone camera for a possible live selfie. Organisations also give their legal name, address and registration number.
- Expect to vouch for your own security. For Defense Access that means multi-factor authentication and API keys rotated at least every seven days. From 15 December 2026 it becomes phishing-resistant MFA and no long-lived API keys at all.
- Describe the work specifically. Gotchaa Lab, a small Malaysian software company, wrote that it described checking its own web apps and servers, inspecting suspicious files and writing fixes, with no client systems. It was approved about twenty minutes later. Anthropic's stated target is two days, so do not plan around that.
Know the conditions before you accept them. Data retention is switched on for everyone enrolled, so that Anthropic can monitor for misuse. Your tier covers your own internal work, and serving clients from it needs a separate approval. The Usage Policy still applies in full.
After approval, access switches on automatically on Pro, Max, Ultra and Team plans. On Enterprise an owner has to grant it through a custom role. On the API an admin enables it for a specific workspace, which cannot be the default one. On Pro, Mythos runs only on usage credits. On Max and Ultra it shares up to half of your weekly limit with Fable.
There is also a route with no application. If your company is on Claude Enterprise, Claude Security runs its scans on Mythos and does not require the programme. More on that below.
Setting up Claude Code for security work
Four things need setting before the first prompt.
Start with the model. Run /model and pick Mythos 5.2. Gotchaa Lab reported that it was missing from the menu straight after approval, that typing /model claude-mythos-5-2 worked anyway, and that it showed up in the list after a restart.
Then the effort level. Claude Code has five: low, medium, high, xhigh and max. For a hunt I would set /effort xhigh. Anthropic reports that Mythos 5.2 beat the older models on CVE Rediscovery at every effort level, so drop to high if cost matters more than depth. Keep max for a single hard finding, since it only lasts for the session.
Watch the bill while you learn what a hunt costs. GrapheneOS, whose developers hold Defense Access as individuals, wrote that Mythos 5.2 is much more useful to them than Daybreak Blue, and that it eats tokens fast enough to limit how much they use it.
Isolate the session. Start Claude Code inside a dev container, or switch on /sandbox, which gives Bash commands filesystem and network isolation. Mythos 5.2 is better behaved here than its predecessors. Anthropic ran an adversarial test with a deliberately weak sandbox and tasks that mostly could not be solved without escaping it. Mythos 5.2 reached for credentials or files planted outside the sandbox in 3.1% of scenarios, down from 21% for Mythos 5.1 and 39% for Mythos 5. That is a large improvement and still not zero, so keep real credentials out of reach.
Finally, give it the rules. Write SECURITY-SCOPE.md in the repository and reference it from CLAUDE.md, so every session starts from the same scope. Keep the brief specific: owned targets, allowed local tests, excluded paths, credential handling, and stop conditions.
# SECURITY-SCOPE.md
In scope: this repository and a local test instance.
Allowed: source review, local tests, and patch proposals.
Excluded: production systems, third-party services, and secrets.
Stop if a test touches a live target or exposes someone else's data.
Report uncertainty and ask for human review before applying a patch./model claude-mythos-5-2
/effort xhigh
/sandboxRun the Claude Security plugin first
Before writing a hunt prompt of your own, run the scanner Anthropic has already built. The Claude Security plugin is in beta for Claude Code users on supported paid or API access. It runs on models available in your session; Anthropic directs readers who specifically want Mythos-powered scans to its managed Enterprise product.
/plugin install claude-security@claude-plugins-official
/claude-securityThe second command opens a menu with three jobs: scan the codebase, scan a set of changes, and suggest patches. A team of agents maps the architecture, builds a threat model, hunts, and has independent verifiers review every finding before it reaches the report.
A few practical notes from the docs. On a large repository, pick one of the focused scopes it offers, such as the API layer or the authentication code. It works best in auto mode. It needs Python 3.9 or later on your path, and on a Pro plan you have to turn on dynamic workflows in /config first.
Results land in a CLAUDE-SECURITY-<timestamp>/ folder inside the repository. CLAUDE-SECURITY-RESULTS.md is the report, with an ID, impact, exploit scenario, severity, confidence and recommendation for each finding. The same findings come as JSON lines and as a SARIF file you can feed to GitHub code scanning. The folder carries its own .gitignore, so it will not slip into a commit.
When you are ready to fix, run /claude-security again and choose Suggest patches, or just say fix finding F3. Each patch is drafted in a scratch copy and reviewed by a second agent that runs your tests. You apply it yourself:
git apply CLAUDE-SECURITY-<timestamp>/patches/F1.patchKeep it to one patch per pull request. The docs are firm that patches are never applied automatically. They also say two scans of the same code can surface different findings, so run it again next week.
There is a model distinction here. The plugin docs say scan agents use your Claude Code session's model, but direct readers who specifically want scans on Mythos to the managed Claude Security product. Use the plugin as a baseline on an available model; use an approved Mythos session for the focused hunts below, or the Enterprise product for managed Mythos scanning.
Then hunt the way Anthropic's red team did
The plugin gives you breadth. For depth on the code that matters most, copy the scaffold Anthropic's red team described when it first tested Mythos. Thomas Ptacek describes the same shape in earlier work by Nicholas Carlini: a short script that loops over files, asks the same question each time, then makes a second pass to verify.
Start by ranking. Their scale ran from 1, a file with nothing that could hold a vulnerability, to 5, a file that parses untrusted data from the internet or handles authentication.
Read SECURITY-SCOPE.md. Do not look for bugs yet.
Rank every source file in this repository from 1 to 5 by how likely it is to contain an exploitable security bug.
1 = nothing that could hold a vulnerability, such as constants or type definitions.
5 = parses untrusted input from the network, or decides authentication or authorisation.
Output a table sorted by score, with one line of reasoning per file. Save it to security/ranked-files.md.Then give each high-scoring file its own session. Starting from a different file each time is what sends the runs down different paths through the code.
Read SECURITY-SCOPE.md and docs/threat-model.md.
Start from <file>. Find the most serious security vulnerability reachable from this file. Read whatever other files you need. Where it helps, run the code or the tests locally to confirm or reject your hypothesis.
Answer with either "no bug" or one report: the trace with file and line, the attacker's starting position, and steps to reproduce it on the local instance. Do not write a fix.You can run that by hand for your top ten files, or loop it. For the loop, put the paths that scored 4 or 5 into a file called security/top-files.txt, one per line. Claude Code's non-interactive mode takes a prompt with -p:
while read -r file; do
out="security/runs/$(echo "$file" | tr '/' '_').md"
claude -p "Read SECURITY-SCOPE.md and docs/threat-model.md. Start from $file. Find the most serious security vulnerability reachable from this file. Answer with either 'no bug' or one report with a trace and local reproduction steps. Do not write a fix." \
--model claude-mythos-5-2 > "$out"
done < security/top-files.txtTreat that loop as a sketch. A -p session skips the workspace trust prompt, so only run it inside the sandboxed clone, and check which permission settings your version needs before it can run tests.
Finish the way the red team did, with a validator that sees only the report:
I have received the following bug report about my own codebase. Check it against the code. Tell me whether it is real, and whether it is worth fixing this week. If it only affects a corner almost nobody can reach, say so.
<paste one report>Two additions come from people who have triaged Mythos output. Tell the model what your documentation promises, because three of the five findings in the curl report were documented behaviour. And ask for a test before you believe anything. Mozilla only counted findings that came with a reproducible test case.
Where /advisor helps and where it does not
The advisor is a Claude Code feature that pairs your main model with a second, usually stronger one. The main model consults it at decision points: before committing to an approach, when the same error keeps coming back, and before declaring a task done. The advisor reads the whole conversation, tool calls included, and sends back guidance.
You set it with one command:
/advisor opus
/advisor fable
/advisor offThe rule that shapes everything else is that an advisor must rank at or above the main model. So its main use is saving money. A cheaper model does the hours of reading and the expensive one weighs in a handful of times. Anthropic pitched the pattern the same way when it brought it to its developer platform in April: pair Opus as the advisor with a cheaper executor, and you get close to Opus-level results for a fraction of the cost.
For security work I see two good uses.
The first is before you have Mythos. Run a long review on Sonnet or Opus with a stronger advisor, and ask for the consultation where judgement matters. Add a line such as consult the advisor before you finalise the threat model, and again before you report findings. The docs say you can request a consultation in the prompt like this, and that there is no setting to force or cap calls.
The second is a cheap check on the plan. A scan plan that hunts the wrong directories wastes every token spent after it. One advisor call at the planning step costs far less than a wasted run.
Know the limits. The advisor is experimental. The current docs support the Anthropic API, Claude Platform on AWS, and Anthropic-managed Claude Models on Google Cloud. They exclude Amazon Bedrock, Google Cloud's Agent Platform, and Microsoft Foundry. Each call re-reads the whole transcript at the advisor's rates. A Fable advisor needs usage-credit consent on some plans. Fable also carries the cyber safeguards, so it may decline on security transcripts. The docs list a declined state without saying what triggers it.
With Mythos itself as the main model, the current Claude Code pairing table does not list a supported advisor pairing. Do not build the review around an advisor call in a Mythos session. Run /advisor with no argument if Anthropic updates the picker, and use a fresh reviewer session in the meantime.
For an independent check on a Mythos session, start a fresh session with only the finding report and ask it to test each claim against the source. The advisor shares the main model's entire context; a fresh reviewer sees the report without the hunt's assumptions.
On Enterprise, let Claude Security carry the routine
Claude Security is Anthropic's managed scanner, in public beta for Claude Enterprise. An owner switches it on under Organization settings. You connect repositories, it runs a deep baseline scan, and after that it rescans as the code changes. Its scans run on Mythos and need no Cyber Verification Program access. Each user needs a premium seat, and usage is billed at token cost with no platform fee.

The managed product's findings view in Anthropic's walkthrough. These are example findings, not results from my code.
Four habits separate a useful setup from a noisy one:
- Put related repositories in one project. A project holds up to eight, each marked as in scope or as context only. Anthropic's example of what this catches is a backend trusting input that the client was supposed to validate.
- Edit the threat model. Claude writes one from your code. You can correct it on the project's Resources tab and add architecture documents. Vanta's director of security said the findings lined up with their priorities once they wrote their own risk policy into it.
- Dismiss with a reason. A dismissed finding stays closed on later scans. You can also explain in the project chat why it was wrong and ask Claude to update the threat model.
- Use the Fix button. It opens Claude Code on that one finding. The finding is marked fixed when the fix lands, and reopened if the issue comes back.
Its severity scale is tied to how exploitable something is in your codebase. Critical means anyone on the network can exploit it with no login and no action from a victim, and can both read and change data. High means serious impact that needs a login or a victim, or impact that is only partial.

Anthropic's example finding detail connects the attack path to source locations and a review state.
Two cautions. Claude Security does not support zero data retention. And you should only scan code your company owns or has the right to scan.
Until 31 December 2026 there is a launch offer for eligible Enterprise organisations: up to $25,000 a month in usage credits for two months. That is a cheap way to find out what a baseline scan of your codebase turns up.
What Mythos still gets wrong
The honest counterweight to the launch numbers is Daniel Stenberg's write-up of a Mythos Preview scan of curl. Five findings were labelled confirmed. The curl security team kept one as a vulnerability, at low severity. The report also listed about twenty ordinary bugs, described clearly, with few false positives.
Stenberg's conclusion was that he saw no evidence it found more than the AI analysers curl already used, while AI analysers as a group are significantly better than traditional static analysis. That was Mythos Preview, three releases ago, on one of the most audited C codebases there is. I still think it sets the right expectation: useful and uneven, with a person at the end.
Cloudflare, which ran Mythos Preview across more than fifty repositories, found its refusals inconsistent. It declined one task and then accepted the same task after an unrelated change to the environment. Cloudflare also saw model-written patches that fixed the bug and broke code depending on it.
And results move between runs. Anthropic's own documentation says so for both the plugin and the managed product.
I read all of this as a case for the unglamorous parts of the method: a written scope, a sceptic, a test for every finding, and a person who reads the patch.
Where I would start in week one
If the approval email were in front of me today, the first week would look like this.
On day one, set up the sandboxed clone and the scope file, then run the plugin on the code that handles authentication and permissions. On day two, read the report with a sceptic session open and write a test for everything that survives. Spend the rest of the week on per-file hunts across the files that scored 5, with one fix per pull request and a rescan of each area after its fix lands.
The ranking, focused hunt, and independent review prompts above cover those steps. The OpenAI side of the story is in the Daybreak Blue guide.
If you issue certificates and want each one to be verifiable by anyone with the link, have a look at what I am building at Creadefy. And if you already have Mythos and something here does not match what you see, tell me. This area changes monthly, and I would rather fix the article than leave it wrong.
Sources
Product instructions were rechecked on 22 November 2026. Plans, limits and model lists change often, so follow the links before relying on a detail.
- Anthropic announcements: Claude Fable 5.2 and Mythos 5.2, Expanding the Cyber Verification Program, Mythos Preview red team write-up, Claude Security update
- Anthropic help and docs: Cyber Verification Program, Use Claude Security, Claude Security product page, Claude Security plugin, advisor, model configuration, Claude Code security
- Teams and researchers: Daniel Stenberg on curl, Cloudflare, Mozilla, Thomas and Erin Ptacek, Gotchaa Lab
- Posts on X: XBOW, Max Weinbach, GrapheneOS, Felix Rieseberg, and the Claude account on which model to start with and on the advisor pattern