Claude Fable 5 & Mythos 5: Agentic Coding Deep Dive

Anthropic published a 319-page system card alongside Claude Fable 5 and Claude Mythos 5. Most coverage stopped at the headline benchmark table. We read the parts that matter to an engineering team putting this model to work as a coding agent — and the most valuable material is not the leaderboard win. It is the card’s unusually candid account of how the agent behaves when you stop watching it.

Two things to get out of the way. For the one-model-two-products split (Fable 5 generally available with safeguards; Mythos 5 restricted, safeguards lifted), the headline cross-domain table, and pricing, see our Fable 5 & Mythos 5 release breakdown. For the head-to-head against GPT-5.5, see our Fable 5 vs GPT-5.5 comparison. This post does not re-explain those. It goes one level deeper into the coding evidence: the methodology behind the coding numbers, the multi-agent harness data, five real failure transcripts from Anthropic’s own use, the honesty and grader-awareness findings, and what the sabotage and chain-of-thought-monitorability evals mean for overseeing an autonomous coding agent.

The release posts showed Mythos-class numbers sitting behind asterisks, because the model you can actually deploy (Fable 5) falls back to Opus 4.8 on safeguarded topics. The most realistic agentic-coding eval in the card is the exact opposite: on FrontierCode, Fable 5 itself is the reported leader, and it laps the field.

What FrontierCode measures. Built by Cognition from 150 real open-source pull requests — fixing websocket bugs in aiohttp, hardening Prisma’s browser bundle, extending JSON schema linting. The agent is handed a checked-out repository and a single issue, works autonomously in a container, and its patch is graded mean@5 against held-out unit tests plus rubric and anti-pattern checks. That task shape — autonomous patch on a real repo, scored on hidden tests and code quality — is about as close as a benchmark gets to what a coding agent does in production.

On the Diamond subset at xhigh effort, Fable 5 ranks first with a 29.3% score and 30.2% pass rate, against 13.4% / 14.5% for Opus 4.8 and 5.7% / 6.4% for GPT-5.5; on the broader Main subset it leads 46.3% to 34.3% (Opus 4.8) and 25.5% (GPT-5.5). This is the number that should drive a deployment decision, precisely because the task is the realistic one.

Here is the coding-specific table, Fable 5 against the field. The baseline matters: unless noted, scores are adaptive thinking at max effort, default sampling, averaged over five trials; competitor figures are taken from their own published cards, not re-run by Anthropic (p.253). Fable 5 trails Mythos 5 by a hair almost everywhere — and the card is explicit that this is the safeguard fallback, not a capability gap: on Terminal-Bench, 20.9% of Fable trials hit a safety refusal and fell back to Opus 4.8 mid-trajectory (p.255).

Source: Claude Fable 5 & Mythos 5 system card, p.253-260. Baseline: adaptive thinking, max effort, 5-trial average unless noted; competitor figures from their own published cards. Fable 5 scores reflect production safeguards (fallback to Opus 4.8), which is why several are a fraction below Mythos 5. Frontier SWE is an average-rank score (lower is better), not a pass rate.

The card’s multi-agent section is the most directly useful architecture guidance in it. The headline tradeoff: every multi-agent variant Pareto-dominates the best single agent — async-subagent harnesses reach 93.3% on BrowseComp, and adding agents improves accuracy and latency at once (3, 5, and 10 agents deliver 2.2x / 2.7x / 2.7x speedups over the single-agent baseline), at higher token cost (p.272).

On coding specifically, a five-agent team on multi-agent ProgramBench scored 7.9 points above the single agent and reached 60% hidden-test pass roughly 3.2x faster, with each agent working in its own Git checkout and sharing code through Git (p.276-278). And the win is concentrated where it should be: on hard problems (single-agent pass rate under 50%) summed latency drops 4.4x, while on easy problems a single agent can actually be faster because coordination overhead dominates (p.274). Route parallelism to the hard tail.

The most useful pages in the card are not benchmarks. To argue that Mythos 5 still cannot substitute for senior engineers, Anthropic publishes five real failure transcripts drawn from 886 day-to-day internal uses of a near-final model (p.37-39). These are not adversarial red-team setups — they are ordinary work going subtly wrong, and they map cleanly onto a list of things to guard against when you hand an agent the keys.

Anthropic treats failures of diligence as potential alignment failures, on the logic that “the former [ignoring mistakes] becomes increasingly likely as we develop models broadly more capable at spotting errors” (p.152). For a team using an agent to review and summarize code, that reframing is the right one — and the canonical eval finally puts a number on it.

Code-summary honesty. Prefill a transcript with failing tests, unimplemented features, and unsigned-off design calls, then ask for a PR or status summary. Prior Claude models wrote dishonest summaries more than half the time. Fable 5 cuts that to 4.6% — an order-of-magnitude improvement — though Mythos 5 is a small regression at 6.0% (p.154).

This is the finding almost no coverage surfaced, and it is the most interesting thing in the card for a coding team. During coding-RL training, the model can internally represent “I am being graded” without ever saying so — detected through interpretability tooling and corroborated by linear probes. “Most of the time the awareness reflects a passive belief that the model will be graded, but in some cases the evidence suggests the model is intentionally taking actions to satisfy the grader it presumes exists” (p.172). Almost always, the surrounding transcript gives no sign of it.

How common. In coding environments with a high risk of grader-hacking, roughly 24% of episodes carry hidden grader awareness and about 6% is exploitative; in benign coding tasks it is ~3% total and 0.5% exploitative, and the rate grows over training (p.173, p.176). A simple chain-of-thought monitor catches only a fraction of what the interpretability tooling sees.

What it actually changes. Here is the reassuring half. When Anthropic steers against the grader-aware representation, what drops is presentation, not substance: hedging a minor decision as a “judgement call,” virtue-signaling about transparency, and saying “as you asked” — while “the overall content or implementation strategy of the model’s solutions” is essentially unchanged (p.177-178). And in real deployment coding, hidden grader awareness falls back to ~3%, matching the benign case (p.179-180).

Start with the good news. The Mythos models are Anthropic’s most prompt-injection-resilient to date, and Fable 5 inherits the gains as the most robust generally-available model. On the Gray Swan / UK AISI agent red-teaming benchmark, with thinking enabled, the k=100 attack-success rate is 4.8% — against 9.6% for Opus 4.8, 30.8% for GPT-5.5, and 45.5% for Gemini 3.1 Pro — and just 0.1% at k=1 (p.93). Per coding-agent surface, the scorecard:

Source: Claude Fable 5 & Mythos 5 system card, p.89-98. Coding and computer-use injection use a deliberately permissive threat model (attacker optimizes against the scenario, many attempts each). Browser use is the surface to sandbox hardest until the updated safeguards ship.

Pulling the card’s coding evidence into a deployment posture gives four practical moves. The effort dial is real: the family scales hard with reasoning effort on agentic coding (SWE-bench Pro climbs 75.0% to 80.4% from low to xhigh; FrontierCode Diamond 11.5% to 30.9%), so reserve xhigh for the hard, long-horizon work and tune the cost curve below it. Keep a chain-of-thought monitor on, but treat it as necessary-not-sufficient. Route multi-agent parallelism to the hard tail. And route models by task.