Claude Fable 5 API Guide

Um Claude Fable 5 aufzurufen, nutze die Modell-ID claude-fable-5 und schalte Thinking mit thinking: {"type": "adaptive"} ein. Das ist der ganze Happy Path. Die Fallen sind alles drumherum: Sampling-Parameter, die früher funktionierten, geben jetzt einen 400 zurück, und ein Parameter, der auf Opus 4.8 in Ordnung ist, bricht deinen Request auf Fable 5.

Fable 5 ist am 9. Juni 2026 als Anthropics fähigstes Modell gestartet, eine Stufe über Opus. Es hat ein 1M-Kontextfenster und eine Output-Obergrenze von 128K, und es kostet $10 pro Million Input-Tokens und $50 pro Million Output-Tokens. Das ist das Doppelte des Tarifs von Opus 4.8 – das ist also ein Modell, das du auf harte Probleme ansetzt, nicht auf Routinearbeit.

Das hier ist der praktische Guide. Wie du den Call machst, welche 400er auftauchen und warum, wie du Effort und Budgets tunest, wie sich Caching ändert und der eine Bedrock-Schritt, der dich blockiert, wenn du ihn auslässt.

Der minimale funktionierende Call

Fang hier an. Das ist der kleinste Call, der funktioniert, in Python mit dem offiziellen Anthropic SDK. Der Client liest deinen ANTHROPIC_API_KEY aus der Umgebung, wählt das Modell, schaltet adaptives Thinking ein und setzt Effort auf xhigh, weil das die richtige Einstellung für Coding- und agentische Arbeit ist.

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "Explain what a row-level security policy does."}],
)

print(message.content[0].text)

Die Modell-ID ist exakt der String claude-fable-5. Es gibt kein Datums-Suffix. Wenn du eins anhängst, bekommst du einen 404.

Wenn du gar kein Thinking willst, entferne die thinking-Zeile. Du setzt sie nicht auf disabled. Diese Unterscheidung ist der mit Abstand größte Stolperstein bei diesem Modell, und sie bekommt unten ihren eigenen Abschnitt.

Die 400er-Fallen

Fable 5 hat eine Reihe von Parametern fallen gelassen, die frühere Modelle akzeptiert haben. Sendest du einen davon, kommt ein HTTP 400 (invalid_request_error) zurück. Hier ist die volle Matrix, was bricht und wie man es behebt.

Ein Prefill bedeutet, dass dein messages-Array mit einem role: "assistant"-Turn endet, den du angefangen hast zu schreiben, damit das Modell ihn fortsetzt. Dieses Muster gibt auf Fable 5 einen 400 zurück. Wenn du es genutzt hast, um JSON zu erzwingen, wechsle zu Structured Outputs, weiter unten gezeigt.

Warum deaktiviertes Thinking einen 400 zurückgibt

Das ist die Falle, die "Drop-in"-Upgrades bricht, also lohnt es sich, hier präzise zu sein.

Auf Opus 4.8 und Opus 4.7 laufen zwei Dinge einen Request ohne Thinking: das thinking-Feld weglassen oder thinking: {"type": "disabled"} setzen. Sie sind austauschbar.

Auf Fable 5 sind sie es nicht. Ein explizites thinking: {"type": "disabled"} gibt einen 400 zurück. Nur das Weglassen des Felds läuft Thinking-frei. Code, der gestern auf Opus funktionierte und explizit disabled gesetzt hat, fängt also in dem Moment an zu fehlern, in dem du die Modell-ID tauschst.

Dieses Snippet zeigt die kaputte und die funktionierende Version nebeneinander. Die erste gibt auf Fable 5 einen 400. Die zweite läuft ohne Thinking, was die erste eigentlich versuchte.

# WRONG on Fable 5 - returns a 400
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    thinking={"type": "disabled"},
    messages=[{"role": "user", "content": "Classify this ticket as bug or feature."}],
)

# RIGHT - omit the thinking param to run without thinking
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Classify this ticket as bug or feature."}],
)

Der Fix ist eine Löschung, keine Wertänderung. Entferne die Zeile. Versuch nicht, einen anderen Wert für type zu finden.

Noch eine Verhaltensänderung, die man kennen sollte: Mit ausgeschaltetem Thinking schreibt Fable 5 manchmal längeres Reasoning in die sichtbare Antwort. Wenn du kurze, schnelle Antworten brauchst, ist der sauberste Fix, adaptives Thinking anzulassen, was das Reasoning aus dem finalen Text raushält. Wenn du Thinking-frei laufen musst, füge eine System-Instruktion hinzu, die dem Modell sagt, es soll nur mit seiner finalen Antwort antworten.

Effort-Tuning

