Claude Models Guide

TL;DR

• Current GA tiers: Claude Sonnet 5 (claude-sonnet-5) — everyday production workhorse; Claude Opus 5 (claude-opus-5) — hardest reasoning and agentic work; Claude Haiku 4.5 (claude-haiku-4-5) — latency and volume. Route by workload — never one permanent default.

• Context: on the order of ~1M tokens for Sonnet 5 / Opus 5 class; Haiku often ~200K (verify per model in Anthropic docs). Long context is a real product differentiator for codebase and document packs — with cost and attention caveats.

• Adaptive / effort thinking on Sonnet 5 — raise thinking effort for hard paths; keep low effort (or Haiku) for volume. Tier × effort is the routing grid.

• Historical strengths: careful instruction following, long-context coding, Constitutional AI alignment story, and Model Context Protocol for tool connectivity.

• Content marking (2026-08): models launched on or after 2026-08-02 embed SynthID-Text watermarks (EU AI Act transparency, applied globally). C2PA credentials on supported files. Does not identify users; detection API forthcoming. See AI Security.

• History only: Claude 2 → 3 → 3.5/3.7 → 4.x → Sonnet 5 / Opus 5. Do not start new systems on retired IDs.

Quick Decision Guide

Who this guide is for

• Best for: AI engineers · ML engineers · backend engineers · architects
• Difficulty: Intermediate
• Estimated time: 55 min

Learning Path

Large Language Models → Prompt Engineering → Claude Models → Function Calling → Cost Optimization → Evaluation

On this page

• Why This Matters
• The Problem Claude Models Solve
• How We Got Here
• What Is the Claude Model Family?
• How Claude Models Work
• Architecture
• Step-by-Step Flow
• Real Production Example
• Design Decisions
• Comparisons
• Common Mistakes
• Where It Breaks Down
• When NOT to Default to Claude
• Running in Production
• Production Checklist
• Related Guides
• Interview Questions
• Key Takeaways
• FAQs
• References
• Further Reading

Why This Matters

Anthropic's Claude is the primary peer to OpenAI GPT in many production stacks — IDE agents like Cursor, enterprise copilots, and agent frameworks. The decision is not "Claude vs GPT" as a brand war. It is which tier and thinking effort meet your latency, context, safety, and cost constraints on a measured golden set.

Teams that default every request to Opus overpay. Teams that force Haiku onto multi-file refactors underperform. Understanding Claude's tier grid, long-context behavior, and honest failure modes lets you route deliberately and avoid vendor hype from either side.

Operationally, Claude forces the same discipline as GPT: pin IDs, attribute tokens (including thinking), and re-eval on every upgrade. The difference is where quality shows up first — long packs, careful edits, MCP-hosted tools — and where friction shows up first — verbosity, over-refusal, and effort-driven latency. Design the product around those realities instead of assuming a single "best model" checkbox.

Engineering Insight

Most production failures trace back to weak routing and evaluation, not to picking the "wrong" provider. Choose tiers by workload and eval-gate every change.

The Problem Claude Models Solve

Enterprise LLM deployments hit three recurring frictions:

1. Context limits — policies, contracts, and repos span more tokens than early chat models allowed without aggressive chunking.
2. Unreliable instruction following — models drift, invent policy, or ignore constraints.
3. Tool integration sprawl — every datasource needs custom connector code.

Claude addresses these with large context on leading tiers, post-training aimed at helpful/honest/harmless behavior (Constitutional AI lineage), and MCP as a standardized tool/data protocol. For developers, Claude often excels when the job is careful reading of long inputs: code review, contract analysis, research synthesis, multi-file edits.

You still need RAG, tools, structured outputs, and evaluation. Long context is not a substitute for retrieval design or claim verification — see hallucinations and large language models.

How We Got Here

Diagram: Claude family evolution

timeline
    title From Claude 2 chat to Sonnet 5 / Opus 5
    2023 : Claude 2
         : Early long-context chat alternative
    2024 : Claude 3 / 3.5
         : Haiku / Sonnet / Opus product grid
    2024-2025 : 3.7 / early 4.x
              : Stronger coding + extended thinking
    2025-2026 : Sonnet 5 / Opus 5 / Haiku 4.5
              : ~1M context class + effort routing

