Claude Fable 5 effizient prompten: Ein praktischer Leitfaden

Bei 10 $ pro Million Eingabetoken und 50 $ pro Million Ausgabetoken Claude Fable 5 (Modell-ID claude-fable-5) ist der teuerste Weg im Claude-Angebot, eine vage Eingabeaufforderung zu senden. Es ist aber auch: gut gepromptet: das Modell, das eine schwierige Aufgabe am ehesten in einem Durchlauf statt in fünf erledigt. Diese Kombination verändert, was effizientes Prompten bedeutet. In der Launch-Analyse habe ich beschrieben, was Fable 5 ist und wann es seinen Aufpreis wert ist; dieser Beitrag ist die Fortsetzung für den Tag, an dem Sie tatsächlich Traffic darauf lenken. Alles hier ist ausführbar: vorab gefüllte Briefings, Aufwands-Sweeps, Prompt-Caching, Aufgabenbudgets und Ablehnungs-Fallbacks: mit der Token-Mathematik, die zeigt, warum sich jeder einzelne lohnt.

Effizienz hat bei diesem Modell eine andere Gestalt

Bei früheren Claude-Generationen bedeutete Effizienzarbeit das Einstellen von Zahlen: eine Temperatur hier, ein Thinking-Budget dort, eine max_tokens-Obergrenze als improvisierte Bremse. Fable 5 entfernt all das. Sampling-Parameter geben einen harten 400-Fehler zurück, manuelle Thinking-Budgets geben einen 400-Fehler zurück, und anders als bei Opus 4.8 können Sie nicht einmal ein explizites thinking: {"type": "disabled"}senden; Thinking ist einfach immer an, und das Modell entscheidet, wie viel jede Aufgabe benötigt. Was bleibt, sind genau zwei Hebel: die Worte in Ihrem Prompt und output_config.effort. Das klingt nach weniger Kontrolle. In der Praxis verlagert es die Effizienzarbeit dorthin, wo sie schon immer hingehörte: auf die Qualität des Briefings, das Sie schreiben, und eine ehrliche Messung, wie viel Tiefe Ihre Aufgabe tatsächlich erfordert.

Schreiben Sie das gesamte Briefing im Voraus

Der größte Effizienzgewinn kostet nichts: Packen Sie die gesamte Aufgabe in die erste Nachricht. Fable 5 ist auf lange, autonome Durchläufe abgestimmt, und seine Planung ist nur so gut wie die Spezifikation, gegen die es plant. Ein tröpfchenweise gefütterter Dialog („jetzt füge auch Tests hinzu“, „ach ja, und halte die API stabil“) zwingt das Modell, nach jeder Korrektur neu zu denken, und bei interaktiven Workloads denkt es nach jedem Benutzerzug intensiv nach. Fünf kurze Durchläufe kosten routinemäßig mehr als ein vollständiges Briefing und liefern ein schlechteres Ergebnis. Ein vollständiges Briefing hat fünf Teile: den Kontext (warum das wichtig ist), das Ziel, die Einschränkungen, das erwartete Ausgabeformat und eine überprüfbare Definition of Done.

# efficient_brief.py
# pip install anthropic
from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment

