Every Claude Model Explained: Haiku, Sonnet, Opus and Fable (October 2026)

As of October 2026 Anthropic offers four current Claude models: Haiku 5.5, Sonnet 5.5, Opus 5.5 and Fable 5.1. They share one API and one set of tools, but differ sharply in speed, price and how much reasoning depth they bring to hard problems. This guide covers what each is for, how they compare, and — at the end — real outputs we generated from each model with the identical prompt.

A busy 2026: the release timeline

Fable arrived on 9 June 2026 as a new tier above Opus. Fable 5.1 followed on 1 September, then the 5.5 generation landed in a three-week burst: Opus 5.5 (22 Sep), Sonnet 5.5 (28 Sep) and Haiku 5.5 (7 Oct). Older models such as Opus 5 and Sonnet 5 remain available as legacy options.

At a glance

Model	Released	Input / Output (per 1M tokens)	Best at	API model ID
Haiku 5.5	7 Oct 2026	$0.10 / —	High-volume, low-latency, cost-sensitive work	claude-haiku-5-5
Sonnet 5.5	28 Sep 2026	$2 / $10	Everyday coding, bug fixes, documents, agents	claude-sonnet-5-5
Opus 5.5	22 Sep 2026	$4 / $20	Complex work needing careful judgment	claude-opus-5-5
Fable 5.1	1 Sep 2026	$10 / $50	The hardest problems; long-running agents	claude-fable-5-1

Price: a 100× spread

Fable 5.1 costs 2.5× Opus 5.5 per token, Opus costs 2× Sonnet, and Haiku 5.5 is a hundredth of Fable. Opus 5.5 is the value story of the generation: Anthropic says it performs at Fable 5.1’s level on most work while costing about 40% less to run than Opus 5.

Bigger isn’t always better: agentic coding

On Terminal-Bench 4.0, Sonnet 5.5 scores 70.6% versus Opus 5.5’s 66.4%. Opus still leads on most public benchmarks that reward judgment, which suggests a useful division of labour: let Opus design the plan, let Sonnet build it.

Where each model sits

Meet the models

Claude Haiku 5.5 — the sprinter

Use it for:

• Classifying or tagging thousands of support tickets
• Real-time autocomplete and chat triage
• Extracting fields from invoices and forms
• First-pass filter that escalates hard cases to Sonnet or Opus

Example prompt:

Classify this ticket as BILLING, BUG, or FEATURE. Reply with the label only.

"I was charged twice for October."

Claude Sonnet 5.5 — the workhorse

Use it for:

• Implementing a feature from a clear spec
• Fixing a failing test suite in an agent loop
• Drafting reports, decks and spreadsheets
• Customer-facing assistants where latency matters

Example prompt:

Here's a failing pytest output and the module it tests. Find the bug, fix it, and explain the change in two sentences.

Claude Opus 5.5 — the strategist

Use it for:

• Architecture decisions and large refactors
• Reviewing a contract or research paper for subtle issues
• Long-form writing that needs a consistent voice
• Planning multi-step agent work that Sonnet then executes

Example prompt:

We're splitting a monolith into services. Here is the repo map and our traffic data. Propose the boundaries, the migration order, and the top three risks.

Claude Fable 5.1 — the frontier

Use it for:

• Problems where Opus gets stuck
• Very long-running autonomous agents
• Novel research-grade analysis
• Work where a single error is far more expensive than tokens

Example prompt:

Opus's proof attempt fails at step 4 (attached). Find a different approach to the lemma and verify each step.

Calling any model from the API

Switching models is a one-line change — only the model string differs:

import anthropic

client = anthropic.Anthropic()

for model in ["claude-haiku-5-5", "claude-sonnet-5-5",
              "claude-opus-5-5", "claude-fable-5-1"]:
    msg = client.messages.create(
        model=model,
        max_tokens=512,
        messages=[{"role": "user",
                   "content": "Explain recursion in two sentences."}],
    )
    print(model, "→", msg.content[0].text)

A common production pattern is cascade routing: send everything to Haiku, escalate low-confidence answers to Sonnet, and reserve Opus or Fable for the small fraction of genuinely hard cases.

Which one should I use?

Live examples: same prompt, every model

To compare the models directly, we sent each one the identical three-part prompt on 17 October 2026 and published the raw output unedited. The prompt: (1) explain recursion to a beginner in exactly two sentences; (2) write a Python is_palindrome(s) ignoring case, spaces and punctuation; (3) draw an original animated SVG of “a tiny robot watering a plant”.

1. The animated SVGs

All three animate a bobbing robot, a tilting arm and falling droplets. Haiku produced the leanest drawing; Sonnet added a growing stem and staggered droplets; Opus choreographed the scene — droplets only appear while the can is tipped, and the flower sways and blooms.

Note: Fable 5.1 could not be run for this article because the account used requires usage credits for it, so its slot is intentionally left empty rather than filled with a simulated answer.

2. Explaining recursion

Recursion is when a function solves a problem by calling itself on a smaller piece of the same problem. Every recursive function needs a base case that stops the calling, so the steps eventually end instead of running forever.

Haiku 5.5

Recursion is when a function solves a problem by calling itself on a smaller piece of that same problem, like opening a set of nested boxes where each box contains a smaller one. It keeps going until it reaches a simple "base case" that can be answered directly, and then the answers are passed back up the chain to build the final result.

Sonnet 5.5

Recursion is when a function solves a problem by calling itself on a smaller version of the same problem, like opening a set of nesting dolls one at a time. Each call gets closer to a simple "base case" that can be answered directly, and then the answers are passed back up to build the final result.

Opus 5.5

Haiku went straight to the mechanics (self-call + base case). Sonnet and Opus both reached for an analogy — nested boxes and nesting dolls — and added the step beginners usually miss: answers being passed back up the chain.

3. Writing code

Haiku 5.5

def is_palindrome(s):
    t = [c.lower() for c in s if c.isalnum()]
    return t == t[::-1]

Sonnet 5.5

def is_palindrome(s):
    cleaned = [c.lower() for c in s if c.isalnum()]
    return cleaned == cleaned[::-1]

Opus 5.5

def is_palindrome(s):
    t = [c.lower() for c in s if c.isalnum()]
    return t == t[::-1]

All three converged on the same idiomatic three-line solution — a reminder that for simple, well-specified tasks the cheapest model is often all you need.

The bottom line

• Haiku 5.5 — default for volume; costs pennies.
• Sonnet 5.5 — default for almost everything else, and the best agentic coder per dollar.
• Opus 5.5 — when judgment matters; near-Fable quality at 40% of the price.
• Fable 5.1 — when Opus gets stuck and the problem is worth it.

Sources: Anthropic model and pricing announcements as summarised by Inkfluence AI, Digit, TAAFT, DevToolPicks and SSD Nodes. Verify current pricing at docs.claude.com.