The three-tier naming (Haiku / Sonnet / Opus) stabilized; versions advanced capability and context while production practice added effort dials.

Keep Claude 2–4.x IDs in migration history. New systems should pin current Sonnet 5 / Opus 5 / Haiku 4.5 IDs from Anthropic docs.

What Is the Claude Model Family?

Claude is Anthropic's family of decoder-only transformer LLMs, trained and aligned with techniques that include Constitutional AI — models critique/revise against written principles during training — plus RLHF-style preference optimization.

Claude Fable 5 (claude-fable-5) is Anthropic's higher widely released tier above Opus for peak long-running agent capability; Mythos 5 remains limited-access. Prefer Opus 5 for most complex production work unless you specifically need Fable.

Additional product surfaces (availability varies — verify):

• Adaptive / extended thinking — internal reasoning tokens before the visible answer; effort controls on Sonnet 5-class paths
• Computer use — GUI interaction via screenshots/actions (where offered)
• Batch API — discounted async jobs
• Prompt caching — discounted repeated prefixes
• MCP — standardized tool and context servers — Model Context Protocol

Note

Model IDs, context limits, and prices change. Verify against Anthropic docs and the current pricing page before architecture or finance lock-in.

How Claude Models Work

Claude tokenizes text (and images on vision-enabled models), runs transformer attention across the context window, and generates tokens autoregressively until stop. The application owns everything around that loop: retrieval packing, tool execution, schema validation, and delivery policy. Treating Claude as a black-box "smart API" without those layers reproduces the same failure modes as any other LLM family.

Long context. Sonnet 5 / Opus 5 class windows (~1M) let you pass large repos or document sets in one request. That is genuinely useful when cross-file or cross-clause dependencies matter and chunking would sever them. You still pay for every input token and can hit "lost in the middle" — put critical instructions at the edges; measure faithfulness on long packs with questions that probe middle sections. Haiku's smaller window (often ~200K — verify) is usually enough for chat turns and short RAG. Whole-repo dumps are not free intelligence: if your eval shows RAG + Sonnet matching whole-pack quality at half the cost, prefer RAG.

Thinking / effort. Extended or adaptive thinking allocates internal tokens before the user-visible answer. Higher effort helps math, planning, and hard coding; it increases latency and cost. Route effort + tier together: low-effort Sonnet or Haiku for FAQ; high-effort Sonnet or Opus for hard agents. Log thinking-token counts separately so finance and SRE can see which routes burn hidden compute. Do not ship a global "max effort" flag — that is the Opus-for-everything mistake in another form.

Tool use / MCP. Claude emits tool calls similar to function calling. MCP standardizes how hosts discover and call tools — useful for IDE and multi-server agent setups. Keep authorization outside the model: Claude proposing run_sql does not mean the host should execute unrestricted queries. Sandbox tools, scope credentials, and cap agent loops.

Alignment behavior. Constitutional AI lineage shows up as careful refusals and instruction adherence. That reduces some unsafe completions; it can also over-refuse legitimate edge cases — design UX for "blocked → clarify / escalate." Measure refusal rate by intent class so safety wins do not silently become product regressions.

Prompt caching and Batch. Structure prompts with static policy, style, and corpus prefixes first; put user-specific variables last so cache keys remain stable across turns. Use Batch for offline review queues and nightly synthesis where multi-hour SLA is acceptable — typically at a meaningful discount versus interactive tokens (verify current Anthropic Batch pricing).

Architecture

Diagram: Claude production architecture

flowchart TB
    subgraph App [Application]
        U[User / Agent host]
        R[Router: risk × complexity]
    end
    subgraph Claude [Anthropic API]
        H[claude-haiku-4-5]
        S[claude-sonnet-5]
        O[claude-opus-5]
    end
    subgraph Controls [Controls]
        Eff[Thinking effort]
        Cache[Prompt cache]
        MCP[MCP / tools]
        Schema[Structured outputs]
        Eval[Eval + traces]
    end
    U --> R
    R -->|volume| H
    R -->|default product| S
    R -->|hardest| O
    S --> Eff
    O --> Eff
    H --> Cache
    S --> MCP
    O --> MCP
    MCP --> Schema --> Eval