BRIEF = """Context: I maintain a Laravel blog whose custom search endpoint
has slowed to ~900ms p95 as the posts table passed 50K rows.

Goal: propose and implement the smallest change that gets p95 under 150ms.

Constraints: MySQL 8 only, no new services, migrations must be reversible,
and the public JSON response shape cannot change.

Deliver: the migration, the changed query code, and one paragraph on the
root cause. Definition of done: EXPLAIN shows no full table scan.
"""

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=32000,                    # stream anything this large
    output_config={"effort": "high"},
    # No thinking parameter: on Fable 5 thinking is always on, and an
    # explicit {"type": "disabled"} is rejected with a 400.
    messages=[{"role": "user", "content": BRIEF}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

final = stream.get_final_message()
print(f"\n[stop: {final.stop_reason}, output: {final.usage.output_tokens}]")

Verwenden Sie den folgenden Builder, um ein Briefing in dieser Form für Ihre eigene Aufgabe zusammenzustellen, und fügen Sie es dann direkt in die API, Claude Code oder claude.ai ein. Die Struktur ist wichtiger als der Wortlaut.

Den Aufwand durchsweepen, statt ihn zu raten

output_config.effort prägt alles: wie tief das Modell denkt, wie viele Tool-Aufrufe es macht, wie ausführlich die Antwort ist. Der Standard ist high, und die Stufenleiter reicht von low, medium, high, xhigh, max. Der kontraintuitive Teil ist, wie stark das untere Ende der Leiter ist. Low-Effort bei Fable 5 übertrifft oft das, was Modelle der vorherigen Generation bei ihren maximalen Einstellungen produzierten, daher gehören routinemäßige Extraktion, Klassifizierung und Zusammenfassung häufig zu low oder medium, wo die Antworten schneller und dramatisch günstiger sind. Reservieren Sie xhigh und max für Arbeiten, bei denen Korrektheit über Kosten steht. Raten Sie nicht, wo Ihre Aufgabe liegt: Sweepen Sie sie einmal und lassen Sie die Zahlen entscheiden.

# effort_sweep.py
# Run one representative prompt at four effort levels and compare.
import time
from anthropic import Anthropic

client = Anthropic()
TASK = open("representative_task.txt").read()  # a real prompt from prod

print(f"{'effort':<8}{'seconds':>9}{'output':>9}  stop")
for effort in ["low", "medium", "high", "xhigh"]:
    t0 = time.monotonic()
    with client.messages.stream(
        model="claude-fable-5",
        max_tokens=64000,
        output_config={"effort": effort},
        messages=[{"role": "user", "content": TASK}],
    ) as stream:
        final = stream.get_final_message()
    took = time.monotonic() - t0
    print(f"{effort:<8}{took:>8.1f}s{final.usage.output_tokens:>9}"
          f"  {final.stop_reason}")

# Judge the four answers (by eye, or with a judge prompt) and keep the
# cheapest effort level that still clears your quality bar.

Die Ausgabetoken-Zahlen aus einem Sweep lassen sich direkt in Geld umrechnen. Die folgende Spielwiese läuft vollständig in Ihrem Browser: Geben Sie Ihre eigenen Messwerte ein und sehen Sie, was ein Tag Traffic auf jeder Effort-Stufe kostet, mit und ohne Caching.

Verschreibe keine Prompts, die für ältere Modelle geschrieben wurden

Hier ist die Überraschung bei der Migration, die niemand einplant: Ihre besten Prompts aus der Opus-Ära können Fable 5 schlechter machen. Prompts sammeln Gerüste, nummerierte Schrittlisten, „immer X vor Y“-Regeln, erzwungene Zusammenfassungen alle paar Aktionen, weil ältere Modelle diese Leitplanken brauchten. Fable 5 befolgt Anweisungen wörtlicher und plant besser als das von Ihnen geschriebene Gerüst, daher schränken vorschreibende Prompts es aktiv ein. Die Migrationsanleitung von Anthropic ist hier unverblümt: Nennen Sie das Ziel und die Einschränkungen, testen Sie dann die Arbeitslast mit und ohne das schrittweise Gerüst und behalten Sie, was besser abschneidet. In meinen Tests gewinnt die entschlackte Version weitaus häufiger, als sie verliert.

BEFORE (written for an older model, too prescriptive for Fable 5):

  Step 1: Read the ticket. Step 2: List every file that could be involved.
  Step 3: For each file, explain whether it is relevant and why.
  Step 4: Propose exactly three fixes. Step 5: Pick one and implement it.
  Step 6: Summarize what you did in exactly 3 bullet points.

AFTER (goal + constraints, steps left to the model):

  Fix the double-charge described in ticket #4821 (text below).
  Constraints: touch only the billing module, keep the public API stable,
  add a regression test. Deliver a unified diff plus one paragraph on the
  root cause. When you have enough information to act, act; do not
  narrate options you will not pursue.

Den Präfix cachen und nur ein Zehntel dafür zahlen

Prompt-Caching ist ein Präfix-Abgleich: Anfragen werden als Tools, dann System, dann Nachrichten gerendert, und jedes Byte, das sich ändert, macht alles danach ungültig. Strukturieren Sie jede hochvolumige Arbeitslast so, dass der stabile Inhalt (System-Prompt, Referenzdokumente, Tool-Definitionen) zuerst kommt und bei jedem Aufruf byte-identisch ist, während der variable Teil (die eigentliche Frage des Benutzers) zuletzt kommt. Markieren Sie die Cache-Grenze mit cache_control, und beachten Sie, dass ein Präfix unter 2.048 Token bei Fable 5 stillschweigend überhaupt nicht gecacht wird. Gecachte Lesevorgänge werden mit etwa einem Zehntel des Eingabepreises berechnet; bei einem Modell für 10 $ pro Million, das Tausende von Anfragen pro Tag bedient, ist das keine Optimierung, sondern der Unterschied zwischen einem tragfähigen Feature und einem toten.

# cached_prefix.py
from anthropic import Anthropic

client = Anthropic()
PLAYBOOK = open("support_playbook.md").read()  # ~9K tokens, never changes

def answer(ticket: str):
    return client.messages.create(
        model="claude-fable-5",
        max_tokens=2048,
        system=[{
            "type": "text",
            "text": PLAYBOOK,                        # stable prefix first
            "cache_control": {"type": "ephemeral"},  # cache boundary here
        }],
        messages=[{"role": "user", "content": ticket}],  # volatile last
    )

first = answer("Customer says the invoice PDF renders blank.")
again = answer("Customer was charged twice for order #8112.")

for label, r in (("first", first), ("again", again)):
    u = r.usage
    print(f"{label}: wrote={u.cache_creation_input_tokens}"
          f" read={u.cache_read_input_tokens} full_price={u.input_tokens}")

# first: wrote=~9000 read=0     -> pays the 1.25x write premium once
# again: wrote=0 read=~9000     -> reads bill at ~0.1x the input price

Agenten-Schleifen budgetieren und mit langen Durchläufen rechnen

Zwei operative Gewohnheiten runden die Effizienzgeschichte ab. Erstens: Planen Sie Zeit ein. Eine einzelne Fable 5-Anfrage mit hohem Aufwand bei einer schwierigen Aufgabe kann legitimerweise viele Minuten laufen, während sie Kontext sammelt, baut und ihre eigene Arbeit überprüft. Streamen Sie daher alles und gestalten Sie Ihre UX um Fortschritt herum, nicht um einen Ladekreis. Zweitens: Verwenden Sie für agentische Schleifen ein Aufgabenbudget. Anders als max_tokens, das eine harte Obergrenze ist, die das Modell nie sieht, gibt ein task_budget dem Modell einen Live-Countdown, an dem es sich aktiv orientiert, priorisiert die wichtige Arbeit und schließt sauber ab, anstatt mitten im Gedanken abgeschnitten zu werden.

# task_budget.py
# Beta: the model sees a live token countdown and paces itself.
from anthropic import Anthropic

client = Anthropic()

with client.beta.messages.stream(
    model="claude-fable-5",
    max_tokens=128000,
    betas=["task-budgets-2026-03-13"],
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 60000},  # min 20,000
    },
    tools=tools,  # your agent's tool definitions
    messages=[{"role": "user", "content": AGENT_BRIEF}],
) as stream:
    final = stream.get_final_message()

