28  Claude Models Explained: Choosing the Best Model

Originally published July 24, 2026.

28.1 The Model Selection Problem

By mid-2026, the Claude model lineup had grown to include multiple classes — Mythos, Fable, Opus, Sonnet, and Haiku — each with different effort levels, pricing, and performance characteristics. For developers, this created a new kind of decision paralysis. Which model do you choose for a given task? Does it matter? Is the cheapest model good enough? Is the most expensive model worth it?

This chapter provides Anthropic’s official guidance on model selection, based on the patterns observed across millions of production requests.

28.2 The Core Principle

Tip

Start with the most intelligent model. Use the effort level to dial performance and cost. Cost-per-task is often lower for smarter models because they solve problems in fewer iterations.

This is counterintuitive. The instinct is to start with the cheapest model and upgrade if quality isn’t good enough. But production data tells a different story: smarter models often cost less per task because:

  1. Fewer iterations: A smarter model gets the right answer in one attempt, while a cheaper model might need 3-5 retries
  2. Less context needed: Smarter models extract more value from the same context, reducing the need for elaborate prompting
  3. Fewer errors: Mistakes are expensive — a wrong answer that propagates downstream costs more than a higher upfront model cost
  4. Better tool use: Smarter models call tools more efficiently, reducing API calls and compute time

28.3 Model Classes

Claude’s model lineup is organized into classes, each optimized for different use cases.

Class Models Positioning Best For
Mythos Mythos 5 Frontier, most capable Hardest problems, novel research
Fable Fable 5 Frontier, most capable Ambitious rewrites, exploration
Opus Opus 4.6, Opus 4.7 Reasoning-intensive enterprise Complex analysis, production agents
Sonnet Sonnet 4.6, Sonnet 5 Versatile everyday General-purpose tasks, code generation
Haiku Haiku 4.6 Fastest, lowest cost Classification, simple extraction

28.3.1 Mythos / Fable — Frontier Models

The frontier models are Anthropic’s most capable. They handle the hardest problems: novel reasoning, complex multi-step planning, and tasks that require creative problem-solving. They’re also the most expensive.

Use frontier models when:

  • The problem is unlike anything you’ve solved before
  • The cost of being wrong is very high
  • You need creative, out-of-the-box solutions
  • You’re exploring a new domain or approach

28.3.2 Opus — Reasoning-Intensive Enterprise

Opus is the workhorse for complex, production-grade applications. It balances deep reasoning with practical cost and speed. If you’re building a production agent that needs to handle a wide variety of tasks reliably, Opus is likely the right choice.

Use Opus when:

  • You need reliable, high-quality reasoning at scale
  • The task is complex but well-defined
  • You’re building production agents
  • Cost matters but quality matters more

28.3.3 Sonnet — Versatile Everyday

Sonnet is the everyday model — good at almost everything, fast enough for interactive use, and affordable enough for high-volume applications. For many teams, Sonnet is the default model, with Opus or Fable used only for particularly challenging tasks.

Use Sonnet when:

  • You need good quality at reasonable cost
  • The task is well-understood
  • You have high request volume
  • You’re doing general-purpose coding, writing, or analysis

28.3.4 Haiku — Fastest and Lowest Cost

Haiku is optimized for speed and cost. It’s not as capable as the larger models, but for simple, well-defined tasks, it’s more than sufficient — and dramatically cheaper.

Use Haiku when:

  • The task is simple and well-defined
  • You need very low latency
  • You’re processing high volumes
  • The cost per task is critical
# Example: Using different models for different parts of a pipeline

# Haiku for initial classification (fast, cheap)
category = haiku.classify(ticket.text)

# Sonnet for response drafting (balanced)
response = sonnet.draft_response(ticket, category)

# Opus for quality review (thorough)
reviewed = opus.review(response, quality_standards)

28.4 The Effort Dimension

Within each model class, effort level lets you control how much reasoning the model does before responding. Higher effort means more internal reasoning steps, which improves quality but increases latency and cost.