Sonnet 5 carries most traffic; Opus and high effort are escalations; Haiku absorbs volume.

Lineup snapshot (July 2026)

Pricing changes frequently — verify Anthropic's published rates (and cache/batch discounts) rather than locking finance to blog numbers. Treat cost like GPT: route, cache, Batch, compress — cost optimization.

Step-by-Step Flow

Diagram: Claude request with effort routing

sequenceDiagram
    participant U as User
    participant App as App / IDE host
    participant Rt as Router
    participant C as Claude
    participant T as Tools / MCP
    U->>App: Task
    App->>Rt: Score difficulty + stakes
    Rt-->>App: tier + thinking effort
    App->>C: Messages + tools + effort
    alt tool / MCP call
        C-->>App: tool_use
        App->>T: Invoke
        T-->>App: Result
        App->>C: tool_result
    end
    C-->>App: Final text / structured
    App-->>U: Deliver + log tokens

Decide tier and effort before the first token; escalate on validation failure, not by habit.

1. Define context shape — whole-repo pack vs RAG chunks vs short chat.
2. Choose starting tier — Sonnet 5 for most product paths; Haiku for volume; Opus only when Sonnet fails evals.
3. Set thinking effort — low for FAQ; raise on Sonnet/Opus for hard planning.
4. Pin model IDs in config; record in traces.
5. Wire tools/MCP for live systems; schemas for parsers — structured outputs.
6. Enable prompt caching on large static prefixes.
7. Instrument tokens (including thinking), latency, cost, refusals.
8. Eval-gate tier and effort changes on coding and faithfulness suites — evaluation.

Real Production Example

Code-review assistant: Haiku triages diff size/risk; Sonnet reviews; Opus only for flagged architectural diffs.

from __future__ import annotations

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

HAIKU = os.environ.get("CLAUDE_VOLUME_MODEL", "claude-haiku-4-5")
SONNET = os.environ.get("CLAUDE_MODEL", "claude-sonnet-5")
OPUS = os.environ.get("CLAUDE_COMPLEX_MODEL", "claude-opus-5")


def triage_diff(diff_text: str) -> str:
    msg = client.messages.create(
        model=HAIKU,
        max_tokens=256,
        messages=[
            {
                "role": "user",
                "content": (
                    "Classify this git diff as low, medium, or high risk. "
                    "Reply with one word only.\n\n" + diff_text[:12000]
                ),
            }
        ],
    )
    return msg.content[0].text.strip().lower()


def review_diff(diff_text: str, risk: str) -> str:
    model = OPUS if risk.startswith("high") else SONNET
    # Raise thinking/effort via current API params when available — verify docs.
    msg = client.messages.create(
        model=model,
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": (
                    "Review this diff for correctness, security, and API breaks. "
                    "Cite file hunks. If unsure, say so.\n\n" + diff_text
                ),
            }
        ],
    )
    return msg.content[0].text


diff = open("change.diff").read()
risk = triage_diff(diff)
print("risk:", risk)
print(review_diff(diff, risk))

For agent hosts, prefer MCP servers for repo, browser, and DB tools instead of one-off HTTP wrappers — see MCP and function calling.

Design Decisions

Choose Claude when:

• Long-context coding or document analysis is central and Sonnet/Opus win your bake-off
• You want careful instruction following and a strong refusal posture
• MCP-centric tooling (IDE agents, multi-server hosts) fits your architecture
• Prompt caching + Batch make large static corpora economical

Prefer another family when:

• OpenAI ecosystem / Azure networking is already standard and OpenAI's current flagship GPT models win evals → GPT
• GCP grounding, Vertex IAM, or native multimodal video is the center → Gemini
• You must self-host → Llama / Mistral

Whole-pack context vs RAG is the recurring Claude-specific decision. Use ~1M packs when the task needs global connectivity (cross-file refactors, multi-contract consistency). Use RAG when the corpus is mostly independent chunks and you can prove recall@k. Many teams hybridize: retrieve candidates, then stuff a ranked subset into Sonnet — cheaper than naive whole-corpus prompts, richer than tiny top-3 packs.

