Claude Fable 5.1 is Anthropic's current top-capability model, released on 1 September 2026 and positioned for demanding reasoning and long-horizon agentic work.
- Input
- text image $10/M
- Output
- text $50/M
- Cache read
- $0.25/M
- Context
- 1M
- Knowledge cutoff
- 2026-06
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 70 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,000,000 |
|---|---|
| Max output (vendor spec) | 128,000 |
| Knowledge cutoff | 2026-06 |
Prompt caching
| How it caches | explicit (opt-in) |
|---|---|
| Min prefix | 1,024 |
| Lifetime | 5m default, 1h option |
| Write cost | 1.25x (5m) / 2x (1h) |
Thinking
| Vendor control | output_config.effort (thinking is adaptive-only and always on) |
|---|---|
| Accepted values | effort low · medium · high · xhigh · max |
| Default | thinking always on (adaptive); effort high applied when the request sets nothing |
| Can be turned off | No |
| Thinking behaviour | Effort can be changed per message mid-conversation without invalidating the prompt cache (beta). Turn-scoped system messages and readable progress updates between tool calls are the other additions, both beta. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface; the vendor mapping above applies |
Model
| Modalities | text + image → text |
|---|
- Extends Claude Fable 5 at the same input and output prices with cache reads at a quarter of the cost
- three changes break callers moving from Fable 5, because forced tool use returns an error, thinking blocks are tied to the model that produced them, and editing an earlier turn invalidates them
One prompt, measured through the gateway
Claude Fable 5.1 passed · 3 sentences
When we enabled reasoning, the model started generating a long chain of internal "thinking" tokens before producing each answer, and we're billed for those tokens at the same output rate even though users never see them. In practice, that hidden reasoning often runs several times longer than the visible response, so the total tokens per request roughly doubled while the number of requests stayed flat. The upside is measurably better accuracy on complex tasks, so the right conversation is whether that quality gain justifies the cost—and if not, we can restrict reasoning to the workflows that actually need it rather than turning it on globally.
out 186 tok latency 3.2 s
Instruction following (exactly three sentences, so countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Claude Fable 5.1 passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): cur = cur + 1 if xs[i] == xs[i - 1] else 1 best = max(best, cur) return best ``` The bug is that `cur` counts *matches between adjacent elements* rather than *elements in the run*: it starts at 0 and only increments when `xs[i] == xs[i-1]`, so a run of length k produces a count of k−1. That's why a single element returns 0 instead of 1, and why every other run also comes out one short — the "misses runs at the end" reports are the same off-by-one seen on inputs like `[1, 2, 2]`, where the trailing run of length 2 is reported as 1 (the original code does update `best` inside the loop, so end-of-list runs aren't actually skipped, just undercounted). […]
out 882 tok (+507 thinking) latency 3.4 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Claude Fable 5.1 passed · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "Q3 (September quarter)", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ``` Notes on judgment calls (not part of the object): - **revenue_usd_m**: The text says "412 for the topline" but never states the currency or that the figure is in millions; it's also on a constant-currency basis and prefaced with "call it," so it's approximate. If you want strict literalism, this should be `null`. - **growth_pct**: "Eleven and change" means slightly above 11%; the exact figure isn't given. - **quarter**: "September quarter" is Q3 on a calendar basis, consistent with the reference to a pending Q4 close. - **guidance**: Explicitly withheld, so `null`.
out 633 tok (+349 thinking) latency 3.8 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Claude Fable 5.1 passed · 121 words, 0 banned, 1 question
**Introducing Cross-Provider Prompt Caching for the Gateway.** Starting today, your API gateway can cache prompts once and reuse them across OpenAI, Anthropic, Google, and any other provider you route to. Long system instructions, retrieval context, and few-shot examples are stored at the gateway layer, so switching models no longer means paying to resend the same tokens. Why send the same 8,000-token preamble to three different vendors when you could send it once? Our cache normalizes prompt segments, fingerprints them, and serves matching prefixes from memory before the request ever reaches an upstream API. Early customers report token costs falling by 30 to 60 percent on high-volume workloads, with median latency dropping alongside. Available today on all Team and Enterprise plans.
out 1722 tok (+1463 thinking) latency 2.9 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Claude Fable 5.1 in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="claude-fable-5-1",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "claude-fable-5-1",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "claude-fable-5-1",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "claude-fable-5-1",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("claude-fable-5-1")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Claude Fable 5.1
- Anthropic's own guidance still starts most workloads on Claude Opus 5 and reserves this tier for cases where Opus 5 at higher effort still falls short.
- It keeps the shape of Claude Fable 5 exactly: a 1M-token context window, 128K output tokens, text and image in and text out, and adaptive thinking that is always on with effort defaulting to high.
- The reason to move up is cost behaviour and agentic endurance rather than a larger window.
- Input and output stay at $10 and $50 per million tokens while cache reads drop to a quarter of the earlier rate, and Anthropic reports roughly 25% lower cost on a typical workload and about 45% on a highly agentic one.
- Three changes are breaking for callers coming from Fable 5: forced tool use now returns an error, thinking blocks are tied to the model that produced them so earlier Claude models cannot read them, and editing an earlier turn invalidates them.
- The additions are backward compatible, and three of the five are in beta: per-message effort, turn-scoped system messages, and readable progress updates between tool calls; the lower cache read price and content provenance are generally available.
- Claude Mythos 5.1 offers the same capabilities to Project Glasswing participants only.
- Synthorai serves it through the OpenAI-compatible chat endpoint as an invite-only beta.
FAQ
Is the Claude Fable 5.1 API free to try?
Claude Fable 5.1 is currently in invited beta: access is application-based rather than open signup. Apply from the Synthorai console; once approved, standard pay-as-you-go pricing applies with no subscription.
What is Claude Fable 5.1 best at?
1M-token context window and 128K output; cache reads at a quarter of Fable 5's rate; forced tool use is no longer supported. See the About section for the full picture from the vendor's own release notes.
How much does Claude Fable 5.1 cost?
Claude Fable 5.1 costs $10 per million input tokens and $50 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.25/M.
What is Claude Fable 5.1's context window?
Claude Fable 5.1 has a context window of 1M tokens on Synthorai. A single response can be up to 128,000 tokens long.
Does Claude Fable 5.1 support prompt caching?
Yes, via opt-in: mark stable prefixes with cache_control breakpoints. Cached input tokens bill at $0.25/M vs $10/M uncached; prompts need a 1,024-token stable prefix to cache (TTL 5m default, 1h option). Prompt caching guide →
How do I get access to Claude Fable 5.1?
Claude Fable 5.1 is in invited beta: request access from the Synthorai console. Once approved it works like every other model: point your OpenAI SDK at base_url="https://synthorai.io/v1" and set model="claude-fable-5-1".
What is Claude Fable 5.1's knowledge cutoff?
Claude Fable 5.1's knowledge cutoff is 2026-06, per the vendor's official documentation (as of 2026-09-05).
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.