Effort Level Behavior When to Use
Low Fast, direct responses Simple tasks, quick lookups
Medium Balanced reasoning Most everyday tasks
High Deep reasoning, multiple steps Complex problems, important decisions
Max Maximum reasoning effort Hardest problems, novel challenges 
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Higher budget = more reasoning
    },
    messages=[{"role": "user", "content": complex_question}],
)
Note

Effort level is the primary lever for cost optimization. For most tasks, starting with a smart model at medium effort and increasing effort only when quality isn’t sufficient is more cost-effective than starting with a cheaper model at high effort.

28.5 The Advisor Strategy

One of the most effective patterns for cost optimization is the advisor strategy: use a cheaper model as the primary worker, with an intelligent model as an advisor that reviews and guides.

28.5.1 How It Works

┌──────────────────────────────────────────┐
│  Worker (Sonnet 5)                       │
│  Handles the bulk of the work            │
│  Fast, affordable, good quality          │
└──────────────┬───────────────────────────┘
               │
               │ Periodically sends work
               │ to advisor for review
               ▼
┌──────────────────────────────────────────┐
│  Advisor (Fable 5)                       │
│  Reviews worker's output                 │
│  Identifies issues, suggests improvements│
│  Only invoked on key decisions           │
└──────────────────────────────────────────┘

28.5.2 The Numbers

The advisor strategy can achieve performance within 10% of using the frontier model alone, at a fraction of the cost:

Configuration Quality (vs. Fable 5 alone) Cost (vs. Fable 5 alone)
Fable 5 alone 100% 100%
Sonnet 5 alone ~75% ~25%
Sonnet 5 + Fable 5 advisor ~90% ~37%

This means you get 90% of the quality for 37% of the cost — a dramatic improvement in price-performance.

28.5.3 Implementation

# Worker handles the task
draft = sonnet.generate(task, context)

# Advisor reviews key decisions
if is_critical_decision(draft):
    review = fable.review(
        draft,
        criteria=["correctness", "completeness", "safety"],
    )
    if review.needs_revision:
        draft = sonnet.revise(draft, review.feedback)

# Final output
return draft

The key is deciding when to invoke the advisor. Invoking it on every step is too expensive. Invoking it only on the final output might miss issues introduced early. The best practice is to invoke the advisor at critical decision points — architecture decisions, security-sensitive operations, and final review.

28.6 Benchmark Saturation and Custom Evals

Here’s a uncomfortable truth about 2026 model benchmarks: the top models have largely saturated them.

Benchmark What It Tests Top Score Saturation
MMLU General knowledge 92%+ Saturated
HumanEval Code generation 95%+ Saturated
GSM8K Math reasoning 97%+ Saturated
GPQA Graduate-level QA 85%+ Near saturation

When every top model scores above 90% on a benchmark, that benchmark no longer helps you choose between them. The differences that matter — the differences that affect your specific application — aren’t captured by general benchmarks.

28.6.1 The Solution: Custom Evaluations

The only reliable way to choose between models for your specific use case is to build custom evaluations that reflect your actual tasks.

# Build an evaluation set from your actual tasks
eval_cases = [
    {
        "input": "Parse this invoice and extract line items",
        "input_data": invoice_pdf,
        "expected": {
            "line_items": [...],
            "total": 1234.56,
            "vendor": "Acme Corp",
        },
        "grading": "exact_match + fuzzy_fields",
    },
    # ... 100+ cases representing your real workload
]

# Run each model on the eval set
for model in ["sonnet-5", "opus-4-7", "fable-5"]:
    results = run_eval(model, eval_cases)
    print(f"{model}: {results.accuracy} accuracy, "
          f"${results.avg_cost} avg cost, "
          f"{results.avg_latency}s avg latency")

28.6.2 What Custom Evals Should Measure