Effort steuert, wie hart das Modell denkt und handelt. Du setzt ihn innerhalb von output_config, nicht auf Top-Level. Der Default ist high.

Dieser Call setzt Effort explizit. Niedrigere Werte bedeuten weniger Tool-Calls, weniger Vorrede und knapperen Output. Höhere Werte bedeuten tieferes Reasoning und mehr Gründlichkeit, zu höheren Token-Kosten.

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": "Refactor this module for testability."}],
)

So wählst du eine Stufe.

Effort zählt auf Fable 5 mehr als auf jedem früheren Opus. Wenn du migrierst, tune ihn pro Route neu, statt anzunehmen, die alte Einstellung passe noch. Für langlaufende agentische Aufgaben gib die volle Task-Spec gleich in einem Turn vor und lauf auf high oder xhigh. Bei xhigh oder max gib max_tokens echten Spielraum (starte bei 64K), damit das Modell Raum hat, über Tool-Calls hinweg zu denken und zu handeln.

Task-Budgets

Ein Task-Budget sagt dem Modell, wie viele Tokens es für eine ganze agentische Schleife hat, gezählt werden Thinking, Tool-Calls und finaler Output. Das Modell sieht einen laufenden Countdown und teilt sich ein, indem es elegant zum Abschluss kommt, während das Budget zur Neige geht.

Das ist etwas anderes als max_tokens. max_tokens ist eine harte Obergrenze, die das Modell nicht sehen kann. Ein Task-Budget ist ein Vorschlag, den das Modell kennt und um den herum es plant. Nutze das Budget, damit das Modell sich selbst mäßigt, und behalte max_tokens als die erzwungene Grenze.

Task-Budgets sind in der Beta, du übergibst also einen Beta-Header und rufst über den Beta-Namespace auf. Das Mindestbudget sind 20.000 Tokens.

message = client.beta.messages.create(
    betas=["task-budgets-2026-03-13"],
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[{"role": "user", "content": "Migrate the auth module off the deprecated API."}],
)

Setz ein großzügiges Budget für offene agentische Läufe und ein engeres für latenzsensible Aufgaben. Wenn das Budget zu klein für die Arbeit ist, schließt das Modell weniger gründlich ab und sagt dir, dass das Budget die Einschränkung war.

Caching-Notizen

Prompt-Caching funktioniert genauso wie auf jedem Claude-Modell: Es ist ein Prefix-Match, also macht jede Byte-Änderung irgendwo im gecachten Prefix alles dahinter ungültig. Halte stabilen Content vorn und packe volatilen Content (Timestamps, Request-IDs, die Frage pro Request) hinter deinen letzten Breakpoint.

Zwei Zahlen sind auf Fable 5 anders. Der minimale cachebare Prefix sind 2048 Tokens, runter von 4096 auf Opus 4.8. Ein 3K-Token-Prompt, der auf Opus 4.8 stillschweigend nicht cachte, wird also auf Fable 5 cachen. Cache-Reads kosten etwa 0,1x des Basis-Input-Tarifs, und Writes kosten etwa 1,25x mit dem Default-Fenster von fünf Minuten.

Dieser Call cacht einen großen, stabilen System-Prompt. Der cache_control-Marker geht auf den System-Block. Die Frage pro Request im User-Turn bleibt ungecacht, was du auch willst.

message = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    system=[
        {
            "type": "text",
            "text": LARGE_STABLE_SYSTEM_PROMPT,
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": "Summarize the key risks in section 4."}],
)

Um einen Cache-Hit zu bestätigen, lies message.usage.cache_read_input_tokens. Wenn er über wiederholte Requests mit demselben Prefix bei null bleibt, ändert sich etwas im Prefix bei jedem Call. Die üblichen Verdächtigen sind ein Timestamp im System-Prompt, JSON ohne sortierte Keys serialisiert oder ein Tool-Set, das pro Request variiert.

Streaming für große Outputs

Fable 5 kann bis zu 128K Output-Tokens produzieren, aber das SDK rennt bei einem Nicht-Streaming-Request, der nach einem großen Output fragt, in einen HTTP-Timeout. Die Faustregel: Streame alles über grob 16K max_tokens.

Das hier streamt die Antwort und sammelt am Ende die finale Message ein, sodass du sowohl Live-Tokens als auch ein vollständiges Ergebnis-Objekt bekommst.

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "Write the full migration plan."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

Eine Streaming-Notiz speziell für Fable 5: Thinking-Blöcke streamen, aber ihr Text ist standardmäßig leer. Wenn du Reasoning für Nutzer anzeigst, sieht dieser Default wie eine lange stille Pause aus, bevor die Antwort startet. Um sichtbaren Fortschritt wiederherzustellen, frag mit thinking={"type": "adaptive", "display": "summarized"} nach zusammengefasstem Thinking.

Fable 5 auf Amazon Bedrock

Bedrock hat einen Schritt, der jeden Request blockiert, bis du ihn machst: Du musst dem Daten-Sharing zustimmen, bevor du Fable 5 aufrufen kannst. Dafür gibt es zum Launch kein Console-UI, also ist er leicht zu übersehen, und der Fehler, den er produziert, ist nicht offensichtlich.

Du stimmst über die Data-Retention-API zu, indem du den Modus auf provider_data_share setzt. Dieser curl-Call macht es für die bedrock-mantle-Engine, die du mit der Anthropic Messages API nutzt. Lauf ihn einmal pro Account vor deinem ersten Modell-Call.

curl -X PUT https://bedrock-mantle.us-east-1.api.aws/v1/data_retention \
  -H "x-api-key: <your-bedrock-api-key>" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "provider_data_share" }'

