As of October 22, 2026, Anthropic recommends starting with Claude Opus 5.5 for most workloads. That is a starting point, not a universal team default. The practical choice depends on the task’s reasoning requirements, error impact, latency target, volume, cost ceiling, and review process.
Anthropic currently positions Fable 5.1 for demanding reasoning and long-horizon agentic work, Opus 5.5 as the general starting point, Sonnet 5.5 as a balance of speed and intelligence, and Haiku 5.5 for high-volume or latency-sensitive tasks. The model, price, plan, availability, limit, and effort details in this guide were checked against official documentation on October 22, 2026. They can change, so recheck the linked references before deployment.
Model capability does not guarantee correctness. Evaluate representative work, validate outputs for the task, and use least-privilege access and human approval before consequential or externally visible actions.
Which Claude model is best for work right now?
For a first evaluation, use Opus 5.5 if the work benefits from stronger reasoning or if an error would be expensive to correct. Test Sonnet 5.5 for interactive drafting, document transformation, routine analysis, and ordinary coding. Test Haiku 5.5 for high-volume classification, extraction, routing, and short transformations. Consider Fable 5.1 only when the task genuinely needs a longer agentic horizon and your plan, permissions, and review controls support it.
A team may therefore start with Opus 5.5 for evaluation while choosing a smaller operational default for a tested, low-risk workflow. For example, a feedback pipeline might use Haiku 5.5 for approved theme tagging, Sonnet 5.5 for interactive summaries, and Opus 5.5 to reconcile conflicting evidence before a policy decision. Those assignments are a proposed routing framework, not Anthropic requirements.
Starting with Opus 5.5 follows Anthropic’s current general guidance. A team can still make Sonnet 5.5 or Haiku 5.5 its default for a defined workflow when representative testing shows that quality, correction effort, latency, and cost meet the workflow’s requirements.
What is the difference between Haiku 5.5, Sonnet 5.5, Opus 5.5, and Fable 5.1?
Anthropic’s positioning narrows the shortlist, but it does not establish a guaranteed winner for a particular job. The table below uses Anthropic’s listed API prices per million tokens and describes practical tradeoffs rather than benchmark rankings.
| Model | Documented fit | Input / output price | Practical tradeoff |
|---|---|---|---|
| Haiku 5.5 | High-volume, latency-sensitive work such as classification, extraction, and routing | From $0.10 / $0.50 | Low listed starting price; pricing is tiered by prompt size. |
| Sonnet 5.5 | Balance of speed and intelligence | $2 / $10 | A candidate for interactive work where responsiveness and capability both matter. |
| Opus 5.5 | Anthropic’s recommended starting point for most workloads | $4 / $20 | Test whether added quality justifies the spend and latency. |
| Fable 5.1 | Demanding reasoning and long-horizon agentic work | $10 / $50 | Use only when the task horizon, access rules, and controls justify the cost. |
Anthropic’s current overview lists a 1 million-token context window and a 128,000-token maximum output for these primary models. These are limits, not a recommendation to send the maximum context. The current model IDs are claude-haiku-5-5, claude-sonnet-5-5, claude-opus-5-5, and claude-fable-5-1. Use the current Claude model overview for provider-specific availability, limits, prices, and capabilities. Anthropic’s Models API can also return model limits and capabilities for applications that maintain a current capability registry.
Fable 5 and Fable 5.1 are paid-plan gated. Pro users and standard Team seats generally use usage credits for Fable. On Max plans, premium Team seats, and premium seat-based Enterprise plans, Fable usage can count toward up to 50% of the weekly allowance. That is part of the total allowance, not extra capacity. Check the current Fable plan and usage rules before budgeting.
Choose by task risk, volume, and need for autonomy
Use two questions to narrow the choice: how much reasoning does the task need, and what happens if the result is wrong? Volume and latency then determine whether the selected capability is operationally affordable.
| Trigger or task | AI job | Validation | Action or fallback |
|---|---|---|---|
| Many short feedback records | Test Haiku 5.5 to assign approved themes or extract specified fields. | Check allowed values, required fields, source identity, and truncation. | Stage validated fields; send ambiguous comments to an operations queue. |
| Interactive drafting or routine analysis | Test Sonnet 5.5 to transform supplied documents into a brief, summary, or first draft. | Check required sections, factual support, audience, and completeness. | Save as a draft for the owner; return incomplete work for correction. |
| Conflicting evidence or difficult technical judgment | Test Opus 5.5 for source reconciliation, complex planning, architecture, or difficult debugging. | Require cited source passages, reproducible tests, or a domain-specific review. | Escalate unresolved disagreement or high-impact conclusions to a named reviewer. |
| Long-running, multi-step work | Consider Fable 5.1 when the task needs a longer agentic horizon and access rules fit. | Limit tools and writable destinations; inspect actions and intermediate results. | Pause before consequential changes and route exceptions to an owner. |
For coding, distinguish a routine function or test draft from architecture decisions or debugging that has resisted simpler approaches. Test the actual repository, tools, and acceptance tests rather than assuming one model wins every coding task. Claude Code documents aliases and named model configuration, including opusplan as a special model setting. Check the Claude Code model configuration reference for current behavior instead of assuming a particular planning and execution sequence.
Interactive and unattended work have different control needs. Interactive drafting can be judged mainly on quality, latency, and review time. Unattended work also needs scoped permissions, action limits, cancellation, logging, and a named owner for exceptions. ConsultEvo’s AI agent design service page provides relevant service context for bounded tasks and review gates.
Optimize the response and review loop
Example: draft a customer update from supplied notes, then let the account owner edit and send it. The model prepares content; the owner controls publication.
Control actions as well as output
Example: an agent may prepare a CRM change, but validation, deduplication, and approval should precede a consequential write.
Use a failure-based escalation rule instead of upgrading by instinct
Before switching models, identify what failed. A malformed result is usually a contract or validation problem. A missing fact is usually a source problem. A capability escalation is justified when the remaining problem is genuinely about reasoning or task horizon.
- Name the failure. Record whether the result lacked evidence, missed a required field, contradicted a source, exceeded latency, or failed a reasoning task.
- Repair the input or contract. Supply missing source material, identify the audience, specify the format, or add allowed values and acceptance criteria.
- Retry within the selected model. If supported for that model and product surface, test an appropriate effort setting. Anthropic says the effort parameter controls token use while responding and can affect tool calls and thinking. Higher effort can increase cost and latency, and defaults and supported levels vary.
- Escalate for a named reason. Consider a more capable model for unresolved conflicting evidence, difficult reasoning after the brief is repaired, or a long-horizon task. Set a retry limit and log each attempt.
- Measure the workflow. Compare completion rate, correction rate, reviewer time, latency, and cost on representative tasks. Public benchmarks are not a substitute for testing your own inputs and tools.
Anthropic’s current effort documentation says most models default to high effort, while Opus 5.5 and Haiku 5.5 default to medium. Confirm the exact model and product surface before estimating cost or latency.
Build a bounded model-routing workflow
The following is a hypothetical application design, not an Anthropic-provided router or CRM connector. It assumes an application can call the selected model and access the organization’s system of record. For example, an operations owner could receive an inbound lead document, extract approved fields, validate them, and stage a proposed update. ConsultEvo’s CRM systems and workflow design page provides relevant service context.
A compact routing-policy record might look like this. It is illustrative application configuration, not an Anthropic schema.
{
"task_type": "customer_feedback_summary",
"risk_class": "standard",
"default_model_id": "claude-haiku-5-5",
"effort": "medium",
"cost_ceiling": 0.05,
"human_approval_required": false,
"effective_from": "2026-10-22"
}For a hypothetical lead extraction, the output contract could contain company_name, contact_date, requested_service, and source_id. The application should validate required fields, date format, approved service values, source identity, and truncation before staging the result in the CRM. A value outside the allowed list or a date that does not parse goes to the CRM operations reviewer.
Define data grain before storing results. One run-level record represents one model invocation and should contain its run ID, model ID, provider, effort, prompt version, token counts, timestamps, status, and validation result. Store each source version separately. If the workflow records evidence, keep each citation or evidence span as its own record. Weekly correction rates belong in an aggregate reporting layer, not in an invocation row.
For one intended output per source and configuration, a proposed unique key is source_id, source_version, prompt_version, model_id, provider, effort, and output_variant. Keep a separate run ID for every invocation and a separate citation or event ID where those are distinct records. Enforce uniqueness in the database and use an atomic upsert or transaction. A lookup followed by an insert is not race-safe when workers process the same event concurrently.
Control recurring-work costs with caching, batching, and version records
- Use direct requests for interactive work. Keep source material and the output contract specific to the current task.
- Use prompt caching for reusable prefixes. Anthropic supports automatic and explicit cache breakpoints with 5-minute or 1-hour TTL options. Caching is useful when instructions or reference material recur, but it does not automatically reduce the cost of every request. Version cached material when it changes. See the prompt caching guide.
- Use Message Batches only when delayed completion is acceptable. The API is asynchronous and Anthropic documents a 50% reduction in input and output token costs. A batch supports up to 100,000 requests or 256 MB, whichever comes first, and expires after 24 hours if incomplete. Track request-level results and failures when polling and retrieving the batch. See the Message Batches documentation.
- Save enough provenance to reproduce a run. Record the full model ID, provider, Claude Code version where relevant, effort, prompt and source versions, token counts, run status, validation result, and reviewer approval. Claude Code aliases such as
sonnetandopusare moving selectors, not version pins. Use a full model name or provider-specific identifier where reproducibility matters, and review the model lifecycle information.
Keep deterministic work deterministic. Use date libraries to normalize dates, database constraints to prevent duplicate records, and lookup tables for approved categories. Reserve model judgment for ambiguity in unstructured material. For consequential or externally visible actions, use least-privilege access and require human approval before the action occurs.
What to verify before standardizing a model across a team
Make the model choice a reviewed configuration, not an informal habit. Check the intended model, provider, plan, and workflow immediately before rollout. Anthropic’s current Team signup guidance lists a two-member minimum, not five. Fable usage and billing still depend on plan and seat type.
- Confirm the full model ID, provider, availability, and current lifecycle status.
- Check context and output limits, prices, and effort support for the exact product surface.
- Confirm plan and seat access, including whether Fable requires usage credits.
- Run representative tasks and record quality, correction rate, latency, review time, and cost.
- Assign a policy owner and review date, then repeat the evaluation after a material model change.
Frequently asked questions about choosing a Claude model
Which Claude model should I start with for work?
Anthropic’s October 2026 overview recommends starting with Opus 5.5 for most workloads. Your operational default may differ after testing task quality, volume, latency, cost, and review requirements on representative work.
What is the difference between Opus 5.5 and Fable 5.1?
Anthropic positions Opus 5.5 as its general starting recommendation and Fable 5.1 for demanding reasoning and long-horizon agentic work. Choose based on the task horizon and controls required, not the model names alone.
Does Haiku 5.5 have a 1 million-token context window?
Yes. Anthropic’s current overview lists a 1 million-token context window and a 128,000-token maximum output for Haiku 5.5. Verify limits for the exact model and provider you use.
Are Claude model aliases stable version pins?
No. Claude Code documents aliases such as sonnet and opus as moving selectors. Use a full model name or provider-specific identifier when reproducibility requires a fixed selection, and record the provider and configuration.
What does opusplan do?
Claude Code documents opusplan as a special model setting. Its exact behavior can depend on the current Claude Code version, so consult the current configuration reference rather than assuming a fixed planning and execution sequence.
When should I use the Batch API?
Use Message Batches for independent requests that do not need an immediate response. It is asynchronous, so use direct requests for interactive work and handle each request’s result or failure separately.