Claude (Anthropic): Fable, Opus, Sonnet, Mythos — Agents, Safety and Production Engineering
Anthropic's 2026 Claude portfolio spans four capability tiers: Claude Fable 5 (highest generally available capability), Claude Opus 5 (released 24 July 2026, near-Fable capability at lower cost), Claude Sonnet 5 (released 30 June 2026, an agentic execution model tuned for tools and automation), and Claude Mythos 5 (a restricted model for selected cybersecurity, biology and healthcare research partners). Like every model in this section, Claude is closed: no weights, no architecture disclosure beyond high-level research posts and system cards.
How to read this guide
| Part | Sections | Focus |
|---|---|---|
| A · Identity | 1–2 | Closed model, tier lineup, positioning |
| B · Study map | 3 | Priorities for engineers |
| C · Architecture | 4 | Constitutional AI, hybrid reasoning, effort settings |
| D · Evaluation | 5 | System cards, safety classifiers, responsible scaling |
| E · Production | 6–7 | API patterns, MCP, computer use, caching, cost |
| F · Assessment | 8–Conclusion | Checklist, reading list, takeaways |
Introduction
Anthropic positions Claude as a safety-first, agent-capable model family. Every public artefact — research posts, system cards, the Constitutional AI paper, "Building effective agents" guidance — reinforces a consistent story: capability and safety are trained together, not bolted on afterward. For an AI engineer, the practical consequence is that Claude's behaviour under agentic autonomy, tool use and long-horizon execution is a first-class design concern documented by the vendor, not an incidental side effect to be discovered in production.
As with every closed model, the ceiling on what can be studied is the vendor's own disclosure: system cards, high-level architecture descriptions ("hybrid reasoning", "effort settings"), and API documentation. Parameter counts, exact layer structure and full training data composition are not published for Fable 5, Opus 5 or Sonnet 5.
1. What kind of model is Claude?
1.1 Closed, API and platform-only
Claude is accessed through Anthropic's API, Claude.ai, Claude Code, and cloud marketplace integrations (AWS Bedrock, Google Cloud Vertex AI, Microsoft Foundry). There is no open-weight Claude release and no officially supported self-hosting path.
1.2 Constitutional AI as the safety foundation
Anthropic's foundational safety method, Constitutional AI (arXiv:2212.08073), trains the model to critique and revise its own outputs against a written set of principles, reducing reliance on large volumes of human-labelled harmful/harmless comparisons. This is the conceptual ancestor of the safety behaviour visible across the entire 2026 Claude lineup — refusal patterns, self-correction, and the classifiers layered around Opus 5 and Sonnet 5.
1.3 Hybrid reasoning
Claude models operate with hybrid reasoning: a single model that can respond quickly for straightforward requests or engage extended, visible reasoning for harder ones, controlled by an effort setting rather than requiring a separate "reasoning model" product line. This differs in framing from OpenAI's tiered-router approach, though both ultimately expose an adjustable reasoning/effort control to the caller.
1.4 Agentic by design
Claude Sonnet 5 in particular is explicitly positioned as an agentic execution model: built for tool use, browser and terminal interaction, and multi-step planning, with Anthropic publishing dedicated engineering guidance ("Building effective agents") on how to structure agent loops around it. Claude Code — Anthropic's own coding agent product — is a reference implementation of these patterns.
2. Family lineup and tiers
| Model | Released | Position | Notable pricing signal | Best fit |
|---|---|---|---|---|
| Claude Fable 5 | GA (highest tier) | Frontier coding, knowledge work, vision, science, long-horizon agents | Premium, flagship pricing | Maximum capability where cost is secondary |
| Claude Opus 5 | 24 Jul 2026 | Near-Fable capability at lower cost; strong coding/debugging and knowledge work | $5 / $25 per MTok (input/output) | Serious professional and coding work at better unit economics than Fable |
| Claude Sonnet 5 | 30 Jun 2026 | Agentic execution: tools, browsers, terminals, automation, enterprise throughput | Introductory $2 / $10 per MTok, moving to $3 / $15 | High-throughput agentic and automation workloads |
| Claude Mythos 5 | Restricted | Selected cybersecurity, biology and healthcare research partners only | Not generally available | Not a normal deployment option — partner-gated research use |
2.1 Claude Opus 5 specifics
Anthropic describes Opus 5 as delivering strength close to Fable 5 for coding and knowledge work at a materially lower cost. Notable production-relevant features:
- Effort settings — an adjustable reasoning-depth control, similar in purpose to GPT-5.6's reasoning effort.
- Fast mode — roughly 2.5× faster generation at roughly 2× the price, for latency-sensitive workloads willing to pay a premium for speed rather than for additional reasoning depth.
- Cyber classifiers — safety classifiers specifically tuned to detect and constrain cyber-offensive tool use.
- Biology routing — requests that touch sensitive biological content are routed through additional safety handling before a response is produced.
2.2 Claude Sonnet 5 specifics
- Explicitly agentic: tuned for plans, tools, browser use and terminal interaction.
- Exposes effort levels analogous to Opus 5's, letting callers trade latency/cost for reasoning depth on a per-request basis.
- Ships with an updated tokenizer relative to prior Sonnet generations, producing roughly 1.0–1.35× as many tokens for equivalent text depending on content type and language — a detail that directly affects cost estimation and context-window budgeting when migrating from older Sonnet versions.
2.3 Claude Mythos 5 and the restricted-access pattern
Mythos 5 illustrates a distinct closed-model governance pattern: rather than gating a capability behind a refusal at inference time, Anthropic gates access to the model itself to a small set of vetted partners in cybersecurity, biology and healthcare research. Engineers evaluating "what Claude can do" should not assume Mythos-level capability is available through the standard API — Fable 5 is the practical capability ceiling for general customers.
2.4 Choosing a tier
| Signal | Lean toward |
|---|---|
| Maximum capability, cost secondary | Fable 5 |
| Strong coding/debugging at better unit economics than Fable | Opus 5 |
| Latency-critical, willing to pay a premium for speed | Opus 5 Fast mode |
| High-throughput agents, tool use, automation at scale | Sonnet 5 |
| Restricted research domains (cyber, bio, healthcare) with partner vetting | Mythos 5 (by application only) |
3. What an AI engineer should study
- Constitutional AI and its production echo — how principle-based self-critique shows up as refusal, self-correction and hedging behaviour in real traffic.
- Hybrid reasoning and effort settings — how to tune Opus 5 and Sonnet 5 effort levels per endpoint, and how Fast mode changes the latency/cost/quality trade-off.
- Agentic patterns — Anthropic's "Building effective agents" guidance: when to use a single agent with tools versus an orchestrator-worker pattern.
- Model Context Protocol (MCP) — the open protocol Anthropic introduced for connecting models to external tools and data sources in a standardised way.
- Computer use — Claude's ability to operate a graphical interface (mouse, keyboard, screenshots) as a tool-use modality, and the operational risks this introduces.
- Prompt caching — Anthropic's mechanism for reusing processed prefixes across requests, and how it interacts with system prompts, tool definitions and long context.
- Interpretability research — Anthropic publishes some of the most active interpretability work in the industry; understanding its findings (features, circuits, mechanistic transparency) informs realistic expectations about explainability, even though it does not translate into weight access.
- Safety frameworks — Anthropic's responsible scaling commitments and system-card safety evaluations, including cyber classifiers and biology routing.
- Claude Code — as a reference agent harness, useful for understanding how Anthropic itself structures long-running coding agent sessions around its own models.
4. Architecture and system design (as publicly disclosed)
This section is limited to what Anthropic has publicly described. Parameter counts, layer counts, attention mechanism details and full training data composition for Fable 5, Opus 5, Sonnet 5 and Mythos 5 are not published.
4.1 Constitutional AI
Constitutional AI (arXiv:2212.08073) trains a model in two broad phases: supervised learning, where the model critiques and revises its own responses against a written constitution of principles, and reinforcement learning, where an AI-generated preference signal (rather than exclusively human labels) is used to train a preference model that then guides further training. The claimed benefit is a more scalable and more transparent alignment process, since the governing principles are legible text rather than implicit patterns in a large human-labelled dataset.
4.2 Hybrid reasoning
Rather than a strictly separate "reasoning model" line, Anthropic describes Claude's current generation as hybrid reasoning systems: a single model capable of near-instant responses for simple requests and extended, visible chain-of-thought-style reasoning for harder ones, selected via an effort parameter rather than a different model checkpoint. This differs architecturally in framing from OpenAI's routed fast/deep-model system, though the externally observable trade-off (latency and cost versus reasoning depth) is similar.
4.3 Effort settings and Fast mode
Effort settings on Opus 5 and Sonnet 5 let a caller request shallower or deeper reasoning per request. Opus 5's Fast mode is a distinct axis: roughly 2.5× faster output at roughly 2× the price — optimising for wall-clock latency rather than reasoning depth, useful for latency-bound interactive applications where the task itself does not require maximum deliberation.
4.4 Safety-specific architecture: classifiers and routing
Anthropic layers dedicated classifiers around the core model rather than relying solely on the base model's trained refusal behaviour:
- Cyber classifiers on Opus 5 detect and constrain requests and tool sequences associated with cyber-offensive activity.
- Biology routing detects sensitive biological content and routes it through additional safety handling before response generation completes.
These layers add a safety-processing step to the request lifecycle, which is a source of latency and occasional false-positive refusals that engineers must design around (clear error surfaces, appeal/escalation paths, avoiding automatic retries that resend the same content unchanged).
4.5 Model Context Protocol (MCP)
MCP is an open protocol, originated by Anthropic, standardising how models connect to external tools, data sources and services — analogous in spirit to a universal adapter layer for agent tool use, intended to reduce the N×M integration problem between models and tools. It is not Claude-specific in principle (other vendors have adopted MCP-compatible tooling), but Anthropic's own documentation and Claude Code are the primary reference implementation.
4.6 Computer use
Computer use lets Claude operate a computer's graphical interface directly — interpreting screenshots and issuing mouse/keyboard actions — as an alternative to purpose-built API integrations for legacy or GUI-only systems. This is architecturally a specialised tool-use modality (screenshot-in, action-out) rather than a change to the core language model, but it carries distinct operational risk (irreversible UI actions, unintended clicks) that must be mitigated at the harness level.
5. Evaluation and system cards
5.1 System cards as primary disclosure
Anthropic publishes system cards accompanying major releases (Opus 5, Sonnet 5), covering capability evaluations, safety evaluations, red-teaming summaries and known limitations — the same category of artefact as OpenAI's system cards, though methodology and categories differ by vendor.
5.2 Responsible scaling and capability thresholds
Anthropic's responsible-scaling framework defines capability thresholds (analogous in purpose to OpenAI's Preparedness Framework) that trigger additional safety measures or access restrictions as models cross defined risk levels. Mythos 5's restricted-access model is the clearest visible consequence of this framework: rather than releasing a maximally capable model broadly and relying entirely on inference-time refusals, Anthropic restricts access to vetted partners for certain domains.
5.3 Cyber and biology-specific evaluation
Given Opus 5's cyber classifiers and biology routing, expect system-card content specifically addressing:
- Offensive cybersecurity uplift testing (e.g., exploit generation, vulnerability discovery assistance).
- Biological and chemical uplift testing, informing the biology-routing thresholds.
5.4 Model-level vs system-level evaluation
As with every closed model in this landscape, a published Claude benchmark score reflects the model plus its safety layers plus its default effort setting at a point in time. Effort level, Fast mode, and classifier intervention can all change measured behaviour independently of the underlying model's raw capability — control for these explicitly when comparing tiers or replicating vendor-published numbers.
5.5 What remains unverifiable externally
Constitutional AI's self-critique process, the composition of the AI-generated preference data, and the exact behaviour of cyber/biology classifiers are described at a conceptual level but are not independently auditable without weight or training-data access. Treat vendor safety claims as informative, not as a substitute for your own red-teaming of your specific use case.
6. Production engineering: API patterns
6.1 Basic request with effort setting
from __future__ import annotations
import os
import anthropic
api_key = os.environ.get("ANTHROPIC_API_KEY")
if not api_key:
raise RuntimeError("ANTHROPIC_API_KEY is not configured.")
client = anthropic.Anthropic(api_key=api_key)
response = client.messages.create(
model="claude-opus-5",
max_tokens=2048,
effort="medium",
messages=[
{
"role": "user",
"content": "Identify the root cause of intermittent 502 errors in this trace.",
}
],
)
print(response.content[0].text)
6.2 Prompt caching
response = client.messages.create(
model="claude-sonnet-5",
max_tokens=1024,
system=[
{
"type": "text",
"text": large_repository_summary,
"cache_control": {"type": "ephemeral"},
}
],
messages=[
{"role": "user", "content": "List the three riskiest modules to refactor."}
],
)
Marking stable, reused content (repository summaries, tool definitions, long system instructions) with cache control avoids reprocessing the same prefix on every turn of a long agent session. As with any prefix-caching system, place volatile content (the latest user message) after the cached block, never before it.
6.3 Tool calling
tools = [
{
"name": "run_tests",
"description": "Run the project's test suite and return pass/fail counts.",
"input_schema": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Test directory to run."}
},
"required": ["path"],
},
}
]
response = client.messages.create(
model="claude-sonnet-5",
max_tokens=1024,
tools=tools,
messages=[{"role": "user", "content": "Run the tests in tests/unit and summarise failures."}],
)
for block in response.content:
if block.type == "tool_use":
validated_path = validate_and_authorise_path(block.input["path"])
tool_result = run_tests(validated_path)
Never execute a tool call before validating its arguments against an allowlist and authorisation policy — this applies equally to Claude, GPT-5.6 and every other tool-calling model in this section.
6.4 Model Context Protocol integration
# Conceptual MCP client wiring — actual transport depends on the MCP SDK version.
from mcp_client import connect_to_server
server_connection = connect_to_server(server_url="stdio://internal-repo-tools")
available_tools = server_connection.list_tools()
response = client.messages.create(
model="claude-opus-5",
max_tokens=2048,
tools=available_tools,
messages=[{"role": "user", "content": "Summarise open pull requests older than 7 days."}],
)
MCP's value is standardising the tool-discovery and tool-invocation contract so the same server can serve multiple model vendors and multiple internal agents without bespoke integration code per pairing.
6.5 Computer use
response = client.messages.create(
model="claude-opus-5",
max_tokens=1024,
tools=[
{
"type": "computer_20250124",
"name": "computer",
"display_width_px": 1280,
"display_height_px": 800,
}
],
messages=[
{"role": "user", "content": "Open the settings panel and enable dark mode."}
],
)
Computer-use sessions should run inside an isolated, disposable environment (sandboxed VM or container with a virtual display) with no access to production credentials, and should require human approval before any action with irreversible or financial consequences.
6.6 Fast mode for latency-critical paths
response = client.messages.create(
model="claude-opus-5",
max_tokens=512,
effort="low",
speed="fast",
messages=[{"role": "user", "content": "Classify this ticket as billing, technical or account."}],
)
Reserve Fast mode for tasks where wall-clock latency dominates the user experience and the task does not require maximum reasoning depth — paying roughly 2× for roughly 2.5× the speed is a good trade for interactive classification and short-form generation, and a poor trade for complex multi-step debugging.
7. Latency, cost and reliability engineering
7.1 Effort and Fast mode combined
| Configuration | Fit | Cost/latency profile |
|---|---|---|
| Low effort, standard speed | Simple extraction, classification | Lowest cost |
| Medium effort, standard speed | General assistant and coding tasks | Balanced default |
| High effort, standard speed | Complex debugging, multi-step planning | Higher cost, higher latency |
| Low/medium effort, Fast mode | Latency-critical interactive UX | ~2× cost, ~2.5× speed |
7.2 Tokenizer migration cost
Sonnet 5's updated tokenizer can produce 1.0–1.35× as many tokens as prior Sonnet generations for equivalent input. When migrating existing prompts and context budgets from an older Sonnet model, re-measure actual token counts rather than reusing old estimates — context-window headroom and per-request cost projections both shift.
7.3 Handling safety-layer false positives
Cyber classifiers and biology routing can occasionally flag legitimate requests (e.g., a security engineer asking about a known CVE for patching purposes). Design for this explicitly:
- Surface a clear, distinguishable error/refusal state rather than a generic failure.
- Provide a human escalation path for legitimate professional use cases that are incorrectly blocked.
- Avoid blind automated retries of an unchanged prompt against a safety refusal — it will not succeed and wastes cost.
7.4 Reliability patterns
- Apply exponential backoff with jitter on rate limits and transient errors.
- Set per-endpoint effort/Fast-mode defaults deliberately; do not let every endpoint default to maximum effort, which inflates both cost and latency without proportional quality gain for simple tasks.
- For agentic sessions using MCP or computer use, checkpoint state regularly so a mid-session failure does not require restarting the entire task from scratch.
7.5 Observability
Track per endpoint: effort level used, Fast-mode usage, cache-hit rate, tool-call success/retry rate, classifier-refusal rate, and end-to-end task completion rate (not just per-turn success) for agentic workflows.
8. Engineering assessment checklist
Claude engineering assessment
- Confirmed no self-hosting path exists; Claude access depends on Anthropic's API or an authorised cloud marketplace (Bedrock, Vertex AI, Foundry)
- Tier selected per endpoint (Fable 5 / Opus 5 / Sonnet 5) based on measured cost/capability trade-offs, not assumption
- Effort setting tuned per endpoint; Fast mode reserved for genuinely latency-critical, low-complexity tasks
- Tokenizer change accounted for when migrating from older Sonnet/Claude versions (re-measured token counts, not reused estimates)
- Prompt caching applied to stable prefixes (system prompts, tool definitions, repository context) with volatile content placed last
- Tool calls validated, authorised and sandboxed before execution — including MCP-sourced tools and computer-use actions
- Computer-use sessions run in isolated, disposable environments with human approval for irreversible actions
- Safety-layer false-positive handling designed explicitly (clear refusal states, human escalation, no blind retries)
- Own golden evaluation set maintained independent of vendor-published benchmark claims
- Mythos 5 correctly excluded from capability assumptions unless your organisation is a vetted research partner
- Agentic session checkpointing implemented so mid-task failures do not require full restarts
- Data-retention, residency and cloud-marketplace terms reviewed against regulatory requirements
Essential reading
- Anthropic, Claude Opus 5 release post
- Anthropic, Claude Sonnet 5 release post
- Anthropic, Claude model documentation
- Anthropic, research publications index
- Anthropic, system cards for Opus 5 and Sonnet 5
- Bai et al., Constitutional AI: Harmlessness from AI Feedback, arXiv:2212.08073
- Anthropic, "Building effective agents"
- Model Context Protocol specification and documentation
- Anthropic, Claude Code documentation
Conclusion
Claude's 2026 lineup is defined less by a single flagship number and more by a deliberate, published safety and agent-design philosophy: Constitutional AI as the alignment foundation, hybrid reasoning with effort controls instead of separate reasoning-model lines, dedicated classifiers for cyber and biology risk, and a restricted-access tier (Mythos 5) for the highest-risk research domains. Opus 5 and Sonnet 5 give engineers a genuine cost/capability choice — near-Fable coding strength at lower cost, or a throughput-oriented agentic execution model — while MCP and computer use extend the tool-use surface beyond conventional function calling.
Correct interpretation: Claude should be evaluated as a safety-engineered agent platform with tunable effort and speed, not compared purely on a single leaderboard score detached from effort setting, Fast mode and classifier behaviour.
Discussion
Comments
Share feedback or questions about this page. No account required.
Loading comments…