Claude: Anthropic's Model Family in Practice

Four Tiers and a Different Set of Rules

Claude is Anthropic's model family, and in late 2026 it has four tiers that are widely available: Haiku, Sonnet, Opus and Fable. Teams usually meet Claude through a coding tool and then bring it into their own product, which is where the differences from other providers start to matter. The Messages API looks familiar, but thinking, tool use and caching each follow rules that changed with the 5.5 generation.

The Lineup

Every tier has a 1M-token context window and up to 128K output tokens. The ids are plain aliases with no date suffix. Fable is a separate tier above Opus and not a new name for it. Haiku's price applies to prompts up to 100K tokens and rises beyond that. Sonnet is the sensible default, Opus the step up when Sonnet is not enough, and Haiku the tier to push volume onto.

Thinking Is Adaptive, and Effort Controls It

Current Claude models decide for themselves when and how much to think. You do not set a token budget. The oldbudget_tokens parameter is rejected, and you steer depth with effort.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    thinking={"type": "adaptive", "display": "summarized"},
    output_config={"effort": "high"},     # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": "Find the race condition in this handler: ..."}],
)

# content is a list of typed blocks, and the first one is often a thinking block
for block in response.content:
    if block.type == "text":
        print(block.text)

• Defaults differ by model. Opus 5.5 and Haiku 5.5 default to medium effort, Sonnet 5.5 to high. Set it explicitly so a model change does not also change effort without you noticing.
• Thinking cannot be switched off on Opus 5.5. Use low effort instead. Sonnet 5.5 has a mode that thinks only between tool calls.
• Thinking counts toward max_tokens. A small cap can leave no room for the answer. Use a generous cap, and stream when it is large.
• You see a summary at most. The raw reasoning is never returned, and by default the thinking text is empty unless you ask for the summarised display.

Tool Use: What Is Different

Tools are declared with a name, a description and an input schema. The model returns tool_use blocks, and you answer withtool_result blocks. Three rules catch code written for other providers:

• You cannot force a tool call on Fable 5.1, Opus 5.5 or Sonnet 5.5. Only auto and none are accepted. Ask for the tool in the instructions, or use structured outputs if the forced call only existed to get JSON back.
• Return every result in one message. When the model makes several tool calls in a turn, send all the results together in a single user message. Splitting them across messages teaches the model to stop calling tools in parallel.
• Mark tools as strict when arguments must match the schema exactly, and return failures as a result withis_error set, so the model can recover.

Prompt Caching

Caching is the largest cost lever for most Claude applications. A cached prefix is read at roughly a tenth of the input price. Writing to the cache costs about a quarter more than normal input. The default lifetime is five minutes, and one hour is available.

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    cache_control={"type": "ephemeral"},   # caches up to the last cacheable block
    system=LONG_STABLE_INSTRUCTIONS,
    messages=[{"role": "user", "content": question}],
)

print(response.usage.cache_read_input_tokens)   # zero on every call means something changes each time

Caching matches on an exact prefix, so one changed byte near the top invalidates everything after it. The usual causes are a timestamp in the system prompt, tools listed in a different order, and JSON serialised with unstable key order. Tools come first in the prefix, then the system prompt, then the messages.

Where You Can Run It

The same models are available from Anthropic directly and through Amazon Bedrock, Google Vertex AI and Microsoft Foundry. Each cloud has its own client class, its own model id format, and a slightly different list of supported features, and new models and beta features tend to arrive on the first-party API first. Choose the platform for procurement and data-boundary reasons, then check the feature you depend on is available there.

Key Takeaways