Claude Fable 5.1 vs GPT-6 Luna
Claude Fable 5.1 è disponibile su invito. Le cifre sottostanti sono le tariffe in tempo reale, ma le chiamate richiedono prima un'autorizzazione per il workspace; richiedici l'accesso prima di basare il tuo sviluppo su questo confronto.
Quale scegliere e quando
Entrambi accettano testo e immagini in input e restituiscono testo, limitano l'output a 128,000 token e offrono circa un milione di token di contesto (1,000,000 per claude-fable-5-1, 1,050,000 per gpt-6-luna), quindi la vera differenza è il prezzo e il controllo sul thinking. gpt-6-luna costa $0.1 in input e $0.5 in output per milione contro $10 e $50, 100x più economico su entrambe le direzioni, con letture dalla cache a $0.01 contro $0.25, e il suo thinking può essere disattivato, il che si adatta a lavori ad alto volume o sensibili alla latenza. Scegli claude-fable-5-1 quando desideri la modalità di ragionamento sempre attiva di Anthropic e sei disposto a pagarla.
Benchmark
Dati pubblicati dai fornitori: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Prezzi
| Claude Fable 5.1 | GPT-6 Luna | Δ | |
|---|---|---|---|
| Input / 1M token | $10 | $0.1 | 100× |
| Output / 1M token | $50 | $0.5 | 100× |
| Lettura cache / 1M token | $0.25 | $0.01 | 25× |
| Scrittura in cache | 1.25x (5m) / 2x (1h) | nessun addebito separato | - |
Le tariffe provengono dal catalogo live al momento della build; la pagina di ciascun modello riporta la scheda attuale.
Dove si posizionano - prezzo di input per 1M di token rispetto a tutti gli 74 modelli chat con questa unità di fatturazione (scala logaritmica)
Capacità
| Claude Fable 5.1 | GPT-6 Luna | |
|---|---|---|
| Utilizzo dei tool | sì | sì |
| Controllo del ragionamento | sempre attivo | configurabile |
| Output strutturato | sì | sì |
| Prompt caching | esplicito (contrassegni il prefisso) | implicito (automatico) |
| Durata della cache | 5m default, 1h option | 5-10m, up to 1h |
| Prefisso minimo in cache | 1024 token | 1024 token |
Specifiche
| Claude Fable 5.1 | GPT-6 Luna | |
|---|---|---|
| Modalità di input | testo immagine | testo immagine |
| Modalità di output | testo | testo |
| Rilascio | 2026-09-01 | 2026-09-22 |
| Cutoff di conoscenza | 2026-06 | 2026-05 |
| Finestra di contesto | 1M | 1.1M |
| Output massimo | 128K | 128K |
| Parametro thinking | output_config.effort (thinking is adaptive-only and always on) | reasoning.effort |
| Valori accettati | effort
| reasoning.effort
|
| Predefinito | thinking always on (adaptive) effort
| medium |
Le specifiche sono trascritte dalla documentazione di ciascun fornitore; una riga che un fornitore non pubblica viene omessa anziché essere dedotta. Fonti complete: Claude Fable 5.1 · GPT-6 Luna
Un solo prompt, entrambi i modelli - misurati attraverso il gateway
Claude Fable 5.1 superato · 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 latenza 3.2 s
GPT-6 Luna superato · 3 sentences
Enabling reasoning typically makes the model process more information and generate more internal tokens before producing its answer. Because usage is billed by tokens—and reasoning may also route requests to a more expensive model—the cost per request can rise sharply. If request volume stayed similar, that higher cost per request could explain why the bill doubled.
out 117 tok (+48 ragionamento) latenza 3.4 s
Rispetto dell'istruzione (esattamente tre frasi - contabili), adattamento al pubblico (registro da CFO), e il divario di fatturazione del pensiero nascosto che i contatori di token qui sotto rivelano.
Claude Fable 5.1 superato · 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 ragionamento) latenza 3.4 s
GPT-6 Luna superato · 8/8 cases
```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 ``` The original code counted matching *adjacent pairs* rather than items, so a run of length `n` was reported as `n - 1`, and a single-item input returned `0`. This version counts the current item as part of each run and updates `best` at every index, including the last; it returns `0` for an empty input.
out 514 tok (+356 ragionamento) latenza 6.9 s
Se la correzione è davvero giusta (eseguibile), la densità della spiegazione, e l'efficienza in token su un compito delimitato.
Claude Fable 5.1 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 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 ragionamento) latenza 3.8 s
GPT-6 Luna superato · 5/5 fields, guidance "Withheld pending the Q4 close"
{"company":"Meridian Robotics","quarter":"September quarter","revenue_usd_m":412,"growth_pct":null,"guidance":"Withheld pending the Q4 close"}
out 161 tok (+119 ragionamento) latenza 21.7 s
Aderenza allo schema (nessun campo inventato), pressione di allucinazione (guidance è esplicitamente sospesa), e differenze nel percorso di output strutturato.
Claude Fable 5.1 superato · 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 ragionamento) latenza 2.9 s
GPT-6 Luna superato · 120 words, 0 banned, 1 question
Introducing Prompt Cache, a new API gateway feature that recognizes repeat prompt prefixes and reuses provider-side cached context across supported models. Teams can route requests to different AI providers while preserving eligible cache hits, reducing redundant input processing and helping lower latency and token costs. Configure cache policies in one place, monitor hit rates by provider, and keep existing client integrations unchanged. The gateway applies provider-specific rules automatically, so developers do not need to build separate caching logic for each endpoint. Which workflows could benefit from faster responses and predictable spend? Prompt Cache is available today in preview for eligible accounts, with usage details, supported providers, and setup guidance in the dashboard. Start with one route, compare results, then expand.
out 959 tok (+813 ragionamento) latenza 14.6 s
Rispetto dei vincoli (budget di parole, elenco di parole vietate, l'unica domanda), impronta stilistica, e controllo della lunghezza.
Passa dall'uno all'altro con una sola riga
Entrambi gli id sono presenti in ogni scheda qui sotto - la coppia di righe evidenziata è l'unica modifica. Stesso endpoint, stessa chiave, stessa struttura della richiesta.
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",
# model="gpt-6-luna", # decommenta questa riga, commenta quella sopra
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",
// model: "gpt-6-luna", // decommenta questa riga, commenta quella sopra
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",
# "model": "gpt-6-luna", # decommenta questa riga, commenta quella sopra
"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",
// Model: "gpt-6-luna", // decommenta questa riga, commenta quella sopra
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")
// .model("gpt-6-luna") // decommenta questa riga, commenta quella sopra
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));FAQ
Qual è più economico, Claude Fable 5.1 o GPT-6 Luna?
GPT-6 Luna è più economico per input / 1m token ($0.1 contro $10, 100× di differenza). Altre righe potrebbero indicare il contrario - la tabella sopra riporta la scheda completa, e il costo reale dipende dal tuo mix.
Posso fare un A/B test di Claude Fable 5.1 contro GPT-6 Luna senza due integrazioni?
Sì. Entrambi sono serviti tramite lo stesso endpoint compatibile con OpenAI con una singola chiave API - il passaggio richiede la modifica della stringa del modello in una sola riga, quindi puoi instradare una frazione del traffico verso ciascuno e confrontare direttamente le fatture.
Claude Fable 5.1 e GPT-6 Luna supportano il prompt caching?
Sì - entrambi fatturano le letture in cache a un prezzo inferiore rispetto alla loro tariffa di input, quindi i carichi di lavoro con warm-prefix costano meno di quanto suggeriscano le tariffe di listino. Le righe esatte per la lettura in cache si trovano nella tabella dei prezzi qui sopra.