Common patterns

Diagram: Tier × effort decision

flowchart TD
    Q[Task] --> Vol{High volume / low stakes?}
    Vol -->|Yes| H[Haiku 4.5]
    Vol -->|No| Hard{Fails Sonnet eval or max difficulty?}
    Hard -->|No| S[Sonnet 5]
    Hard -->|Yes| O[Opus 5]
    S --> E{Need deeper thinking?}
    E -->|Yes| SH[Sonnet + higher effort]
    E -->|No| SL[Sonnet + low effort]

Escalate tier and effort independently; measure both on your golden set.

For IDE and agent hosts, prefer MCP servers with least-privilege credentials over embedding long-lived cloud keys in the model prompt. The model should request tools; the host should authorize them. That boundary matters more for Claude-heavy coding agents than for simple chat wrappers.

Comparisons

Bake-offs should fix the task pack first (coding edits, long-doc QA, tool agents), then vary only the model ID and effort. Changing prompts and models at once makes winners meaningless. Report quality, p95 latency, and $ per successful task — not isolated arena scores.

Common Mistakes

1. Opus for everything — burns budget; Sonnet 5 should carry most load.
2. Max thinking effort globally — latency and cost explode; dial per route.
3. Dumping megatokens without measurement — long context ≠ perfect recall; eval middle-span questions.
4. Ignoring over-refusal — build clarify/escalate paths for blocked legitimate asks.
5. Unpinned aliases — pin IDs; re-eval on every upgrade.
6. Skipping cache layout — dynamic timestamps in the system prompt destroy prompt-cache hits.
7. No peer bake-off — Claude is not automatically best; compare GPT and Gemini on your suite.

Where It Breaks Down

• Knowledge cutoff — RAG/tools for current facts.
• Verbosity — Claude can over-explain; constrain with prompts and max tokens.
• Over-refusal — safety posture blocks some medical/legal/security research UX.
• Latency under high effort — stream UI; move hard jobs async.
• Multimodal gaps vs Gemini — for heavy video/audio pipelines, evaluate Gemini honestly.
• Vendor lock-in via MCP-only assumptions — keep tool interfaces portable where possible.
• Cache invalidation surprises — editing a "static" policy prefix busts prompt-cache hit rates overnight; version the cached blob explicitly.
• Thinking-token opacity — product UIs that hide thinking still bill for it; finance must see those meters.

When NOT to Default to Claude

Do not set Claude (or Opus) as the permanent org default when:

• OpenAI or Gemini win your latency/cost/quality Pareto on the real workload
• You need GCP-native grounding and Vertex controls as the system of record
• Almost all traffic is cheap classification — Haiku or another volume model after bake-off
• You cannot yet log thinking tokens and $ — instrument first
• Residency requires self-host open weights

Warning

Permanent Opus (or permanent max effort) is an anti-pattern. Route by capability, latency, and cost; pin versions; re-eval on change.

Running in Production

Best Practice

Default to Sonnet 5, escalate to Opus 5 on measured failure, absorb volume on Haiku 4.5, and treat thinking effort as a per-route dial.

Long-context packs deserve their own SLO: track p95 latency and cost per review job separately from interactive chat. A Sonnet 5 whole-repo review that is acceptable asynchronously can destroy interactive TTFT budgets if you reuse the same route. Split configs: CLAUDE_INTERACTIVE_MODEL vs CLAUDE_BATCH_MODEL, with different max_tokens and effort defaults.

Continue Learning

• Next guide: GPT Models
• Then: Context Windows

Production Checklist

• Model ID pinned per environment (Haiku / Sonnet / Opus tiers)
• Thinking effort dial set per route (not a global max)
• Interactive vs long-pack / Batch configs separated
• Prompt caching enabled on large static prefixes
• MCP/tools scoped with least-privilege credentials
• SynthID-Text / C2PA marking understood for compliance and detector workflows
• Structured outputs enforced on parser paths
• Token and cost metrics include thinking tokens
• Golden-set gates for coding and faithfulness upgrades
• Fallback provider documented and tested
• Refusal / escalation UX defined
• Rollback strategy for tier or ID changes documented

