Anthropic’s current Claude lineup looks unusually uniform at first glance. Claude Fable 5.2, Opus 5.5, Sonnet 5.5, and Haiku 5.5 all accept text and images, support tool use, expose a one-million-token context window, and can return as many as 128,000 tokens in a synchronous response. That apparent consistency is useful for application developers, but it creates a new challenge for AI platform teams: the model name alone no longer describes the operational profile of a request.
The important differences now sit in price, latency, default reasoning effort, thinking behavior, and the kinds of work each model is intended to handle. Anthropic’s updated catalog therefore raises the bar for model routing. A production control plane should select models from measured workload requirements and machine-readable capabilities, not from a static “small, medium, large” hierarchy.
That is the infrastructure lesson behind Claude 5.5. The lineup gives teams a broad common interface, but it also makes routing policy, evaluation data, and cost telemetry more important than ever.
A common envelope hides four different operating profiles
Anthropic positions Fable 5.2 for demanding reasoning and long-horizon agentic work, Opus 5.5 for long-running agentic coding and knowledge work, Sonnet 5.5 as the speed-and-intelligence balance, and Haiku 5.5 for high-volume, latency-sensitive processing. The descriptions are straightforward. The infrastructure implications are not.
All four current models have a one-million-token context window and a 128,000-token maximum synchronous output. They also share vision, multilingual, and tool-use support. That reduces the amount of feature-detection logic an application needs, but it does not make the models interchangeable. Base API prices span two orders of magnitude on input: Fable 5.2 costs $8 per million input tokens and $40 per million output tokens; Opus 5.5 costs $4 and $20; Sonnet 5.5 costs $2 and $10; and Haiku 5.5 starts at $0.10 and $0.50 for prompts up to 100,000 tokens.
Haiku’s rate rises to $0.50 per million input tokens and $2.50 per million output tokens when prompts exceed 100,000 tokens. That threshold is a reminder that a supported context size is not the same thing as a cost-neutral context size. A router that sees “1M context” as a boolean capability can make a technically valid decision that is economically wrong.
Reasoning controls add another dimension. Fable 5.2 uses adaptive thinking that is always on and defaults to high effort. Opus 5.5 also keeps adaptive thinking on, but defaults to medium effort. Sonnet 5.5 defaults to high effort, while Haiku 5.5 defaults to medium. The model choice and the effort setting together define the real execution profile. Anthropic explicitly suggests that adjusting effort can be a better lever than switching models.
The model ID is stable; the deployment is still a living system
Anthropic’s versioning rules remove one source of ambiguity. Starting with the Claude 4.6 generation, dateless IDs such as claude-opus-5-5 and claude-sonnet-5-5 are pinned snapshots, not aliases that silently advance to new weights. When Anthropic ships an updated model, it receives a new ID. Each ID also has its own deprecation and retirement schedule.
For platform teams, that makes reproducible evaluation and staged rollout easier. A production system can pin an ID, validate a replacement, canary traffic, and roll back without wondering whether a nominally unchanged ID moved underneath it.
But pinning does not freeze every observable property. Anthropic notes that serving infrastructure around a model can change, including request routing, safety classifiers, and sampling logic. Those changes can produce minor behavioral differences even when the weights and model ID remain fixed. In other words, a pinned model is a necessary control, not a complete reproducibility guarantee.
This distinction should shape incident response. When quality shifts on a stable model ID, teams should first separate three possibilities: application changes, traffic-mix changes, and provider-side serving changes. That requires retaining prompt-template versions, routing decisions, effort settings, tool schemas, latency data, token counts, and sampled outputs. A model ID by itself is not enough evidence.
The Models API should feed the control plane
Anthropic’s Models API now exposes information that belongs in routing logic: maximum input tokens, maximum output tokens, capability objects, and a line field that groups related models. The documentation specifically warns developers to read line rather than infer it from the model ID, because Anthropic may add more lines.
That is a useful design cue. Hardcoded string parsing is brittle infrastructure. A router should ingest the provider’s catalog, normalize the metadata into an internal registry, and combine it with organization-specific evaluation results. Provider metadata can answer whether a model supports a feature; internal evidence must answer whether it meets a particular service-level objective.
A practical registry entry should include at least:
- Identity: provider, pinned model ID, model line, and availability by cloud or region.
- Capabilities: input modalities, tool support, thinking modes, context limit, and maximum output.
- Economics: input, output, cache-write, cache-read, batch, and long-context rates.
- Performance: measured time to first token, output rate, end-to-end latency, and error rate for each workload class.
- Quality: task-specific evaluation scores, failure modes, and confidence intervals.
- Lifecycle: first-seen date, retirement commitment, approved environments, and rollout status.
Refreshing that registry does not mean automatically sending traffic to every newly discovered model. Catalog ingestion and production approval should be separate steps. New IDs can enter a quarantine state, run against offline evaluations and shadow traffic, and become eligible only after policy checks pass.
Route tasks, not brands
The most defensible routing unit is a workload class. Classification, extraction, repository-scale coding, interactive research, and multihour autonomous execution have different tolerance for latency, error, and cost. One global “best model” setting obscures those differences.
Anthropic’s own selection guidance offers two starting strategies. An efficiency-first path begins with Haiku 5.5 and upgrades only when evaluations expose a capability gap. A capability-first path begins with Opus 5.5, then lowers effort or steps down after the workflow has been optimized. Fable 5.2 is the escalation target when demanding reasoning or long-horizon agent work still falls short at higher Opus effort.
Production routing can turn those suggestions into explicit policy:
- Send bounded, high-volume extraction and classification to Haiku when it meets accuracy and latency targets.
- Use Sonnet for everyday coding, analysis, and tool-driven workflows that need a stronger quality margin.
- Reserve Opus for complex agentic coding and knowledge work where long execution paths justify higher token prices.
- Escalate to Fable only for task classes whose evaluations show a measurable gain large enough to cover the additional cost.
The escalation condition must be observable. “This task looks hard” is not a production policy. Better signals include a low-confidence classifier, repeated tool failures, exhausted retries, an evaluator score below threshold, or a workload label assigned before execution. Teams should also cap escalation depth and total spend so that a pathological agent loop cannot climb the model ladder indefinitely.
Effort becomes a first-class routing variable
Traditional model routers choose an endpoint. The Claude lineup suggests that routers increasingly need to choose an endpoint-plus-configuration. Effort can trade intelligence for latency and cost within the same model, so changing it may preserve a model’s behavior and tool compatibility better than hopping between model families.
That creates a two-dimensional decision surface. A task might run well on Opus 5.5 at medium effort, Sonnet 5.5 at high effort, or Fable 5.2 at a different operating point. The correct choice depends on the entire distribution: input length, expected output, cacheability, tool-call count, retry probability, and the business cost of failure.
Platform teams should therefore log effort beside the model ID and evaluate configurations as distinct candidates. A benchmark labeled only “Opus versus Sonnet” is incomplete if the effort settings differ or remain implicit. Explicit configuration also protects teams when provider defaults vary across models.
Long context needs admission control
A one-million-token context window is valuable for large repositories, long documents, and durable agent sessions. It is also an invitation to replace retrieval and memory design with indiscriminate prompt growth. That can increase cost, latency, and the amount of irrelevant material competing for attention.
The infrastructure layer should treat long context as a governed resource. Before accepting a very large prompt, it can deduplicate files, strip generated artifacts, summarize older turns, retrieve only relevant chunks, and estimate the full request cost. It should also distinguish maximum capacity from the context length at which a workload remains economical and reliable.
Caching matters here. Anthropic prices cache reads below base input rates, with especially low multipliers for the current Fable, Opus, and Sonnet models. Stable prefixes such as repository instructions, tool definitions, or reference corpora can change the economics of repeated requests. Batch processing is another lever, priced at a 50% discount according to the model overview. A good router needs these delivery modes in its cost model rather than comparing only headline token prices.
A rollout checklist for platform teams
Teams adopting the current Claude lineup can avoid most routing mistakes with a disciplined rollout:
- Define workload classes. Group requests by task, risk, latency target, and failure cost before choosing models.
- Build representative evals. Use real prompts and data, measure edge cases, and score complete agent trajectories rather than isolated responses.
- Test model-and-effort pairs. Treat every pair as a separate deployment candidate with its own quality, latency, and cost profile.
- Pin model IDs. Promote new IDs through offline, shadow, canary, and production stages; do not confuse older aliases with newer pinned dateless IDs.
- Ingest capability metadata. Use the Models API, but require an internal approval state before a discovered model can receive traffic.
- Instrument every decision. Record route, effort, prompt version, token use, cache behavior, tool calls, retries, and final outcome.
- Set budget guardrails. Limit context size, retries, escalations, and maximum spend per job or tenant.
- Re-evaluate continuously. Stable IDs reduce weight drift, but serving infrastructure and workload distributions can still change.
The control plane is now part of model quality
Claude 5.5’s broad common feature set is good news for developers. Applications can rely on a more consistent interface while moving among models optimized for different jobs. Yet that flexibility shifts responsibility upward. Quality is no longer just a property of the selected model; it is also a property of the router, evaluation suite, context policy, effort setting, and observability stack around it.
The strongest AI infrastructure teams will not search for one permanent default. They will maintain a small, approved portfolio of pinned configurations, route well-defined workloads with evidence, and keep cost and behavior under continuous measurement. Anthropic’s latest catalog supplies the pieces. The differentiator will be how rigorously teams assemble them.


