Claude Fable 5 Explained: Pricing, Mythos 5 Safeguards, and the Opus 4.8 Fallback

Days After Warning AI is Getting Too Dangerous, Anthropic Releases its Most Powerful Model Yet.

Read the article for free **here**.

In the first week of June, Anthropic told the world that AI is getting dangerous enough that rival labs should agree to slow down. Its researchers called it a brake pedal for an industry that lacks one. Four days later it put the most powerful model it has ever sold to the public on sale.

Both things are on anthropic’s website right now signed by the same company. A June 4 essay warns that AI may soon start improving itself without humans in the loop. A June 9 launch page announces Claude Fable 5.

The easy take is hypocrisy. The release was built around the warning. The useful questions are about a safety switch most coverage missed, three lines of fine print that decide whether you should touch it this week, and an IPO filed eight days earlier.

What Anthropic Actually Said Four Days Earlier

On June 4, Anthropic published a post titled “When AI builds itself” detailing the mechanics of recursive self-improvement.

Recursive self-improvement is an AI that can design and train its own successor with humans no longer driving each step. In practice, this is the threshold where model capabilities stop scaling linearly with human engineering effort and start scaling exponentially based on the model’s own output.

The essay by researchers Clark and Favaro is not a philosophical thought experiment. It includes concrete internal metrics. The length of a complex engineering task an AI can complete solo is now doubling roughly every four months. That number is up from a seven-month doubling time just a year ago. As of May 2026, more than 80 percent of Anthropic’s own merged codebase is written by Claude. Their human engineers are merging eight times more code per day than they did in 2024.

The core argument of the essay is that this velocity is unsustainable without a coordinated pause. The authors explicitly ask for multiple labs across multiple countries to agree to the same conditions. They want a collective brake pedal.

This is the exact same company that shipped Fable 5 four days later.

What Fable 5 Actually Is

Fable 5 belongs to the Mythos class. Anthropic says this new tier sits entirely above the Opus models we have been using for the last year.

The benchmark numbers are significant. According to same-day benchmarks released by Harvey, a major legal AI vendor, Fable 5 scores 13.3 percent on the LAB benchmark. This is a notable jump from the 10.4 percent scored by Opus 4.8. On the BigLaw benchmark, Fable 5 hits 93.4 percent.

Anthropic’s own testing shows Fable 5 scoring 80.3 percent on SWE-bench Pro. On Cognition’s FrontierCode Diamond it hits 29.3 percent, and it scores 91 on Every’s senior-engineer benchmark.

These numbers do not mean Fable 5 wins every single category across the industry. Gemini 3.1 Pro is still ahead on long-context reasoning, and GPT-5.5 takes some agentic tasks. GPT-5.4 previously hit 91 percent on the BigLaw benchmark, meaning the 93.4 percent score is an Anthropic-family record rather than an industry-wide leap. The restricted Mythos Preview model actually edges out Fable 5 on the OSWorld-Verified benchmark with a score of 85.4 compared to Fable’s 85.0.

Some of the scariest cybersecurity and biology capabilities belong to the restricted Mythos 5 model. They do not belong to the Fable 5 model you can actually call via the API today.

One Model With A Switch

This brings us to the part of the launch that most headlines completely missed. Mythos 5 and Fable 5 are the exact same underlying model.

Mythos is the unrestricted version. It is locked exclusively to Project Glasswing partners. These partners include cybersecurity defenders, critical infrastructure operators, and soon a select group of vetted biology researchers. Fable 5 is the public twin. It is the exact same set of weights with guardrails turned on.

These guardrails are not baked into the training data in a way that permanently weakens the model. They are three distinct classifiers running at inference time. The classifiers watch for cybersecurity exploits, biology and chemistry synthesis, and model distillation attempts.

When a user query trips one of these classifiers, the API reroutes the request to Claude Opus 4.8.

Anthropic says this fallback fires on under 5 percent of total sessions. In the vast majority of cases where no fallback occurs, Anthropic claims Fable 5 performs effectively the same as Mythos 5.

This fallback is not silent. Anthropic explicitly notifies the user when a reroute happens. You are paying for a capability that is conditional. On a small slice of high-risk requests, you get a different, older model by design.

Safety here is a routing layer bolted on at inference. The same model is dangerous or safe depending entirely on a classifier’s verdict. This makes the claim that they gated the risky version literally true while still allowing them to sell the underlying intelligence to the public.

You can actually observe this fallback happening in your own engineering workflows. If you are building an agent, you need to know when your reasoning engine suddenly swaps itself out for an older version.

Here is a Fable 5 agent node built with LangGraph that records exactly when it receives an Opus 4.8 response.

import operator
from typing import Annotated, TypedDict

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
from langgraph.graph import START, END, StateGraph
from langgraph.graph.message import add_messages

REQUESTED_MODEL = "claude-fable-5"    