Related Guides

Prerequisites

• Large Language Models · Tokens · Context Windows

Core Concepts

• GPT Models · Gemini Models
• Llama · Mistral · DeepSeek

Implementation

• Function Calling · Structured Outputs
• Claude · Cursor · LangChain

Optimization

• Cost Optimization

Advanced Topics

• Model Context Protocol
• Evaluation

Diagram: Claude learning path

flowchart LR
    LLM[LLMs] --> CL[Claude models]
    CL --> CW[Context windows]
    CW --> MCP[MCP]
    MCP --> FC[Function calling]
    FC --> CO[Cost opt]
    CO --> EV[Evaluation]
    CL --> GPT[GPT]
    CL --> GM[Gemini]

Long context and MCP sit next to Claude; compare peers before locking a vendor.

Interview Questions

1. How do Sonnet 5, Opus 5, and Haiku 4.5 differ?
   Sonnet is the production workhorse; Opus is the hardest-reasoning escalation; Haiku is volume/latency. Route by workload.

2. When do you raise thinking effort?
   On hard planning, math, or multi-step agents — after measuring that low effort fails. Not on every FAQ.

3. Is 1M context a reason to skip RAG?
   Sometimes for tightly coupled packs; usually no. Cost, latency, and middle-context loss still favor retrieval for large corpora.

4. What is MCP?
   A protocol for connecting models to tools and data sources with standard discovery/invocation — see MCP.

5. Claude vs GPT for coding?
   Bake off Sonnet 5 / Opus 5 vs OpenAI's current flagship GPT tiers on your repo metrics — do not assume a permanent winner.

6. How does Constitutional AI show up in products?
   Stronger refusal and principle-following tendencies; plan for over-refusal UX.

7. How do you control Claude cost?
   Haiku for volume, cache prefixes, Batch offline, escalate Opus rarely — cost optimization.

8. Why pin model IDs?
   Reproducible evals and traces; aliases can change behavior without a deploy.

Key Takeaways

• Claude's production grid is Sonnet 5 / Opus 5 / Haiku 4.5 — route by tier and thinking effort.
• Long context is powerful and expensive; measure middle-span faithfulness.
• MCP and tools ground actions; schemas and eval ground reliability.
• Historical Claude versions belong in migration notes, not new defaults.
• Never treat Opus (or Claude generally) as the permanent org-wide default.

FAQs

Is Sonnet 5 always the right default?

It is the right starting default for many product apps, not a permanent law. If Haiku meets evals, use it; if Sonnet fails hard tasks, escalate to Opus.

When should I use Opus 5?

When Sonnet 5 fails your golden set on hard reasoning, architecture, or long agent loops — or when stakes demand maximum capability plus verification.

What is Haiku 4.5 for?

Latency-sensitive and high-volume paths: classification, extraction, triage, cheap first-pass routing.

How large is Claude's context?

~1M class on Sonnet 5 / Opus 5; Haiku often ~200K. Verify current model pages.

Does Claude eliminate hallucinations?

No. Alignment and long context help; you still need grounding and verification.

Claude vs Gemini for documents?

Claude is strong on careful long-text reasoning; Gemini is strong on native multimodal and Google grounding. Bake off on your corpus.

Should I use prompt caching?

Yes for large static system/doc prefixes. Keep dynamic fields at the end.

Can I fine-tune Claude?

Anthropic's fine-tune options vary by program and time — check current docs; most teams start with prompting, tools, and RAG.

Are Claude outputs watermarked?

Models launched on or after 2026-08-02 embed SynthID-Text watermarks (applied globally). The mark is not user-identifying. Supported files can carry C2PA credentials. Anthropic has announced a forthcoming detection API. See How Claude’s text watermark works.

References

• Anthropic Documentation
• Anthropic Models Overview
• How Claude’s text watermark works
• Model Context Protocol
• OpenAI API Documentation (peer comparison)
• Google AI for Developers

Further Reading

• Constitutional AI (Anthropic)
• LangChain Documentation
• Cursor Documentation