# Best Model for Claude Code in 2026: Opus 5.5, Sonnet 5.5, Fable 5.2, Haiku 5.5, and Effort Routing > Compare Claude Opus 5.5, Sonnet 5.5, Fable 5.2, and Haiku 5.5 in Claude Code: SWE-bench cost curves, effort tuning, prompt caching, and BeatAPI pricing. - Canonical HTML: https://beatapi.io/blog/best-model-for-claude-code - Markdown: https://beatapi.io/blog/best-model-for-claude-code.md - Entity: BeatAPI (https://beatapi.io) — unified capability layer for AI agents - Published: 2026-11-21 - Author: BeatAPI Team (https://beatapi.io/about) - Language: en - Category: Comparison - Topic cluster: AI Agent & MCP Integration (Pillar Hub: https://beatapi.io/integrations) - Reading time: 12 min read - All blog posts for agents: https://beatapi.io/blog/llms.txt --- **Claude Opus 5.5 at its default `medium` effort is the best overall model for Claude Code in November 2026, while Claude Sonnet 5.5 is the lowest-cost daily default for clearly scoped edits on standard Anthropic pricing.** Claude Fable 5.2 handles multi-hour autonomous runs and hard root-cause investigations that stall Opus 5.5, and Claude Haiku 5.5 handles narrow subagent searches and log summaries under 100K input tokens. Choosing the best model for Claude Code requires separating three controls that govern quality and spend. The model sets the frozen reasoning weights, the effort level sets how many files, tool calls, and verification passes Claude runs per turn, and the Prompt Cache hit rate sets what you actually pay across a multi-turn session.

Quick answer: which model fits each Claude Code job

- **Choose [Claude Opus 5.5](/claude-opus-5-5-api) as your default all-round coding model:** Anthropic sets Claude Opus 5.5 as the account default across Pro, Max, Ultra, Team, Enterprise, and Anthropic API plans in Claude Code v2.1.280 and later. On Anthropic's 478-problem SWE-bench Pro subset, Claude Opus 5.5 at `medium` effort solved 92.8% of tasks at $0.22 per solved task on official list pricing with a five-minute cache—and on BeatAPI's 50%-off pricing, a 90%-cached Opus 5.5 session costs the exact same $0.0602 per turn as an official cached Sonnet 5.5 session. - **Choose [Claude Sonnet 5.5](/claude-sonnet-5-5-api) for fast, clearly specified daily work and coding subagents:** Claude Sonnet 5.5 requires Claude Code v2.1.284 or later, responds faster than Opus 5.5, and cuts standard official token rates in half ($2 / $10 per million tokens versus $4 / $20, or $1 / $5 on BeatAPI). When a hard bug triggers repeated retries on Sonnet 5.5, moving up to Opus 5.5 usually lowers total spend per completed fix. - **Choose [Claude Fable 5.2](/claude-fable-5-2-api) only for multi-hour autonomy and stubborn failures:** Released November 9, 2026 and requiring Claude Code v2.1.321 or later, Claude Fable 5.2 costs $8 / $40 officially ($4 / $20 on BeatAPI) and reaches 49.1% on FrontierCode 2.0 at `xhigh` effort. No plan sets Claude Fable 5.2 as an account default, so switch explicitly with `/model fable` only after Opus 5.5 stalls at higher effort. - **Choose [Claude Haiku 5.5](/claude-haiku-5-5-api) for fast read-only subagents and verifiable micro-tasks:** Claude Haiku 5.5 requires Claude Code v2.1.293 or later and charges $0.10 / $0.50 per million tokens officially ($0.05 / $0.25 on BeatAPI) for prompts up to 100,000 tokens. Keep Haiku 5.5 inputs under 100K tokens because crossing 100K triggers a 5x long-context price jump across the entire request.

Claude 5.x specs, CLI version requirements, and real monthly cost