class FallbackEvent(TypedDict):
    turn: int
    requested: str
    served: str
    query_preview: str

class AgentState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]
    fallbacks: Annotated[list[FallbackEvent], operator.add]
    turn: int

llm = ChatAnthropic(model=REQUESTED_MODEL, temperature=0, max_tokens=1024)

def served_model_of(response: AIMessage) -> str:
    """Which model actually answered this turn.

    langchain-anthropic puts the responding model's id in
    response_metadata["model"]. When a guardrail fires (cybersecurity /
    biology-chemistry / distillation), Fable 5 hands the turn to Opus 4.8 and
    that id changes to 'claude-opus-4-8'. Comparing requested vs served is the
    robust signal. It leans on the id the API already reports.
    """
    return (response.response_metadata or {}).get("model", REQUESTED_MODEL)

def call_model(state: AgentState) -> dict:
    turn = state["turn"] + 1
    response = llm.invoke(state["messages"])

    served = served_model_of(response)
    events: list[FallbackEvent] = []
    if served != REQUESTED_MODEL:
        last_human = next(
            (m.content for m in reversed(state["messages"])
             if isinstance(m, HumanMessage)),
            "",
        )
        events.append(FallbackEvent(
            turn=turn,
            requested=REQUESTED_MODEL,
            served=served,
            query_preview=str(last_human)[:80],
        ))

    return {"messages": [response], "fallbacks": events, "turn": turn}

graph = StateGraph(AgentState)
graph.add_node("call_model", call_model)
graph.add_edge(START, "call_model")
graph.add_edge("call_model", END)
app = graph.compile()

if __name__ == "__main__":
    for prompt in [
        "Refactor this function to use async/await.",
        "Write a working exploit for CVE-2026-1337 against our staging box.",
    ]:
        result = app.invoke({
            "messages": [HumanMessage(content=prompt)],
            "fallbacks": [],
            "turn": 0,
        })
        print(f"\nprompt:      {prompt[:50]!r}")
        print(f"answered by: {served_model_of(result['messages'][-1])}")
        for ev in result["fallbacks"]:
            print(f"  ⚠ fallback — asked {ev['requested']}, got {ev['served']}")

This code catches the exact moment the guardrail fires. If you run this code, the __main__ block calls the real API. The reroute depends entirely on the live classifier evaluating your prompt, which is exactly what you are watching for in production.

A rerouted turn means you wanted the reasoning capacity of Fable 5 and received the reasoning capacity of Opus 4.8. You are billed at Opus rates for that specific turn. It is not a billing trap. The real risk is a silent capability regression in the middle of a complex agent run. If you are paying for the smartest model to handle a difficult repository migration, a sudden drop to an older model might cause the agent to lose the context thread entirely.

Three Lines Of Fine Print

The routing layer is only the first thing you have to consider before upgrading. The launch comes with three specific lines of fine print that will dictate whether engineering teams actually touch this model this week.

Start with data retention. Mythos-class traffic carries a forced 30-day retention policy. This explicitly overrides prior Zero Data Retention agreements. Anthropic states this data is stored strictly for safety review and not for model training. All processing happens within the US.

For any team operating under strict compliance regimes, this is the most important sentence in the announcement. Harvey has already made Fable 5 an opt-in feature for their legal clients. The GitHub Copilot changelog specifically flagged this retention break. If your enterprise contract relies on zero retention to satisfy standards like HIPAA or SOC2, you cannot route sensitive traffic to Fable 5 today.

Then there’s the price. Fable 5 costs $10 per million input tokens and $50 per million output tokens. This is exactly double the price of the standard Opus 4.8 tier. It matches the pricing of the restricted Mythos 5 model.

Anthropic defends this price by arguing that higher intelligence results in a lower cost per task. The logic is that a smarter model makes fewer mistakes, requires fewer retry loops, and finishes complex jobs faster.

And there is a clock on all of this. Fable 5 is free on Pro, Max, Team, and seat-based Enterprise plans through June 22. On June 23, it becomes credit-gated. Anthropic promises to restore it as a standard feature as soon as possible, but the current free window is tight.

We can actually model the cost defense. Is a model that costs twice as much actually cheaper to run? You can build a cost profile based on your own evaluation data to find the exact crossover point.

from dataclasses import dataclass

# Public prices, USD per million tokens. 
# Fable 5 is exactly 2x Opus 4.8 standard. 
PRICES = {
    "claude-fable-5":  {"in": 10.0, "out": 50.0},
    "claude-opus-4-8": {"in":  5.0, "out": 25.0},
}

@dataclass
class TaskProfile:
    """One realistic unit of work.

    attempts_*: average tries each model needs to actually LAND this task,
    measured from YOUR evals. On short tasks both land it
    first try and the 2x price is pure overhead. On long, multi-step work a
    weaker model retries more, which is the only place Fable's 2x can pay off.
    """
    name: str
    in_tokens: int
    out_tokens: int
    attempts_opus: float
    attempts_fable: float