Wenn du stattdessen die Converse- oder Invoke-API auf der bedrock-runtime-Engine aufrufst, unterscheiden sich Endpoint und Auth. Das ist das äquivalente Opt-in für diese Engine.

curl -X PUT https://bedrock.us-east-1.amazonaws.com/data-retention \
  -H "Authorization: Bearer <your_bearer_token>" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "provider_data_share" }'

Zuzustimmen heißt, dass Anthropic deine Inputs und Outputs 30 Tage lang aufbewahrt. Die Daten werden nicht fürs Training genutzt, menschlicher Zugriff darauf wird geloggt, und sie werden nach 30 Tagen gelöscht. Es ist eine Voraussetzung für allen Traffic der Mythos-Klasse, und sobald du zustimmst, verlassen deine Daten die Security-Boundary von AWS. Entscheide, ob das für deinen Workload akzeptabel ist, bevor du es umlegst.

Sobald du zugestimmt hast, richte das Anthropic SDK auf den Bedrock-Endpoint. Die Modell-ID auf der Messages API ist anthropic.claude-fable-5, mit dem anthropic.-Prefix. Dieser Python-Call läuft gegen bedrock-mantle.

import anthropic

client = anthropic.Anthropic(
    base_url="https://bedrock-mantle.us-east-1.api.aws/anthropic",
    api_key="<your-bedrock-api-key>",
)

message = client.messages.create(
    model="anthropic.claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Design a multi-region architecture for 100k requests per second."}],
)

print(message.content[0].text)

Wenn du die Converse-API über boto3 bevorzugst, ändert sich die Modell-ID zu global.anthropic.claude-fable-5, und du rufst bedrock-runtime auf. Das ist derselbe Request in dieser Form.

import boto3

bedrock_runtime = boto3.client("bedrock-runtime", region_name="us-east-1")

response = bedrock_runtime.converse(
    modelId="global.anthropic.claude-fable-5",
    messages=[{"role": "user", "content": [{"text": "Design a multi-region architecture for 100k RPS."}]}],
    inferenceConfig={"maxTokens": 4096},
)

print(response["output"]["message"]["content"][0]["text"])

Zum Launch bedient Bedrock Fable 5 in US East (N. Virginia) und Europe (Stockholm). Der Zugang wird schrittweise über AWS-Accounts erweitert; wenn deiner noch nicht aktiviert ist, kontaktiere den AWS Support, um schneller voranzukommen.

Eine Abrechnungsüberraschung, auf die du dich einstellen solltest

Fable 5 kommt mit konservativen Schutzmechanismen. Anfragen zu Cyber-, Bio-, Chemie- und Gesundheitsthemen fallen stattdessen auf eine Antwort von Opus 4.8 zurück, und der Nutzer wird informiert. Das wird im Schnitt in unter 5 % der Sessions ausgelöst.

Der Teil, der deinen Code betrifft, ist die Abrechnung. Fallback-Antworten werden zu Opus-Tarifen abgerechnet, nicht zu Fable-Tarifen. Auf Bedrock werden, wenn ein Request mitten im Gespräch blockiert wird, die anfänglichen Tokens zu Fable-Tarifen abgerechnet und der Rest zu Opus-Tarifen. Manche Antworten werden also günstiger sein, als dein Modell-Picker andeutet, und tragen einen Hinweis, dass sie von Opus 4.8 beantwortet wurden. Bau dein Kostenmodell so, dass es das zulässt, statt jeden Fable-Call als pauschale Fable-Gebühr zu behandeln.

Migration von Opus 4.8 oder 4.7

Wenn dein bestehender Opus-Code schon sauber ist, ist der Umzug auf Fable 5 ein Modell-ID-Tausch und nichts weiter. "Sauber" heißt: keine Sampling-Parameter, kein budget_tokens und kein explizites thinking: {"type": "disabled"}.