A good custom evaluation measures:

  1. Accuracy: Does the model produce correct results?
  2. Consistency: Does it produce the same quality across different inputs?
  3. Cost: What’s the average cost per task?
  4. Latency: How long does each task take?
  5. Robustness: How does it handle edge cases and malformed input?
  6. Tool use: Does it call the right tools at the right times?
Tip

Aim for at least 100 evaluation cases that represent the real distribution of your tasks. Include easy cases, hard cases, edge cases, and failure cases. A small, well-curated eval set is more valuable than a large, generic one.

28.7 Decision Framework

Here’s a practical decision tree for choosing a model:

1. Is this a novel, exploratory, or extremely complex task?
   → Yes: Use Fable 5 or Mythos 5
   → No: Continue

2. Is this a production application with high volume?
   → Yes: Continue
   → No: Use Opus (quality first, optimize later)

3. Is the task well-defined and consistent?
   → Yes: Continue
   → No: Use Opus (handles variety better)

4. Is cost the primary concern?
   → Yes: Try Haiku first, upgrade if quality insufficient
   → No: Use Sonnet as default

5. Still unsure?
   → Run a custom eval comparing your top 2-3 candidates

28.8 Pricing Reference

Model Input (\(/M tokens) | Output (\)/M tokens) Best Value For
Haiku 4.6 $0.25 $1.25 High-volume simple tasks
Sonnet 4.6 $3 $15 General-purpose work
Sonnet 5 $3 $15 Advanced everyday tasks
Opus 4.6 $5 $25 Production agents
Opus 4.7 $5 $25 Complex reasoning
Fable 5 $15 $75 Frontier capabilities
Mythos 5 $15 $75 Maximum capability
Note

Remember: model cost is only one factor. The total cost of a task includes retries, error handling, downstream propagation of mistakes, and engineering time. A cheaper model that requires more retries or produces more errors may cost more in total.

28.9 Common Patterns

28.9.1 The Default + Escalation Pattern

Start with Sonnet for most tasks. If quality is insufficient, escalate to Opus. If still insufficient, escalate to Fable.

def generate_response(task):
    # Try Sonnet first
    result = sonnet.generate(task)
    if quality_check(result) >= threshold:
        return result

    # Escalate to Opus
    result = opus.generate(task)
    if quality_check(result) >= threshold:
        return result

    # Escalate to Fable
    return fable.generate(task)

28.9.2 The Router Pattern

Use a cheap model (Haiku) to classify the task, then route to the appropriate model.

# Haiku classifies the task
category = haiku.classify(task)
# Returns: "simple", "moderate", "complex", "frontier"

# Route to appropriate model
model = {
    "simple": haiku,
    "moderate": sonnet,
    "complex": opus,
    "frontier": fable,
}[category]

result = model.generate(task)

28.9.3 The Parallel Pattern

Run multiple models in parallel and take the best result (useful for critical tasks where cost is secondary).

results = parallel_execute(
    sonnet.generate(task),
    opus.generate(task),
)
return best_result(results, criteria="accuracy")

28.10 Key Takeaways

  • Start with the most intelligent model and use effort level to dial performance and cost — counterintuitively, smarter models often cost less per task because they solve problems in fewer iterations.
  • Five model classes: Mythos/Fable (frontier), Opus (reasoning-intensive enterprise), Sonnet (versatile everyday), Haiku (fastest, lowest cost).
  • Effort level (Low, Medium, High, Max) controls how much reasoning the model does — it’s the primary lever for cost optimization.
  • The advisor strategy (cheaper worker + intelligent advisor) achieves ~90% of frontier quality at ~37% of cost.
  • General benchmarks have saturated — top models all score above 90% on MMLU, HumanEval, etc. Custom evaluations are the only reliable way to choose.
  • Build custom evals with 100+ cases representing your real task distribution, measuring accuracy, consistency, cost, latency, and robustness.
  • Common patterns: Default + escalation (Sonnet → Opus → Fable), Router (Haiku classifies, then route), and Parallel (run multiple models, take the best).
  • Model cost is only one factor — total task cost includes retries, errors, downstream propagation, and engineering time.