Claude Fable 5.2: Claude Code Setup, API Pricing, and Opus Comparison
Try Claude Fable 5.2 in Claude Code 2.1.321 or later and the Messages API, verify a real coding task, and choose effort deliberately. Compare token prices with published cost-per-task results, understand fast-mode billing and platform differences, and avoid thinking, forced-tool, and conversation-history migration errors.
Contents
Try Claude Fable 5.2 when higher-effort Opus 5.5 still fails your coding checks; otherwise, keep Opus as your daily driver. Start at medium in Claude Code or high in the API, following Anthropic’s model guidance. Compare the cost of accepted changes, because a higher token price can still produce a cheaper completed task.
Released on November 9, 2026, Fable 5.2 uses the API ID claude-fable-5-2. As of 2026-11-12, its model reference lists a 1M-token context window and 128K maximum output.
Select Fable 5.2 in Claude Code and verify a real edit
Use Claude Code 2.1.321 or later, then select the full model ID. The official changelog identifies 2.1.321 as the release that added Fable 5.2.
You need an installed, authenticated Claude Code client and an account or provider that permits this model. Before sending private code, check your organization’s approval for Fable’s Covered Models data-handling policies.
For a native installation, run these commands in Bash:
claude update
claude --versionFor package-manager installations, follow the matching update instructions. Confirm that the reported version is at least 2.1.321; do not assume that an older installation updated successfully.
In an existing session, run:
/model claude-fable-5-2The phrase “default Fable model” does not mean Fable becomes everyone’s default. The model configuration reference says no Fable model is the account-type default.
For a clean test, use Bash and Python 3 to create a disposable directory:
workdir="$(mktemp -d)"
cd "$workdir"
cat > clamp.py <<'PY'
def clamp(value, low, high):
return min(low, max(value, high))
PY
cat > test_clamp.py <<'PY'
from clamp import clamp
assert clamp(-2, 0, 10) == 0
assert clamp(5, 0, 10) == 5
assert clamp(12, 0, 10) == 10
print("3 checks passed")
PY
claude --model claude-fable-5-2 --effort mediumThese CLI flags select the model and effort for the session. Check /model before starting. If the effort differs, inspect CLAUDE_CODE_EFFORT_LEVEL; that environment variable takes precedence over the launch flag.
Give Claude Code this task:
Read clamp.py and test_clamp.py.
Fix clamp.py so all existing assertions pass.
Do not edit test_clamp.py.
Run python3 test_clamp.py and report the exact result.
Do not use subagents.Keep permission checks enabled. Approve only the file and command operations appropriate for this directory.
After the agent finishes, exit Claude Code and independently run:
python3 test_clamp.pyThe expected result is 3 checks passed, with the test file unchanged. A proposed patch without an applied edit and passing test is not a successful check. This verifies the tool path, not Fable’s advantage over another model.
Make your first claude-fable-5-2 API request
Use the direct Anthropic Messages API first to separate model behavior from gateway configuration. This example needs Bash, curl with --fail-with-body, jq, and an Anthropic-issued API key.
Create your own key through the Console API-key instructions, selecting a specific workspace. A workspace-scoped key lets this example omit anthropic-workspace-id, as documented in API authentication.
Paste the key when read waits, then press Enter:
read -rs ANTHROPIC_API_KEY && export ANTHROPIC_API_KEYSend a synchronous request:
curl --silent --show-error --fail-with-body \
https://api.anthropic.com/v1/messages \
--header "Authorization: Bearer ${ANTHROPIC_API_KEY}" \
--header "anthropic-version: 2026-10-21" \
--header "content-type: application/json" \
--data '{
"model": "claude-fable-5-2",
"max_tokens": 4096,
"output_config": {
"effort": "high"
},
"messages": [
{
"role": "user",
"content": "Fix this Python function and return the corrected function plus three assertions: def clamp(value, low, high): return min(low, max(value, high))"
}
]
}' \
--output fable-response.json &&
jq '{
model,
stop_reason,
usage,
text: [.content[] | select(.type == "text") | .text]
}' fable-response.jsonThe request uses the current API version header and the documented output_config.effort field. It omits thinking because Fable 5.2 already uses adaptive thinking.
Check the returned model, nonempty text, usage, and stop_reason. A natural completion normally returns end_turn; max_tokens means the output reached your limit. Follow the stop-reason guidance and raise the output budget before treating truncation as a quality failure.
If the HTTP request fails, inspect the saved error:
jq '.error' fable-response.jsonThis request returns code as text. It does not read local files or execute the assertions. Review its output before running it.
BetterToken also lists claude-fable-5-2 as of 2026-11-12. Its Claude Code integration uses Base URL https://bettertoken.ai. Follow that route’s authentication instructions separately; a model listing does not establish support for every effort or fast-mode parameter.
Compare token prices with cost per completed task
Fable 5.2 costs less per token than Fable 5.1, but twice as much as Opus 5.5 at standard API rates. These are Anthropic’s published prices, in USD per million tokens, as of 2026-11-12.
| Model, standard speed | Uncached input | Output |
|---|---|---|
| Claude Fable 5.1 | $10 | $50 |
| Claude Fable 5.2 | $8 | $40 |
| Claude Opus 5.5 | $4 | $20 |
| Claude Sonnet 5.5 | $2 | $10 |
The Fable 5.1-to-5.2 input and output reductions are both 20%. That is a unit-price reduction, not a guarantee of a 20% smaller session bill.
Fable 5.2’s standard-speed cache rates are $10 for five-minute writes, $16 for one-hour writes, and $0.20 for reads. Each rate is per million tokens. Its asynchronous Batch input/output rates are $4/$20; those are not interactive Claude Code rates.
For an estimated workload of 100,000 uncached input tokens and 20,000 billed output tokens:
Fable 5.2: 0.1 × $8 + 0.02 × $40 = $1.60
Opus 5.5: 0.1 × $4 + 0.02 × $20 = $0.80This calculation assumes standard speed, global pricing, no cache operations, no paid tools, and no Batch discount. It excludes applicable taxes. It holds token counts equal, which real agent sessions often do not.
Anthropic’s FrontierCode 2.0 announcement compares a different quantity. Fable 5.2 at High effort scored 45.3%, versus Opus 5.5’s best 45.5%, at roughly half the reported cost per task. The comparison uses Fable High against Opus Max, not equal token volumes or equal effort.
Cursor’s current CursorBench 4.0 results show why the result is workload-specific. Fable 5.2 High scores 56.9% at a reported cost of $9.70, while Opus 5.5 High scores 56.0% at $3.97. Fable 5.2 Max reaches 60.0% at $32.79.
Those are evaluation results from their publishers, not subscription prices or measurements on your repository. Cursor labels the 56.9% row High, not Claude Code’s default Medium.
Use the cost-per-task evaluation guide to include retries, failed attempts, and agent execution settings in your comparison.
Enable fast mode only when output speed matters
Enable fast mode for latency-sensitive work after the standard request succeeds. Anthropic advertises up to 2.5 times faster token generation, not a guaranteed 2.5-times-faster complete coding task.
For the direct Messages API, keep claude-fable-5-2 and add this top-level field to the request body:
"speed": "fast"No fast-mode beta header is required. On a successful request, verify usage.speed is "fast", as described in the fast-mode API guide.
Fable 5.2 fast-mode input/output prices are $16/$80 per million tokens, as of 2026-11-12. The documented default fast-mode limits apply to the Start, Build, and Scale usage tiers. If you exceed a fast-mode rate limit, the API returns 429 with retry-after. Respect that delay, or deliberately remove speed and retry at standard speed.
In Claude Code, select Fable 5.2 and run /fast. On subscription plans, fast mode draws directly from usage credits even when included plan usage remains. Check the Claude Code requirements before enabling it.
Google Cloud’s Vertex/Agent Platform route needs Claude Code 2.1.322 or later for fast mode. Its supported regions are global, us, and eu; follow the provider-specific instructions.
The cURL configuration above is for Anthropic’s direct API. Do not copy it unchanged to another cloud provider’s endpoint.
Avoid the relevant 400 errors when migrating
Audit request parameters and conversation history before changing production traffic. Always-on adaptive thinking and forced-tool restrictions already applied to Fable 5.1 and Opus 5.5; they are not new restrictions introduced by Fable 5.2.
The Fable 5.2 compatibility guidance documents these failures:
| Request pattern | Result | Fix |
|---|---|---|
thinking: {"type": "enabled"} with budget_tokens | 400 | Omit thinking, or use {"type": "adaptive"}. Control depth through effort. |
thinking: {"type": "disabled"} | 400 | Remove it. Adaptive thinking cannot be disabled. |
tool_choice: {"type": "any"} | 400 invalid_request_error | Use {"type": "auto"} and handle the possibility of a text response. |
tool_choice: {"type": "tool", "name": "..."} | 400 invalid_request_error | Remove the forced selection and handle tool choice in your application. |
For schema-valid tool arguments, use strict: true with automatic tool choice where supported. Strictness constrains arguments; it does not force invocation. JSON outputs are another option. In organizations using customer-managed encryption keys, neither strict tool use nor JSON outputs is available for Fable 5.2. Validate outputs in application code there.
A genuinely important migration change is stricter conversation-prefix checking. Fable 5.2 enforces it for every account, including older accounts whose Fable 5.1 requests previously passed.
The recognizable error includes:
The block is bound to a different conversation.It can occur when you resend a thinking block after changing the system prompt, tools, or earlier conversation content. Retrying that same request does not repair the mismatch.
Follow the preserved-thinking rules: keep the existing prefix unchanged, append new messages, and return assistant content arrays exactly as received. For a simple integration, start a new conversation when replacing the original system prompt or tool definitions.
Applications using computer use or advisor tools should also review the full migration guide before deployment.
Adjust effort and completion checks for longer work
Use effort settings rather than prompt wording to control thinking. Anthropic reports that requests to answer without deliberating do not suppress Fable 5.2’s thinking at medium and above.
The model-specific prompting guide also describes early stopping on multistep tasks, particularly at low and medium. An end_turn response means the turn ended; your acceptance checks still decide whether the work is complete.
For a bounded repository task, make completion conditions explicit:
Complete the requested change and run the relevant tests.
Do not stop after a plan or a list of remaining steps.
Continue through ordinary implementation failures within the approved scope.
Stop and report the blocker if you need unavailable credentials,
destructive actions, or a decision that changes the requested scope.
Do not start subagents for this trial.For long coding tasks, compare high with your medium baseline. Try xhigh only when measured gains justify the extra work. Reserve max for ceiling measurements or unusually expensive failures.
Delegation also changes cost. Anthropic says Fable readily delegates when the surrounding agent system invites it, and subagents can consume a large part of a session’s budget. Record their models and usage before attributing the entire bill to the main model.
Which model should you keep?
Keep Sonnet 5.5 for bounded changes with clear tests when its output already meets your requirements. Its lower token rates make it a sensible first trial for repetitive edits. Move up when review finds missed dependencies or repeated repair attempts.
Keep Opus 5.5 for general repository work unless Fable produces a measurable improvement. The Opus selection guide explains how to switch back and keep that choice selected.
Test Fable 5.2 on difficult diagnosis, cross-file changes, and long migrations that higher-effort Opus still gets wrong. Choose it when the improvement in accepted changes or total completion cost outweighs its higher token rates.
After the setup check, compare models on the same starting commit and acceptance tests. Record effort, elapsed time, cache usage, subagent usage, and all failed attempts. Keep the less expensive configuration that passes your actual checks; a benchmark score alone should not replace that decision.
