Claude Fable 5 è il modello più capace tra quelli a rilascio ampio di Anthropic, costruito per il ragionamento più impegnativo e per il lavoro agentico a lungo orizzonte, descritto come "intelligenza di nuova generazione per agent a lungo termine".
- Input
- testo immagine $10/M
- Output
- testo $50/M
- Lettura cache
- $1/M
- Contesto
- 1M
- Knowledge cutoff
- 2026-01
Benchmark
Dati pubblicati dai provider: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Il prezzo a confronto
Dove si colloca il prezzo tra 68 modelli confrontabili
La barra mostra dove si colloca il prezzo di questo modello tra tutti i modelli dello stesso tipo su Synthorai. Alle due estremità sono indicati il più economico e il più caro. Sono tariffe base; gli sconti per batch, regione e scrittura in cache sono nella pagina dei prezzi.
Specifiche e limiti
Token
| Finestra di contesto (specifica del provider) | 1.000.000 |
|---|---|
| Output massimo (specifica del provider) | 128.000 |
| Knowledge cutoff | 2026-01 |
Prompt caching
| Modalità | esplicito (opt-in) |
|---|---|
| Prefisso min. | 512 default del provider: 1.024 |
| Durata | 5 min predefinito, 1 ora opzionale |
| Costo di scrittura | 1.25x (5m) / 2x (1h) |
Ragionamento
| Parametro del provider | output_config.effort (thinking.type is adaptive-only and needs no configuration) |
|---|---|
| Valori accettati | effort low · medium · high · xhigh · max; both "enabled" and "disabled" return 400 |
| Valore di default | thinking sempre attivo (adattivo); effort high applicato se la richiesta non specifica nulla |
| Disattivabile | No |
| Comportamento del ragionamento | Il thinking non può essere disattivato, quindi usa display "omitted" (qui il valore predefinito) per tenere il testo del thinking fuori dalle risposte; la chain of thought grezza non viene mai restituita, e una richiesta che tenta di far emergere il ragionamento interno come testo di risposta può essere rifiutata con stop_details.category "reasoning_extraction". |
| Parametro | reasoning_effort |
| Valori | minimal · low · medium · high parametri esposti dal gateway: vale la mappatura del provider indicata sopra |
Modello
| Modalità | testo + immagine → testo |
|---|
- Esegue il thinking adattivo sempre attivo con controllo della profondità basato sull'effort
- include classificatori di sicurezza con meccaniche documentate di fallback e di credito di fatturazione
Un solo prompt, misurato attraverso il gateway
Claude Fable 5 superato · 3 sentences
When we enabled reasoning, the model began generating extensive internal "thinking" tokens before each answer, and those tokens are billed as output even though users never see them. Output tokens typically cost several times more than input tokens, so adding thousands of hidden reasoning tokens per request effectively multiplied our per-query cost. In short, we're paying for a much longer response behind the scenes in exchange for higher answer quality, and we can manage this by tuning reasoning effort levels or reserving reasoning mode for complex tasks only.
out 228 tok latenza 6.7 s
Rispetto delle istruzioni (esattamente tre frasi: si contano), adattamento al destinatario (registro da CFO) e lo scarto di fatturazione dovuto al ragionamento nascosto, che i contatori di token qui sotto mettono in luce.
Claude Fable 5 superato · 8/8 cases
## Fixed code ```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` ## Explanation The original function counts **adjacent equal pairs** rather than **items in a run**: a run of length *n* contains only *n − 1* equal neighbor pairs, so every result is off by one — a single-element list yields 0 instead of 1, and `[1, 2, 2]` yields 1 instead of 2 (which callers perceive as "missing" the run at the end). The fix is to initialize both `cur` and `best` to 1 (any nonempty list has a run of at least length 1), reset `cur` to 1 rather than 0 when
out 531 tok latenza 12.5 s
Se la correzione è davvero giusta (si può eseguire), quanto è densa la spiegazione e quanti token servono per un compito circoscritto.
Claude Fable 5 superato · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "Q3 (September quarter)", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null } ``` Notes on interpretation: "up eleven and change" is rendered as 11 (the precise figure isn't stated), and guidance is null because it was explicitly withheld.
out 192 tok latenza 6.5 s
Aderenza allo schema (nessun campo inventato), tentazione di allucinare (il testo dice espressamente che la guidance non viene comunicata) e differenze tra i percorsi di output strutturato.
Claude Fable 5 superato · 120 words, 0 banned, 1 question
**Introducing Cross-Provider Prompt Caching for our API Gateway** Starting today, your repeated prompts are cached once and reused across OpenAI, Anthropic, Google, and any other provider you route through the gateway. Instead of paying full token costs every time your application sends the same system prompt or context block, the gateway detects matching prefixes and serves cached results in milliseconds. Why keep spending money and latency on identical requests? Early adopters report cost reductions of up to 60 percent on high-volume workloads, along with faster median response times. Configuration is simple: enable caching in your dashboard, set a TTL, and choose which routes participate. Cache entries are encrypted at rest and never shared between accounts. Available now on all plans.
out 1173 tok latenza 18.2 s
Rispetto dei vincoli (budget di parole, elenco di parole vietate, l'unica domanda), impronta stilistica e controllo della lunghezza.
Usa Claude Fable 5 in 30 secondi
Compatibile con OpenAI: cambi base_url e tieni il tuo 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",
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",
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",
"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",
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")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));Informazioni su Claude Fable 5
- La guida alla scelta del modello di Anthropic lo riserva ai carichi di lavoro che richiedono la massima capacità disponibile, ossia agent a lungo termine, ragionamento profondo e ricerca avanzata, mentre indirizza il livello Opus al coding agentico complesso di tutti i giorni e al lavoro enterprise.
- Esegue il thinking adattivo sempre attivo con controllo della profondità basato sull'effort, supporta una finestra di contesto da 1M di token e 128K token di output, e viene lanciato con lo strumento di memoria, l'esecuzione di codice, il tool calling programmatico, la compaction e la vision.
- Il thinking non può essere disattivato: entrambi i tipi di thinking, enabled e disabled, restituiscono un 400, la chain of thought grezza non viene mai restituita e i riassunti sono opzionali tramite l'impostazione di visualizzazione del thinking.
- L'effort va da low fino a max, xhigh incluso, con high come predefinito, e Anthropic nota che le sue impostazioni di effort più basse superano spesso le prestazioni a xhigh dei modelli precedenti.
- Il caching dei prompt parte da un prefisso minimo di 512 token, il più basso della lineup.
- In modo unico, include classificatori di sicurezza che possono rifiutare le richieste, con meccaniche documentate di fallback e di credito di fatturazione.
- I rifiuti arrivano come una risposta riuscita che porta uno stop reason di rifiuto e una categoria, e una richiesta rifiutata prima che venga generato qualsiasi output non viene fatturata.
- Il prefill dell'assistente e i parametri di sampling non predefiniti restituiscono entrambi errori.
- Synthorai serve Claude Fable 5, attualmente una beta su invito sulla piattaforma, tramite il suo endpoint compatibile OpenAI.
FAQ
L'API di Claude Fable 5 si può provare gratis?
Sì: i nuovi account ricevono 10 chiamate di prova e fino a $1 di credito gratuito, senza bisogno di carta. A $10/M per i token di input, quel credito basta da solo per circa 12 richieste da ~8K token a Claude Fable 5.
In cosa eccelle Claude Fable 5?
Thinking adattivo sempre attivo con controllo basato sull'effort; finestra di contesto da 1M di token e 128K di output; classificatori di sicurezza che possono rifiutare le richieste. Il quadro completo è nella sezione «Informazioni», ripreso dalle note di rilascio ufficiali del provider.
Quanto costa Claude Fable 5?
Su Synthorai Claude Fable 5 costa $10 per milione di token di input e $50 per milione di token di output: è il prezzo di listino del provider, senza sovrapprezzo di piattaforma. I token di input letti dalla cache costano $1/M.
Qual è la finestra di contesto di Claude Fable 5?
Claude Fable 5 ha una finestra di contesto di 1M token su Synthorai. Una singola risposta può arrivare a 128,000 token. Claude Fable 5 non è più disponibile qui; il suo successore è Claude Fable 5.1.
Claude Fable 5 supporta il prompt caching?
Sì, con opt-in: contrassegna i prefissi stabili con i breakpoint cache_control. I token di input letti dalla cache costano $1/M, contro $10/M senza cache; per andare in cache un prompt deve avere un prefisso stabile di 512 token (TTL 5 min predefinito, 1 ora opzionale). Guida al caching di Claude Fable 5 →
Come ottengo l'accesso a Claude Fable 5?
Fai puntare l'SDK OpenAI che usi già a base_url="https://synthorai.io/v1", imposta model="claude-fable-5" e hai finito: una sola chiave API vale per tutti i modelli del gateway.
Qual è il knowledge cutoff di Claude Fable 5?
Il knowledge cutoff di Claude Fable 5 è 2026-01, secondo la documentazione ufficiale del provider (dato aggiornato al 2026-07-09).
Modelli correlati
Confronta
Ogni valore di questa pagina è ripreso dalla documentazione del provider (il link è qui sopra) e riporta la data dell'ultima verifica. I prezzi sono confrontati sull'intero catalogo; per le specifiche che ogni provider definisce a modo suo indichiamo la differenza invece di metterle in un grafico. Qui non c'è nulla di misurato da noi e non assegniamo punteggi.