Hier ist die Checkliste.

• Tausch die Modell-ID auf claude-fable-5.
• Lösch jedes thinking: {"type": "disabled"}. Es gibt auf Fable 5 einen 400. Lass das Feld stattdessen weg.
• Entferne temperature, top_p und top_k. Sie geben schon auf Opus 4.7 und 4.8 einen 400, und hier auch.
• Ersetze budget_tokens durch thinking: {"type": "adaptive"}.
• Ersetze jeden Prefill mit letztem Assistant-Turn durch output_config: {"format": {...}}.
• Tune effort pro Route neu. Er hat auf Fable 5 mehr Gewicht.
• Setz thinking.display auf "summarized", wenn du Reasoning für Nutzer sichtbar machst.
• Baselin deine max_tokens- und Kosten-Dashboards neu, da Fable mit doppeltem Opus-Pricing läuft.

Wenn du von Opus 4.6 oder älter kommst, wende zuerst die volle Adaptive-Thinking-Migration an, dann die Fable-5-Deltas von oben.

Der eine wirklich neue Breaking Change gegenüber Opus 4.8 und 4.7 ist der explizite Thinking-disabled-400. Alles andere auf dieser Liste galt schon für die jüngsten Opus-Modelle. Deshalb nennen Leute Fable 5 "weitgehend drop-in". Das Wort, das die Arbeit macht, ist "weitgehend".

Häufig gestellte Fragen

Was ist die Modell-ID von Claude Fable 5?

Die First-Party-Modell-ID ist exakt der String claude-fable-5, ohne Datums-Suffix. Auf Amazon Bedrock trägt sie ein anthropic.-Prefix: anthropic.claude-fable-5 auf der Messages API (bedrock-mantle) und global.anthropic.claude-fable-5 auf der Converse- oder Invoke-API (bedrock-runtime).

Warum gibt deaktiviertes Thinking auf Fable 5 einen 400 zurück?

Auf Fable 5 wird ein explizites thinking: {"type": "disabled"} nicht akzeptiert und gibt einen 400 zurück. Das ist einzigartig für Fable 5; Opus 4.8 und 4.7 akzeptieren es. Um einen Request ohne Thinking laufen zu lassen, lass den thinking-Parameter komplett weg, statt ihn auf disabled zu setzen.

Wie nutze ich Fable 5 auf Bedrock?

Stimm zuerst dem Daten-Sharing zu, indem du den Modus der Data-Retention-API auf provider_data_share setzt. Dafür gibt es zum Launch kein Console-UI, du machst es also mit einem curl-Call an den Data-Retention-Endpoint. Danach richte das Anthropic SDK auf die Bedrock-Base-URL und nutze die Modell-ID anthropic.claude-fable-5, oder nutze boto3s Converse-API mit global.anthropic.claude-fable-5.

Wie viel kostet Claude Fable 5?

$10 pro Million Input-Tokens und $50 pro Million Output-Tokens. Das ist das Doppelte der $5 und $25 von Opus 4.8. Antworten, die die Schutzmechanismen auslösen und auf Opus 4.8 zurückfallen, werden stattdessen zu Opus-Tarifen abgerechnet, manche Calls kosten also weniger als der Schlagzeilen-Fable-Tarif.

Wie schalte ich Thinking auf Fable 5 ohne Fehler aus?

Entferne das thinking-Feld aus deinem Request. Ein Request ohne thinking-Feld läuft ohne Thinking. Setz nicht thinking: {"type": "disabled"}, das gibt einen 400 zurück. Wenn du feststellst, dass das Modell mit ausgeschaltetem Thinking langes Reasoning in die sichtbare Antwort schreibt, lass entweder adaptives Thinking an oder füge eine System-Instruktion hinzu, nur mit der finalen Antwort zu antworten.

Ändert sich Prompt-Caching auf Fable 5?

Die Mechanik ist dieselbe, aber der minimale cachebare Prefix ist niedriger: 2048 Tokens auf Fable 5 gegenüber 4096 auf Opus 4.8. Ein mittelgroßer Prompt, der auf Opus 4.8 nicht cachen würde, cacht also auf Fable 5. Verifiziere Hits mit usage.cache_read_input_tokens.

Quellen

• Claude Fable 5 and Claude Mythos 5
• Anthropic Claude Fable 5 on AWS (AWS News Blog)
• Models overview (API docs)
• Model migration guide (API docs)
• Building with extended thinking (API docs)
• Claude Fable 5 model card (Amazon Bedrock)
• Data retention practices for Mythos-class models

Verwandte Seiten

• Opus 4.8 Cheatsheet
• Claude Code Models
• Claude Mythos and OpenMythos