All four current Claude 5.x models share a 1,000,000-token context window and a 128,000-token maximum output limit, so context size alone never separates them. They differ in minimum Claude Code CLI version, default effort behavior, cache-read discount multiplier, long-context pricing thresholds, and retail token rates across Anthropic direct and BeatAPI. | Model and API ID | Context / max output | Claude Code default effort (API default) | Anthropic official list price (in / out / cache read per 1M) | BeatAPI retail price on `POST /v1/messages` (in / out / cache read per 1M) | Minimum CLI version and primary role | | --- | --- | --- | --- | --- | --- | | **Claude Fable 5.2** (`claude-fable-5-2`) | 1M / 128K | `medium` (API: `high`) | $8.00 / $40.00 / $0.20 (0.025x) | $4.00 / $20.00 / $0.10 (5m write $5.00, 1h write $8.00) | `>= v2.1.321`; explicit `/model fable`; multi-hour autonomy and hardest debugging; requires 30-day data retention | | **Claude Opus 5.5** (`claude-opus-5-5`) | 1M / 128K | `medium` (API: `medium`) | $4.00 / $20.00 / $0.20 (0.05x) | $2.00 / $10.00 / $0.10 (5m write $2.50, 1h write $4.00) | `>= v2.1.280`; account default on Pro, Max, Ultra, Team, Enterprise, and API; all-round coding default | | **Claude Sonnet 5.5** (`claude-sonnet-5-5`) | 1M / 128K | `medium` (API: `high`) | $2.00 / $10.00 / $0.10 (0.05x) | $1.00 / $5.00 / $0.10 (5m write $1.25, 1h write $2.00) | `>= v2.1.284`; fast latency; scoped daily features and implementation subagents | | **Claude Haiku 5.5** (`claude-haiku-5-5`) | 1M / 128K | `medium` (API: `medium`) | `<=100K`: $0.10 / $0.50 / $0.01; `>100K`: $0.50 / $2.50 / $0.05 | `<=100K`: $0.05 / $0.25 / $0.005; `>100K`: $0.25 / $1.25 / $0.025 | `>= v2.1.293`; fastest latency; read-only repo search, classification, and log triage | One detail in the [Claude Code model configuration documentation](https://code.claude.com/docs/en/model-config) trips up many guides: inside Claude Code, Claude Fable 5.2, Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5 all start at `medium` effort by default, whereas direct Messages API calls default to `high` on Fable 5.2 and Sonnet 5.5. If any 5.5 or Fable 5.2 entry is missing from your `/model` picker, run `claude update` before troubleshooting your provider. ### What one typical turn and one full month actually cost (uncached vs 90% cached) To turn per-million rates into real developer spend, price a realistic coding turn of 30,000 input tokens and 5,000 output tokens repeated 100 times per day over 20 workdays (2,000 turns per month). Because healthy multi-turn Claude Code sessions read roughly 90% of their input from a five-minute prompt cache (27,000 cache-read tokens plus 3,000 new 5-minute cache-write tokens), comparing uncached list rates against 90%-cached rates on both Anthropic direct and BeatAPI reveals a sharp shift in effective cost. | Model | Uncached turn / month (Anthropic official) | 90% cached turn / month (Anthropic official) | 90% cached turn / month (BeatAPI retail) | | --- | --- | --- | --- | | **Claude Haiku 5.5** (`<=100K`) | $0.0055 / $11 | $0.0031 / $6.29 | **$0.0016 / $3.15** | | **Claude Sonnet 5.5** | $0.11 / $220 | $0.0602 / $120 | **$0.0315 / $63** | | **Claude Opus 5.5** | $0.22 / $440 | $0.1204 / $241 | **$0.0602 / $120** | | **Claude Fable 5.2** | $0.44 / $880 | $0.2354 / $471 | **$0.1177 / $235** | That cached-session arithmetic changes the default decision for BeatAPI users. Running Claude Opus 5.5 through BeatAPI at a 90% cache hit rate costs **$0.0602 per turn ($120 per month)**—identical to running Claude Sonnet 5.5 directly on Anthropic official pricing ($0.0602 per turn, $120 per month). Running Claude Fable 5.2 through BeatAPI ($0.1177 per turn, $235 per month) costs slightly less than running Claude Opus 5.5 directly on Anthropic official pricing ($0.1204 per turn, $241 per month), because BeatAPI cuts standard input, output, and cache-write rates by 50% and charges the same $0.10 per million cache-read tokens on Opus 5.5, Sonnet 5.5, and Fable 5.2. Always compare models on total cost per finished change rather than raw token rate when upgrading from older generations. Anthropic notes that the tokenizer introduced in Claude 4.7 and later counts roughly 30% more tokens for identical text than Claude Haiku 4.5, yet newer models finish in fewer retries: on Anthropic's SWE-bench Pro subset, Claude Sonnet 5.5 cut cost per solved task by 87% compared with Claude Sonnet 5, and Claude Opus 5.5 cut cost per solved task by 78% compared with Claude Opus 5 ($5 / $25 official).

Claude Opus 5.5 vs Claude Sonnet 5.5: which should be your daily default?

Claude Opus 5.5 is the stronger default when avoiding rework matters most or when you route through BeatAPI's discounted pricing, while Claude Sonnet 5.5 is the cheaper daily default when you pay full official list rates on cleanly specified tickets. Anthropic sets Claude Opus 5.5 as the default model across Claude Code plans and positions Claude Sonnet 5.5 as the best balance of response speed and coding intelligence for routine development. ### Tasks where Claude Sonnet 5.5 is enough Claude Sonnet 5.5 matches Opus 5.5's 1M context window and 128K output limit at lower latency and half the official standard token rate, making `/model claude-sonnet-5-5` a reliable fit for clearly bounded work: - Implementing a well-specified feature alongside its unit and integration tests. - Tracing a familiar stack trace or regression across a handful of known files. - Updating test suites and fixtures after a planned code change. - Reviewing a focused pull request for edge cases and contract mismatches. - Translating an approved technical spec into working modules. - Running parallel implementation or review subagents delegated from an Opus 5.5 lead session. Context capacity does not equal diagnostic accuracy. One million tokens lets Claude Sonnet 5.5 hold an entire subsystem, yet if Sonnet 5.5 already has the relevant files and repeats the same mistake twice, switch to Opus 5.5 instead of pasting more code into the prompt. ### Signals that you should start directly on Claude Opus 5.5 Claude Opus 5.5 pays for itself whenever reasoning quality outweighs typing speed. Start directly with `/model claude-opus-5-5` when any of these conditions apply: - A bug crosses multiple services, queues, or async boundaries and the first obvious hypothesis already failed. - You are working inside an unfamiliar repository with open architectural trade-offs. - A database migration, public API contract, or state-machine edit carries high rollback cost. - A large refactor must preserve undocumented legacy behavior across dozens of call sites. - Security boundaries, billing math, or data-integrity invariants make missed edge cases expensive. - Claude Sonnet 5.5 had full context, verified its work, and still delivered an incorrect fix.

When Claude Fable 5.2 justifies its price, and when it wastes budget

Claude Fable 5.2 is Anthropic's strongest generally available model, launched on November 9, 2026 at $8 / $40 per million tokens officially ($4 / $20 on BeatAPI)—20% lower than Claude Fable 5.1's $10 / $50 rate and up to roughly 30% faster in output generation. In the [Claude Fable 5.2 and Mythos 5.2 launch evaluation](https://www.anthropic.com/claude-fable-and-mythos-5-2), Anthropic reported that Claude Fable 5.2 reached **49.1%** on FrontierCode 2.0 at `xhigh` effort (ahead of Claude Opus 5.5 at 45.5% and Claude Fable 5.1 at 32.4%) and **69.9%** on FrontierSWE v2 (ahead of Opus 5.5 at 62.3%). At `high` effort on FrontierCode 2.0, Claude Fable 5.2 scored 45.3%—matching Claude Opus 5.5 at `max` effort (45.5%) for roughly half the per-task cost. Those frontier benchmarks still make Claude Fable 5.2 a specialist tier rather than a daily default. **Repository size alone never justifies paying Fable 5.2 rates**, because Haiku 5.5, Sonnet 5.5, Opus 5.5, and Fable 5.2 all provide 1M-token context windows and routine fixes that already pass on Opus 5.5 cost several times more on Fable 5.2 for the exact same diff. Switch explicitly with `/model fable` (or `/model claude-fable-5-2` inside Claude apps gateway sessions) only when one of four conditions holds: - Claude Opus 5.5 investigated with complete context and still failed to isolate the root cause. - Claude Opus 5.5 at `high` or `xhigh` effort still fails your target evaluation suite. - The task requires multi-hour autonomous execution across many tools and files without losing the plan. - The cost of an incident or flawed design dwarfs a few extra dollars of token spend. Three operational rules govern Claude Fable 5.2 in Claude Code. First, no subscription or cloud provider sets Fable as an account default, and on several subscription tiers Fable draws from separate usage credits rather than included plan limits. Second, Claude Fable 5.2 requires 30-day data retention and is unavailable under zero data retention (ZDR) without explicit Anthropic authorization. Third, requests flagged by cybersecurity or biology safety classifiers trigger automatic model fallback; see our [Claude Fable 5.2 guide](/blog/what-is-claude-fable-5-2) for migration breaking changes and how Fable 5.2 compares with Mythos 5.2.

Where Claude Haiku 5.5 saves money and how to pin a subagent

Claude Haiku 5.5 is the lowest-latency, lowest-cost model in the Claude 5.x lineup ($0.10 / $0.50 per million tokens officially, $0.05 / $0.25 on BeatAPI up to 100K input tokens) while still offering a 1M context window and adaptive thinking. On Anthropic's 79-task Claude Managed Agents suite, Claude Haiku 5.5 at `medium` effort passed 93% of attempts at roughly $0.011 per passed attempt, making it ideal for narrow tasks with fast deterministic checks: - Locating files, symbols, and call graphs before the main coding agent edits code. - Summarizing verbose CI failure logs or test runs down to the failing assertions. - Triaging and labeling issues, pull requests, or structured bug reports. - Applying repetitive, test-backed mechanical edits such as import rewrites. - Answering focused questions about code already loaded in context. Two cost traps can erase Claude Haiku 5.5's savings if left unchecked. First, **any single prompt exceeding 100,000 tokens triggers a 5x price jump across that entire request** (rising to $0.50 / $2.50 officially or $0.25 / $1.25 on BeatAPI), so keep Haiku 5.5 prompts tightly scoped. Second, when Haiku 5.5 misses cross-file invariants and loops through failed retries, the combined token waste and developer review time quickly exceed solving the edit once on Sonnet 5.5. Because Claude Code subagents inherit the main session model unless overridden, pin read-only research subagents explicitly to `haiku` in their subagent frontmatter so they never burn Opus 5.5 or Fable 5.2 rates while searching files: ```yaml --- name: quick-researcher description: Locate files, trace symbol references, and summarize logs inside a scoped directory without editing core logic model: haiku --- ```

Should you upgrade the model or raise effort? Reading the SWE-bench Pro curve

Model selection and effort tuning solve two different failure modes in Claude Code. Selecting a model swaps the frozen server-side weights that set the model's reasoning ceiling, whereas adjusting effort controls how many files Claude reads, how many tool calls it executes, and how thoroughly it verifies its own patch before replying. Anthropic's [Claude Code model and effort guide](https://claude.com/blog/claude-model-and-effort-level-in-claude-code) summarizes the troubleshooting sequence in three steps: 1. **Audit your context first:** Vague requirements, stale `CLAUDE.md` instructions, missing files, or disconnected tools cause failures on every model tier. 2. **Raise effort when Claude skipped work:** If Claude missed a file, skipped running tests, or stopped halfway through a refactor, keep the same model and raise `/effort`. 3. **Upgrade the model when Claude tried and still missed:** If Claude had every relevant file, checked its work, and remained confidently wrong, step up along `Haiku 5.5 -> Sonnet 5.5 -> Opus 5.5 -> Fable 5.2`. In September 2026, Anthropic published customer-billed SWE-bench Pro measurements (official list prices with a 5-minute prompt cache) in its [cost and intelligence optimization guide](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence). Placing model tiers and effort levels in one table shows why raw per-token price is a poor proxy for cost per finished fix: | Model and effort setting | Benchmark subset | Tasks solved | Cost per solved task (official list, 5m cache) | Practical takeaway | | --- | --- | --- | --- | --- | | Claude Sonnet 5.5 (`medium`) | SWE-bench Pro (478 tasks) | 80.3% | $0.07 | Lowest cost, but drops ~7 points below Sonnet 5.5 `high` | | Claude Sonnet 5.5 (`high`, API default) | SWE-bench Pro (478 tasks) | 87.6% | $0.11 | Strong budget baseline for clearly scoped edits | | Claude Opus 5.5 (`low`) | SWE-bench Pro (478 tasks) | 87.4% | $0.12 | Twice the token rate, yet only ~7% more per solved task than Sonnet 5.5 `high` | | **Claude Opus 5.5 (`medium`, Claude Code default)** | SWE-bench Pro (478 tasks) | **92.8%** | **$0.22** | Best single-model default: +5.4 points over `low` at a fraction of Fable spend | | Claude Opus 5.5 (`high`) | SWE-bench Pro (478 tasks) | 95.3% | $0.31 | High-value escalation tier for multi-file refactors and tough bugs | | Claude Opus 5.5 (`xhigh`) | SWE-bench Pro (463 offline-verifiable tasks) | 96.5% | $0.75 | Matches Fable 5.2 `high` (96.3%) for slightly over half the cost | | Claude Fable 5.2 (`low`) | SWE-bench Pro (463 offline-verifiable tasks) | 94.6% | $0.39 | Outscores Fable 5.1 default `high` (92.4% / $1.17) at one-third the cost | | Claude Fable 5.2 (`high`, API default) | SWE-bench Pro (463 offline-verifiable tasks) | 96.3% | $1.39 | Reserve for multi-hour autonomy and tail failures Opus 5.5 cannot crack |
Paper-cut diagram mapping Haiku 5.5, Sonnet 5.5, Opus 5.5, and Fable 5.2 across Task Complexity and Effort Depth axes with Raise Effort and Upgrade Model arrows
Match task ambiguity to the model tier first, then tune Effort Depth inside that tier before upgrading.
When your repository has reliable automated tests, Anthropic's **low-then-high failure re-run policy** beats any fixed effort setting on Claude Opus 5.5. Running all 478 SWE-bench Pro tasks at `low` effort (87.4% solved at $0.11 per task) and re-running only the 13% that fail tests at `high` effort reached roughly **97% total solve rate** for about **$0.17 per task**—more than 40% cheaper than running everything at `high` (95.3% at $0.29 per task), including the cost of the failed first attempts. Two prerequisites apply: your test suite must reliably catch bad patches, and you must tolerate double wall-clock latency on the failing 13%.

Claude Code aliases, Prompt Cache resets, and the opusplan trap

Use aliases for fast interactive switching, but pin full model IDs in benchmarks, CI scripts, and incident logs because cloud providers do not resolve aliases to the same versions as the Anthropic API: | Alias | Resolution on Anthropic API | Operational caveat | | --- | --- | --- | | `default` | Claude Opus 5.5 (Pro, Max, Ultra, Team, Enterprise, API) | Clears overrides back to account default; overridden by organization policy or `ANTHROPIC_DEFAULT_MODEL` | | `opus` / `best` | Claude Opus 5.5 | `best` maps to `opus`, not Fable 5.2 | | `sonnet` | Claude Sonnet 5.5 | Resolves to Sonnet 4.5 or 4.6 on Amazon Bedrock and some cloud lines unless pinned via `ANTHROPIC_DEFAULT_SONNET_MODEL` | | `haiku` | Claude Haiku 5.5 | Resolves to Haiku 4.5 on several AWS and Google Cloud lines unless pinned via `ANTHROPIC_DEFAULT_HAIKU_MODEL` | | `fable` | Claude Fable 5.2 | Resolves to Fable 5 in Claude apps gateway sessions; use `/model claude-fable-5-2` explicitly there | | `opusplan` | Opus in Plan Mode, Sonnet in execution | **Every plan-to-execute toggle switches models and invalidates the warm Prompt Cache** | In long Claude Code sessions, Prompt Cache hit rate moves your monthly bill more than raw token price. Anthropic's production traffic shows a median 84% cache-read share across agent loops (94% or higher for top-decile loops), cutting SWE-bench Pro task cost by 3.1x to 3.3x and multi-turn research cost by 4.8x to 7.2x. Per the [Claude Code prompt caching documentation](https://code.claude.com/docs/en/prompt-caching), four rules keep that discount intact: - **Mid-session `/model` switches break the entire warm cache:** Each model maintains an isolated cache, so switching models forces the next turn to rewrite the full conversation prefix at 1.25x input price—equal to 25 cache reads on Opus 5.5 and Sonnet 5.5, or 50 cache reads on Fable 5.2. - **Repeated `opusplan` toggles penalize long contexts:** Because `opusplan` flips between Opus and Sonnet every time you enter or exit Plan Mode, using it in a 50K-token conversation repeatedly rebuilds both models' caches and often wipes out Sonnet's output-rate savings. - **Adjusting `/effort` preserves the warm cache on Claude 5.x models:** With an API key or Claude subscription, changing `/effort` mid-session on Claude Fable 5.1/5.2, Opus 5.5, Sonnet 5.5, and Haiku 5.5 keeps the cached prefix intact with no confirmation prompt (exceptions: Amazon Bedrock, Google Cloud Agent Platform, HIPAA workspaces, or `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS`). - **Fast Mode (`/fast`) uses a separate cache and doubles token prices:** Fast Mode boosts output speed up to 2.5x on Claude Fable 5.2 ($16 / $80 official) and Claude Opus 5.5 ($8 / $40 official) with identical model quality, so enable it at session start instead of toggling mid-thread. Teams still running Fast Mode on Claude Opus 4.8 must switch before its November 30, 2026 removal using our [Claude Opus 4.8 Fast Mode to Opus 5.5 migration guide](/blog/opus-4-8-fast-mode-migrate-opus-5-5). Run `/usage` inside Claude Code v2.1.251 or later to inspect the `Prompt cache (main)` hit ratio and last miss reason. Whenever your main session drops below 80% cache reads, check for mid-session `/model` switches, `/fast` toggles, or changes to non-deferred MCP tool definitions before downgrading your model.

A six-step model switching order and multi-agent routing setup

Switch models at clean task boundaries with `/clear` rather than every few turns so you keep prompt caches warm and avoid carrying stale context into a new tier: 1. **Pick one clean starting tier:** Start on `claude-opus-5-5` (`medium`) when optimizing for first-pass reliability or running on BeatAPI's 50%-off pricing; start on `claude-sonnet-5-5` when paying full official rates on tightly scoped tickets. 2. **Pin read-only search subagents to Haiku 5.5:** Keep file discovery, symbol lookups, and log summaries on `claude-haiku-5-5` with prompts strictly below 100K tokens. 3. **Start high-risk tickets directly on Opus 5.5:** Open cross-service debugging, schema migrations, auth changes, and architecture work on `claude-opus-5-5` from turn one. 4. **Escalate with `/effort` before switching models:** If Opus 5.5 skips a check or needs deeper verification, raise `/effort` to `high` in place without losing the warm cache. 5. **Escalate to Fable 5.2 at a fresh boundary:** When Opus 5.5 stalls even at high effort—or when starting a multi-hour autonomous refactor—run `/clear` and switch to `/model fable`. 6. **Drop back to Sonnet 5.5 for mechanical finish work:** Once architectural choices are locked and only boilerplate tests or repetitive call-site edits remain, start a clean session on `claude-sonnet-5-5`. ### Multi-agent delegation: where subagents save 31% and where Advisor falls flat Anthropic's multi-agent benchmarks show that adding a second model only beats single-model effort tuning when work exceeds one context window or fans out across independent files. On a 22-million-token Python codebase defect-search benchmark split across 201 parts: - **Claude Opus 5.5 orchestrator + Claude Sonnet 5.5 subagents:** Scored 0.831 F1 for $139—matching Claude Opus 5.5 alone (`medium` to `high`, 0.827–0.850 F1 at $200–$236) while cutting total spend by **31%**. - **Claude Opus 5.5 orchestrator + Claude Haiku 5.5 subagents:** Lowered spend to $47, but dropped F1 sharply to 0.677; on an internal coding suite, adding Haiku 5.5 subagents saved 32% while losing roughly 4 percentage points of pass rate—roughly equivalent to lowering Opus 5.5 effort directly. - **Advisor tool (executor consulting a frontier model on demand):** On Anthropic's internal coding suite, pairing Opus 5.5 (`high`) with a Fable 5.1 advisor added only 1.7 points at 2.1x total cost, landing roughly on Opus 5.5's own effort curve while adding ~1,000 prompt tokens per turn for the advisor tool schema even when never consulted.
Paper-cut workflow showing Main Session keeping Cache Intact on Adjust /effort, hitting Cache Reset on Switch /model, and fanning out via dashed lines to isolated Sonnet 5.5 Subagent and Haiku 5.5 Search tiles
Tune /effort inside the main session to keep the prefix cache warm, and isolate lower-cost subagents via CLAUDE_CODE_SUBAGENT_MODEL.
Because subagents run in isolated conversations with their own caches, pinning `CLAUDE_CODE_SUBAGENT_MODEL` to `claude-sonnet-5-5` cuts fan-out costs without disturbing your main Opus 5.5 prompt cache: ```json { "env": { "ANTHROPIC_MODEL": "claude-opus-5-5", "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-5-5", "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-5-5", "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-5-5", "CLAUDE_CODE_SUBAGENT_MODEL": "claude-sonnet-5-5" } } ```

How to benchmark Claude Code models fairly on your own repository

Public leaderboards narrow your shortlist, but your own repository determines the exact cost-quality threshold. To run a fair comparison, freeze the Git commit, prompt text, tool permissions, and pass criteria across candidates, run each task two to three times to absorb agent variance, and **never change both model and effort in the same test round**—compare models at default effort first, then sweep effort on your winner. | Task type | Concrete sample task in your repo | Metrics to record | | --- | --- | --- | | **Routine feature edit** | Add a validated request field and matching unit tests | First-pass rate, wall-clock time, human fix-up minutes | | **Subtle bug fix** | Reproduce and fix a cross-module or async regression | Root-cause accuracy, retry count, test runs needed | | **Multi-package refactor** | Change a shared interface signature across packages and pass build | Missed call sites, typecheck and build status | | **Pull request review** | Review a PR with known edge-case defects | True bugs caught, false-positive count | | **Architecture and migration** | Draft a reversible schema or API rollout plan | Missing constraints, rollback completeness | | **Scoped subagent search** | Trace a call graph inside one subsystem and summarize | Answer accuracy, whether prompt stayed under 100K, latency | Record input tokens, cache reads, cache writes, output tokens, and human cleanup minutes side by side. A model with double the per-token price still wins if it saves 15 minutes of manual debugging, and a cheaper model wins whenever it clears the exact same automated check.

Running Claude 5.x and Messages-compatible models in Claude Code via BeatAPI

Claude Code speaks the Anthropic Messages wire protocol (`POST /v1/messages`), which BeatAPI serves directly with no translation proxy—cutting standard Claude 5.x input, output, and cache-write rates by 50% while preserving native prompt caching. Follow our [Claude Code integration](/claude-code) setup (or read our full [pay-as-you-go Claude Code without a subscription guide](/blog/claude-code-api-without-subscription)) by merging these keys into `~/.claude/settings.json`: ```json { "env": { "ANTHROPIC_BASE_URL": "https://api.beatapi.io", "ANTHROPIC_AUTH_TOKEN": "", "ANTHROPIC_MODEL": "claude-opus-5-5", "CLAUDE_CODE_SUBAGENT_MODEL": "claude-sonnet-5-5", "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1" } } ``` Restart Claude Code and switch or pin exact model IDs inside any session (verify live rates on [BeatAPI pricing](/pricing)): ```text /model claude-haiku-5-5 /model claude-sonnet-5-5 /model claude-opus-5-5 /model claude-fable-5-2 ``` Avoid three common setup errors when routing through a gateway. First, set `ANTHROPIC_BASE_URL` to `https://api.beatapi.io` with **no `/v1` suffix**, because Claude Code appends `/v1/messages` automatically. Second, `ANTHROPIC_BASE_URL` only changes where requests go—verify which IDs are active for your key via `GET /v1/models` rather than assuming every alias maps identically. Third, if you previously signed in to a claude.ai subscription and see an `Auth conflict` warning on startup, run `/logout` inside Claude Code to drop the session token and keep your API key; see our [Claude Code privacy checklist](/blog/claude-code-privacy-checklist) for keeping credentials safely out of project files. ### Non-Claude models on BeatAPI `POST /v1/messages` and their honest boundaries In addition to Claude 5.x, BeatAPI's `POST /v1/messages` endpoint accepts several non-Claude coding and reasoning models under the same API key for ultra-low-cost scripting or cross-model verification: | Non-Claude model (BeatAPI model ID) | Context / max output | BeatAPI retail price (in / out / cache read per 1M) | Best fit | | --- | --- | --- | --- | | [DeepSeek V4.1 Flash](/deepseek-v4-1-flash-api) (`deepseek-v4.1-flash`) | See catalogue | $0.075 / $0.30 / $0.0015 | Ultra-low-cost batch code tasks (see [Opus 5.5 vs DeepSeek V4.1 Flash](/blog/claude-opus-5-5-vs-deepseek-v4-1-flash-1017)) | | [GLM 5.3](/glm-5-3-api) (`glm-5.3`) | 1M / 128K | $0.56 / $1.76 / $0.104 | Balanced 1M-context coding and bilingual reasoning (`glm-5.3-flash` at $0.06 / $0.20) | | [Kimi K3.1 Pro](/kimi-k3-1-pro-api) (`kimi-k3.1-pro`) | 1,048,576 / — | $0.80 / $4.00 / $0.08 | Long-context repository reading and multi-step tool chains | | [Qwen 4 Max](/qwen4-api) (`qwen4-max`) | See catalogue | $1.20 / $3.60 / $0.06 | General reasoning and low cache-read code generation | Keep protocol boundaries clear before routing non-Claude IDs into Claude Code. Anthropic builds Claude Code specifically for Claude models and does not support routing Claude Code to GPT or Gemini. While BeatAPI serves DeepSeek, GLM, Kimi, and Qwen on `POST /v1/messages` (reachable in Claude Code via `ANTHROPIC_CUSTOM_MODEL_OPTION` or an explicit ID), request-format compatibility does not guarantee Anthropic-specific adaptive thinking, Fast Mode, preserved-thinking prefix checks, or experimental `anthropic-beta` headers. Meanwhile, GPT models on BeatAPI run on OpenAI Chat Completions and Responses rather than `/v1/messages`, so run GPT models in Codex CLI or another OpenAI-native agent through [BeatAPI integrations](/integrations) using the exact same BeatAPI key.

Frequently asked questions

### What is the best model for Claude Code in 2026? **Claude Opus 5.5** (`medium` effort) is the best overall model for Claude Code in 2026 ($4 / $20 official, $2 / $10 on BeatAPI) and is Anthropic's built-in account default. Choose **Claude Sonnet 5.5** ($2 / $10 official, $1 / $5 on BeatAPI) for clearly scoped daily edits when paying full official rates, **Claude Fable 5.2** ($8 / $40 official, $4 / $20 on BeatAPI) for multi-hour autonomous runs and hard bugs that stall Opus 5.5, and **Claude Haiku 5.5** ($0.10 / $0.50 up to 100K official, $0.05 / $0.25 on BeatAPI) for fast, narrow subagents. ### Is Claude Opus 5.5 better than Claude Sonnet 5.5 for coding? Claude Opus 5.5 outperforms Claude Sonnet 5.5 on ambiguous, multi-file debugging and architecture work, while Claude Sonnet 5.5 is faster and half the official per-token rate on straightforward edits. On Anthropic's 478-task SWE-bench Pro subset, Claude Opus 5.5 at `low` effort matched Sonnet 5.5 at `high` (87.4% vs 87.6%) for only 7% more per solved task ($0.12 vs $0.11), and on BeatAPI both models share a $0.10 per million cache-read rate so a 90%-cached Opus 5.5 session costs the same as an official cached Sonnet 5.5 session. ### Do I need to upgrade Claude Code to use Claude 5.5 or Fable 5.2? Yes. Claude Opus 5.5 requires Claude Code v2.1.280 or later, Claude Sonnet 5.5 requires v2.1.284 or later, Claude Haiku 5.5 requires v2.1.293 or later, and Claude Fable 5.2 requires v2.1.321 or later. Run `claude update` and re-open `/model` if any model is missing. ### Should large repositories always use Claude Fable 5.2? No. Claude Haiku 5.5, Sonnet 5.5, Opus 5.5, and Fable 5.2 all share a 1,000,000-token context window, so repository size alone does not justify paying $8 / $40 officially ($4 / $20 on BeatAPI). Give Opus 5.5 or Sonnet 5.5 focused context and reliable tests first, and switch to Claude Fable 5.2 only when Opus 5.5 still fails after raising effort. ### Which model should Claude Code subagents use, and why can Haiku 5.5 get expensive? Set `CLAUDE_CODE_SUBAGENT_MODEL` to **Claude Sonnet 5.5** for implementation and review subagents (which cut total cost by 31% at matched accuracy in Anthropic's 22M-token Python defect-search test), and pin read-only file-search or log-triage subagents to **Claude Haiku 5.5**. Haiku 5.5 bills jump unexpectedly when a single prompt crosses 100,000 tokens—triggering a 5x long-context rate jump—or when hard tasks cause repeated failed retries. ### Does raising effort make a model smarter, and what resets Claude Code's Prompt Cache? Raising effort does not change a model's underlying weights; it increases how many files Claude reads, how many tool calls it runs, and how thoroughly it verifies its changes. Switching models mid-session with `/model` or toggling Plan Mode under `opusplan` invalidates the warm Prompt Cache and forces a 1.25x cache write, whereas adjusting `/effort` mid-session on Claude Fable 5.1/5.2, Opus 5.5, Sonnet 5.5, and Haiku 5.5 preserves the warm cache on API keys and Claude subscriptions. ### Can Claude Code use GPT or Gemini models? Anthropic builds Claude Code for Claude models and does not support routing Claude Code to GPT or Gemini. Use Codex CLI or another OpenAI-compatible coding agent for GPT models (all supported under one key on [BeatAPI integrations](/integrations)). While BeatAPI accepts DeepSeek, GLM, Kimi, and Qwen on `POST /v1/messages`, non-Claude models do not guarantee Claude Code's Anthropic-specific adaptive thinking or Fast Mode behavior.

Three steps to dial in your Claude Code setup today

Stop guessing between models and verify your own baseline in one afternoon. First, pin your main session to `claude-opus-5-5` at default `medium` effort, set `CLAUDE_CODE_SUBAGENT_MODEL` to `claude-sonnet-5-5`, and lock read-only search subagents to `haiku` under 100K input tokens. Second, finish two real pull requests and run `/usage` to confirm your `Prompt cache (main)` hit ratio stays above 80%, switching models only after `/clear` instead of mid-thread. Third, route Claude Code through [BeatAPI Claude Code integration](/claude-code) to cut Claude 5.x token rates by 50%, check live model tiers on [BeatAPI pricing](/pricing), or compare subscription caps against API spend in our [Claude Max vs Ultra breakdown](/blog/claude-max-vs-ultra).