One of the most consequential decisions you make when building with Claude is also one of the easiest to get wrong: picking which model to use. Developers often default to the most capable option available, then wonder why their costs are high and their latency is painful. Others cut corners with a fast model and end up with outputs that require constant human correction. Neither outcome is what you want.

The good news is that this decision is not a guess. Once you understand what each model tier is optimized for, you can route requests intelligently, and that single change can dramatically improve both cost and quality across a real application.

The Four Tiers, Summarized

Anthropic currently offers four Claude models, each sitting at a different point on the speed-capability-cost curve.

  • Claude Fable 5 (claude-fable-5): The most capable model in the lineup. A 1M-token context window, the strongest reasoning, and the best performance on complex multi-step tasks. Use it when quality is non-negotiable.
  • Claude Opus 4.8 (claude-opus-4-8): High capability with a 1M-token context window. Strong at nuanced analysis and extended reasoning tasks. A reliable choice when you need depth but your use case does not strictly require the top tier.
  • Claude Sonnet 4.6 (claude-sonnet-4-6): The balanced middle tier. A 1M-token context window, good reasoning, and noticeably faster and more cost-efficient than Opus or Fable. The right default for a wide range of production workloads.
  • Claude Haiku 4.5 (claude-haiku-4-5): The speed tier. A 200K-token context window, the fastest response times, and the lowest cost per token. Purpose-built for high-volume, latency-sensitive tasks where the job is well-defined.

The Core Trade-off Triangle

Every model selection involves three variables: speed, cost, and capability. You cannot fully maximize all three at once. Here is how to think about each dimension.

Speed

Speed matters most in user-facing interactions where latency is felt directly, such as chat interfaces, autocomplete, or real-time document editing assistance. Haiku 4.5 wins here. When your application streams a response into a UI, the time-to-first-token and overall throughput shape the user experience more than raw output quality does, provided the output clears a minimum quality bar.

Cost

Cost matters most in batch workloads, high-frequency pipelines, and any scenario where a single user action triggers many model calls. Running a nightly job that classifies ten thousand support tickets does not need Fable 5. Using Haiku 4.5 for that job can cut costs substantially while producing results that are just as accurate for a straightforward classification task.

Capability

Capability matters most when the task itself is hard. Hard tasks include multi-step reasoning under ambiguity, generating code that must be correct on the first attempt, synthesizing conflicting information from long documents, and producing creative or strategic work where subtlety counts. These are the jobs where the gap between model tiers shows up plainly in output quality.

A Practical Decision Framework

Work through these questions in order when choosing a model for a new task or feature.

  1. Is the task structurally simple? If the job is classification, extraction, summarization of short content, or filling a template, Haiku 4.5 is your starting point. Test it first. You may already be done.
  2. Does the task require extended reasoning or synthesis? If the job involves comparing options, resolving ambiguity, writing code that must be logically sound, or working through a multi-step problem, move up to Sonnet 4.6. This tier handles most production reasoning workloads well.
  3. Is quality the primary constraint, not cost or speed? If you are generating a legal brief, a technical architecture proposal, or any artifact where a mistake is expensive, use Opus 4.8 or Fable 5. The additional cost is cheap compared to the cost of a wrong answer.
  4. Does the task require the absolute best available reasoning? Use Fable 5 (claude-fable-5) for your hardest problems: agent orchestration over long contexts, research synthesis across many sources, or any task where you need the model to catch its own errors and self-correct reliably.

When to Use Adaptive Thinking

On Claude 4.6 and later models, you can enable adaptive thinking, which lets the model allocate its own reasoning effort rather than forcing a fixed compute budget. This is the current supported approach for extended reasoning on these models.

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 16000,
  thinking: { type: "adaptive" },
  messages: [
    {
      role: "user",
      content: "Analyze the trade-offs between three database architectures for a write-heavy workload and recommend one."
    }
  ]
});

Adaptive thinking is worth enabling on Sonnet 4.6, Opus 4.8, and Fable 5 when the task genuinely benefits from deliberate reasoning. Avoid it on Haiku 4.5 for simple tasks where the overhead adds latency without improving quality. The rule of thumb: if you would benefit from a thoughtful human pausing to reason through the problem, enable adaptive thinking.

Concrete Examples by Use Case

Customer support chatbot (user-facing)

Use Haiku 4.5 for intent detection and routing. Use Sonnet 4.6 for generating the actual response when the issue is technical. Reserve Opus 4.8 or Fable 5 for escalated cases where a human-quality analysis is needed before handing off.

Code generation in an IDE extension

Use Haiku 4.5 for autocomplete suggestions where speed matters and the scope is small. Use Sonnet 4.6 for function-level generation. Use Fable 5 when the developer asks the assistant to architect a new module or refactor a large file with complex dependencies.

Nightly document processing pipeline

If the job is extracting structured fields from invoices, Haiku 4.5 handles it well at scale and low cost. If the job is summarizing complex contracts and flagging unusual clauses, Sonnet 4.6 or Opus 4.8 produces materially better output.

Agentic workflows with MCP tools

When you connect Claude to external tools and data sources via the Model Context Protocol, the model needs to reason reliably about tool selection, error handling, and multi-step planning. Start with Sonnet 4.6 for agentic work. Step up to Fable 5 when the agent operates over long contexts, manages many tools simultaneously, or needs to recover gracefully from unexpected states.

Build a Routing Layer, Not a Single Choice

In most non-trivial applications, the right answer is not to pick one model for everything. It is to route different request types to the model best suited for each. A simple classifier, a few rules based on input length and task type, or even a lightweight prompt-based router can direct requests intelligently. This pattern delivers Haiku-level costs for the majority of requests while reserving Fable-level quality for the minority that actually need it.

Here is a minimal routing pattern in Python:

import anthropic

client = anthropic.Anthropic()

def route_model(task_type: str, input_length: int) -> str:
    if task_type == "classification" or input_length < 500:
        return "claude-haiku-4-5"
    elif task_type == "code_generation" or task_type == "analysis":
        return "claude-sonnet-4-6"
    else:
        return "claude-fable-5"

def run_task(task_type: str, prompt: str) -> str:
    model = route_model(task_type, len(prompt))
    response = client.messages.create(
        model=model,
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

This is deliberately simple. In production you would layer in quality checks, feedback loops, and cost tracking. But the structure is the same: classify first, then route.

Takeaway

Picking a model is an engineering decision, not a status choice. The goal is the right output at the right cost for each specific job. Start at the cheapest tier that could plausibly work, test it, and move up only when you have evidence that quality falls short. Build routing into your architecture from the start. The applications that do this well outperform those that do not, on cost, on latency, and often on output quality too, because each request gets a model calibrated to its actual needs.