Von Anfang an auf Refusal-Fallbacks setzen

Fable 5 führt Sicherheitsklassifizierer aus, die auf Forschungsbiologie und die meisten Cybersicherheitsinhalte abzielen, und harmlose angrenzende Arbeiten: ein Audit von Sicherheitswerkzeugen, eine Life-Science-Datenpipeline: können gelegentlich einen Fehlalarm auslösen. Eine abgelehnte Anfrage kommt als erfolgreicher HTTP 200 mit stop_reason: "refusal" und vor der Ausgabe einem leeren Inhaltsarray zurück, sodass Code, der liest response.content[0] stürzt garantiert genau bei den Anfragen ab, mit denen Sie am wenigsten rechnen. Das effiziente Muster ist, sich für serverseitige Fallbacks zu entscheiden: Geben Sie im selben Aufruf ein Ausweichmodell an, und eine Ablehnung wird transparent von Opus 4.8 erneut bedient, wobei Ihnen die nicht berechnete Ablehnung nichts kostet.

# refusal_fallback.py
from anthropic import Anthropic

client = Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    betas=["server-side-fallback-2026-06-01"],
    fallbacks=[{"model": "claude-opus-4-8"}],  # rescue inside the same call
    messages=[{"role": "user", "content":
               "Audit this nginx config for MIME sniffing issues."}],
)

if response.stop_reason == "refusal":
    print("Whole chain declined:", response.stop_details)
else:
    rescued = any(i.type == "fallback_message"
                  for i in (response.usage.iterations or []))
    print(f"served by {response.model}" + (" (fallback)" if rescued else ""))
    print(response.content[0].text)

Der effiziente Weg in einem Absatz

Verfassen Sie ein vollständiges Briefing mit der dahinterstehenden Begründung, testen Sie den Aufwand einmal durch und bleiben Sie bei der günstigsten Stufe, die besteht, entfernen Sie das Gerüst, das Ihre alten Prompts angesammelt haben, cachen Sie jeden stabilen Präfix über 2.048 Token, geben Sie Agentenschleifen ein Budget, das sie einsehen können, und entscheiden Sie sich für Fallbacks, sodass Ablehnungen zurückfallen, anstatt zu scheitern. Keiner dieser Schritte ist schwierig, und zusammen halbieren sie routinemäßig die Kosten einer Fable-5-Arbeitslast, während sie die Ausgabe verbessern. Das Modell hat die Stellschrauben weggenommen; was es zurückgegeben hat, ist ein System, bei dem die Qualität Ihres Schreibens die Leistungsoptimierung ist.