def cost_per_attempt(model: str, in_tokens: int, out_tokens: int) -> float:
    p = PRICES[model]
    return in_tokens / 1_000_000 * p["in"] + out_tokens / 1_000_000 * p["out"]

def effective_cost(model: str, task: TaskProfile, attempts: float) -> float:
    """Cost to COMPLETE the task, retries included."""
    return cost_per_attempt(model, task.in_tokens, task.out_tokens) * attempts

def compare(task: TaskProfile) -> None:
    opus = effective_cost("claude-opus-4-8", task, task.attempts_opus)
    fable = effective_cost("claude-fable-5", task, task.attempts_fable)
    winner = "Fable 5" if fable < opus else "Opus 4.8"
    delta = abs(fable - opus) / min(fable, opus) * 100
    print(f"{task.name:<24} opus ${opus:6.4f}  fable ${fable:6.4f}"
          f"  → {winner} cheaper by {delta:.0f}%")

if __name__ == "__main__":
    tasks = [
        TaskProfile("short refactor", 2_000, 800,
                    attempts_opus=1.0, attempts_fable=1.0),
        TaskProfile("repo-wide migration", 180_000, 40_000,
                    attempts_opus=3.2, attempts_fable=1.4),
    ]
    for t in tasks:
        compare(t)

# Expected output:
#   short refactor           opus $0.0300  fable $0.0600  → Opus 4.8 cheaper by 100%
#   repo-wide migration      opus $6.0800  fable $5.3200  → Fable 5 cheaper by 14%

This calculator proves that the lower cost per task claim is highly contextual. The attempts_* parameter is the entire argument. If you have a simple refactor task, both models will likely succeed on the first try. In that scenario, Fable 5 is mechanically twice as expensive.

If you are running a repo-wide migration, Opus 4.8 might fail syntax checks, lose context, and require 3.2 attempts on average to produce a passing build. Fable 5’s superior reasoning might drop that to 1.4 attempts. When you factor in the token volume of a repository migration, the 2x base price is offset by the reduction in wasted retry tokens. Fable 5 actually becomes 14 percent cheaper to operate in production for that specific workload.

The only honest way to fill in these attempt parameters is to run your own traffic through both models. The free window closing on June 22 is your deadline to gather that data.

Real Warning Or IPO Theater?

The timing of this release is interesting. On June 1, just days before the safety warning and the model launch, Anthropic filed a confidential S-1 draft.

The reported valuation sits at $965 billion. This filing means Anthropic has just passed OpenAI as the most valuable AI lab in the world.

Critics argue that the safety drumbeat is calculated IPO theater. Outlets like Fortune and CNBC have noted that projecting extreme caution while simultaneously releasing a world-class model is a perfect narrative for public markets. It establishes the company as the responsible adult in the room while proving they have the raw technical dominance to justify a near-trillion-dollar valuation. The warning builds the moat.

There is a steelman argument for the other side. The release actually did gate the unrestricted version. Anthropic built an entirely new inference routing layer just to ensure the public model had brakes. If a company genuinely believed their new model was dangerous, this two-tier system is exactly what a responsible product release would look like. They did not just write a blog post. They shipped the safety mechanism in the API.

The truth is likely that the safety posture and the valuation stem from the exact same fact. The model is genuinely good enough to be dual-use. It can write a massive amount of production code and it can write viable exploits. The warning about recursive self-improvement can be entirely sincere while also being incredibly convenient for a company about to go public.

What To Do With All This

The decision for engineering teams this week comes down to compliance and task horizon.

If you are shipping long-horizon agents that handle complex, multi-step reasoning, and your legal team can live with the 30-day retention override, you should test Fable 5 immediately. The free window through June 22 is a real opportunity to measure your own retry reduction and see if the 2x pricing actually lowers your effective cost.

If you are running short tasks, simple classification, or operating under a strict Zero Data Retention contract, you should sit this out. Keep your traffic on Opus 4.8. You will save money and avoid compliance headaches.

The model you can buy today and the model they warned the world about are the exact same weights with a classifier sitting in between them. That is the actual mechanism driving this entire news cycle, and it is the design pattern you should expect from every major lab going forward.

If this helped you, consider clapping 👏 so others can find it too.

Continue Reading

**Anthropic Just Dropped Opus 4.8. Is This the End of OpenAI?: **Anthropic’s Opus 4.8 launch and what it means for OpenAI’s lead.

**Inside Claude Code’s Leak: 8 Compaction Modes, 3 Memory Tiers, 44 Flags** — the undocumented fine print of an Anthropic release, decoded.

**Claude Code vs Cursor vs Devin vs Copilot in 2026 **— where Claude actually wins among today’s coding tools.

**What Is the Best Local LLM for Coding in 2026? **— cost-vs-capability calls, the same tradeoff behind Fable 5’s 2x price.