# Claude Fable 5: Wann das leistungsstarke Modell eingesetzt wird und welcher effort-Level gewählt werden sollte

> Eine vollständige Analyse des Modells Claude Fable 5 und des Parameters effort: Funktionsweise des Verhaltenssignals für Reasoning, Verfügbarkeitsmatrix der Level (low/xhigh), Kostenberechnung pro Durchlauf sowie Konfiguration in API und Claude Code.

Claude Fable 5 ist das Flaggschiff-Modell von Anthropic der neuen Mythos-Klasse, entwickelt für die komplexesten mehrstufigen Reasoning-Aufgaben und autonome agentische Entwicklung. Zusammen mit diesem Modell haben Entwickler einen neuen fundamentalen Mechanismus zur Verhaltenssteuerung erhalten – den Parameter `effort`.

Dieser Guide analysiert im Detail die Fähigkeiten von Fable 5, die Funktionsweise des Parameters `effort`, die Tokenisierung des Reasonings sowie praktische Strategien zur Konfigurationsauswahl für die Optimierung von Geschwindigkeit und Kosten in der Produktion.

---

## 1. Fable 5 auf den Punkt: Was ist dieses Modell und wofür wird es benötigt?

Claude Fable 5 positioniert sich als das leistungsfähigste breit verfügbare Modell von Anthropic und steht über dem Niveau von Opus. Es wurde für Aufgaben entwickelt, bei denen herkömmliche Modelle an ihre Grenzen stoßen oder den Kontext bei langen Sequenzen verlieren.

### 1.1. Modellpositionierung und die Mythos-Familie

Fable 5 ist die erste öffentlich zugängliche Implementierung der Architektur der Mythos-Klasse. Darüber existiert eine eingeschränkte Forschungs-Version – Mythos 5, die ohne zusätzliche Schichten externer Filter auskommt und ausschließlich autorisierten Forschungsgruppen über die Initiative Project Glasswing bereitgestellt wird.

Das Modell wird in der Umgebung **Claude Code** und auf der Plattform **Managed Agents** unterstützt und bietet ein Kontextfenster von 1.000.000 Tokens sowie eine Generierung von bis zu 128.000 Tokens pro Anfrage.

> [!NOTE]
> Im Web-Interface ist Fable 5 für Nutzer der Pro- und Max-Tarifpläne verfügbar; in der API wird sie über die ID `claude-fable-5` aufgerufen.

### 1.2. Benchmarks, Multimodalität und das Konzept No-Slop Code

In Tests demonstriert Fable 5 State-of-the-Art (SOTA)-Ergebnisse in komplexen Disziplinen:
- **Agentisches Programmieren:** Eigenständiges Deployment von Repositories, Bug-Suche und Test-Erstellung.
- **Generierung von No-Slop Code:** Code ohne redundante Wrapper, künstliche Kommentare und unnötige Abstraktionen.
- **Multimodale Wahrnehmung:** Durchspielen von Spielen (insbesondere Pokemon FireRed) ausschließlich anhand von Videostreams/Screenshots ohne textuelle Hinweise.
- **Wissenschaftliche Forschung:** Simulationen in VibeCAD und Analyse biomedizinischer Strukturen.

Ein zentrales Muster bei Fable 5: Der Vorteil gegenüber Sonnet und Opus wird insbesondere bei langen, mehrstufigen Iterationen spürbar.

---

## 2. Wann lohnt sich der Einsatz von Fable 5 und wann nicht?

Die hohe Leistungsfähigkeit des Modells geht mit erhöhten Kosten einher, daher sollte sein Einsatz wirtschaftlich und technisch begründet sein.

### 2.1. Optimale und ineffiziente Anwendungsszenarien

Fable 5 ist für Aufgaben mit hohen Fehlerkosten konzipiert:

| Empfohlene Nutzung | Nicht empfehlenswert (Kosten-Nutzen-Verhältnis schlecht) |
| --- | --- |
| Umfassende Refactoring-Projekte von Monolithen und System-Migrationen | Einfache CRUD-Operationen und Skript-Template-Aufgaben |
| Mehrstufige agentische Sessions (von 20 bis 100+ Schritten) | Einmalige Klassifizierung oder Datenextraktion |
| Suche nach subtilen Race Conditions und Sicherheitsproblemen | Schreiben einfacher Unit-Tests für bekannte Funktionen |
| Architektonisches Design neuer Subsysteme | Schnelle Zusammenfassung kurzer Notizen |

### 2.2. Vier Regeln für die Produktionsvorbereitung und Zugangsparameter

Bevor Sie Fable 5 in Ihre Pipelines integrieren, beachten Sie folgende technische Aspekte:

1. **Vereinfachen Sie System-Prompts:** Fable 5 denkt konzeptionell. Starre schrittweise Skripte aus älteren Modellen schränken ihr Potenzial nur ein – definieren Sie das Endziel und die zulässigen Grenzen.
2. **Steuern Sie den Parameter effort:** Die Einstellung des Aufwands ist der wichtigste Hebel zur Kontrolle von Latency und finanziellen Kosten.
3. **Legen Sie Timeouts für lange Schritte fest:** Komplexe Reasoning-Prozesse bei Grenzwertaufgaben können Minuten dauern; begrenzen Sie die maximalen Iterationen der Agenten.
4. **Behandeln Sie Ablehnungen (Refusals):** Aufgrund strenger interner Sicherheitsregeln lehnt das Modell einige Randanfragen ab, was eine robuste Fehlerbehandlung im Code erfordert.

---

## 3. Was macht effort überhaupt und wie funktioniert es?

Mit der Einführung von Fable 5 haben die Ingenieure von Anthropic das Einstellsystem grundlegend überarbeitet. Übliche Sampling-Parameter (Temperatur, top-p) und manuelles `budget_tokens` gehören der Vergangenheit an.

### 3.1. Verhaltenssignal vs. fester Token-Budget-Mechanismus

Das zentrale Werkzeug für feine Abstimmung ist nun der Parameter **`effort`**, der innerhalb der Ausgabe-Konfiguration übergeben wird: `output_config={"effort": "..."}`.

> [!IMPORTANT]
> Der Parameter `effort` ist ein qualitatives Verhaltenssignal, kein harter Token-Limit. Er teilt dem Modell mit, wie tief es den Hypothesenraum erkunden und wie viel Aufwand es in die Verifikation investieren soll. Die harte Grenze für die Generierung bleibt weiterhin `max_tokens`.

### 3.2. Einfluss auf Tool-Calls, Erklärungen und Generierung

Im Gegensatz zum veralteten `budget_tokens`, der nur die Phase des internen Reasonings steuerte, skaliert `effort` alle Aspekte der Antwort:
- **Auf Level low:** Das Modell generiert weniger Tool-Calls, bündelt Befehle in einer Anfrage, minimiert einleitende Formulierungen und liefert ein knappes Ergebnis.
- **Auf Level high / xhigh:** Das Modell entfaltet einen internen Plan, überprüft Zwischenergebnisse mit zusätzlichen Tools und stellt ausführliche Kommentare bereit.

---

## 4. Die fünf effort-Level und ihre Verfügbarkeit

Die Messages API unterstützt eine feste Liste mit fünf zulässigen Werten für den Parameter `effort`.

### 4.1. Offizielle Skala von low bis xhigh

| Level | Verhaltensbeschreibung gemäß Anthropic-Dokumentation | Verfügbarkeit im Modell-Familie |
| :--- | :--- | :--- |
| **xhigh** | Maximale Reasoning-Tiefe für lange agentische Sessions (>30 Min.) mit Millionen-Token-Budgets | Nur Fable 5, Mythos 5, Opus 4.8, Opus 4.7 |
| **high** | Standardwert: Ausgedehntes Reasoning, Planung und Schrittüberprüfung | Alle Modelle mit effort-Unterstützung |
| **medium** | Ausgewogenes Level mit moderater Token-Ersparnis ohne Logikverlust | Alle Modelle mit effort-Unterstützung |
| **low** | Maximale Geschwindigkeit und minimale Token-Kosten bei grundlegender Qualitätskontrolle | Alle Modelle mit effort-Unterstützung |
| **max** | Extremes, unbegrenztes Reasoning für spezifische wissenschaftliche Aufgaben | Spezielle Claude Code Sessions |

### 4.2. Modellunterstützung und individuelle Kalibrierung

Das Level **xhigh** ist exklusiv: Bei Opus 4.6 und Sonnet 4.6 fehlt dieses Level. Darüber hinaus wird die Aufwands-Skala für jedes neuronale Netzwerk separat kalibriert: `high` bei Fable 5 erzeugt eine deutlich tiefere Reasoning-Trajektorie als `high` bei Opus 4.6.

---

## 5. Defaults je nach Modell und Umgebung: API und Claude Code

Das Verhalten des Modells ohne explizite Parameterangabe unterscheidet sich je nach Ausführungsumgebung.

### 5.1. Vergleich der Standardwerte in API und Claude Code

| Modell | Default in Messages API | Default in Claude Code |
| :--- | :--- | :--- |
| **Claude Fable 5** | `high` | `high` |
| **Claude Opus 4.8** | `high` | `high` |
| **Claude Opus 4.7** | `high` | `xhigh` |
| **Claude Opus 4.6 / Sonnet 4.6** | `high` | `high` |

### 5.2. Fallback-Verhalten und Zustandserhaltung zwischen Sessions

- **Automatischer Rollback (Fallback):** Wenn Sie eine Session mit Level `xhigh` starten und dann zu Opus 4.6 wechseln, rollt Claude Code automatisch auf `high` zurück, ohne dass ein Absturz erfolgt.
- **Persistenz der Levels:** Die Levels von `low` bis `xhigh` bleiben zwischen den Starts von Claude Code erhalten. Das Level `max` wird bewusst nach Abschluss der Session zurückgesetzt, um ein unkontrolliertes Verbrauchen des Nutzer-Budgets zu verhindern.

---

## 6. Wie hängt effort mit dem Modell-Reasoning zusammen?

Die Arbeit mit dem internen Reasoning (Thinking) unterscheidet sich grundlegend zwischen den Modellgenerationen.

### 6.1. Besonderheiten von Fable 5 vs. adaptiver Modus bei Opus

- **Fable 5:** Reasoning ist architektonisch eingebettet und permanent aktiviert. Der Versuch, `thinking: {"type": "disabled"}` zu übergeben, führt zu einem Fehler `HTTP 400 Bad Request`.
- **Opus 4.7 / 4.8:** Adaptives Reasoning ist standardmäßig deaktiviert und wird durch den Aufruf `thinking: {"type": "adaptive"}` aktiviert.

### 6.2. Migration vom veralteten Parameter budget_tokens

> [!WARNING]
> Wenn Sie Ihre Codebasis aus früheren Versionen des Claude SDK aktualisieren, wird der Parameter `budget_tokens` nicht mehr unterstützt. Seine Verwendung führt zu einem API-Fehler. Ersetzen Sie ihn durch das Objekt `output_config={"effort": "..."}`.

---

## 7. Was kostet jedes Level: Kalkulation der Ausgaben

Der Parameter `effort` ändert nicht den Basistarif pro Million Tokens. Er beeinflusst die finale Rechnung indirekt – über die Anzahl der generierten Reasoning-Tokens.

### 7.1. Tarifierung der versteckten Reasoning-Tokens (Thinking Tokens)

Bei Fable 5 ist die Ausgabe des Reasoning-Textes standardmäßig ausgeblendet (`omitted`), jedoch wird jeder Token des internen Denkens als vollwertiger Output-Token zum Standardtarif berechnet: **$10 pro 1 Mio. Input-Tokens** und **$50 pro 1 Mio. Output-Tokens**.

### 7.2. Kostenkalkulation pro Schritt und Einfluss des neuen Tokenizers

Schätzung der Kosten eines Schritts in einer agentischen Aufgabe bei 20.000 Input-Tokens (am Beispiel Opus 4.8):

| Szenario und Level | Output-Tokens | Input ($5/M) | Output ($25/M) | Gesamt pro 1 Schritt |
| :--- | :--- | :--- | :--- | :--- |
| **low** (knapp, kompakte Tools) | 5.000 | $0,10 | $0,125 | **~$0,23** |
| **high** (Planung, Code-Validierung) | 20.000 | $0,10 | $0,50 | **~$0,60** |
| **xhigh** (tiefgehende Architektur-Analyse) | 60.000 | $0,10 | $1,50 | **~$1,60** |

> [!TIP]
> Für Fable 5 multiplizieren Sie diese Werte mit 2 (Output $50/M). Der Unterschied zwischen `low` und `xhigh` in einer langen agentischen Session mit 50 Schritten kann zwischen $25 und $160 liegen!

---

## 8. Welches Level für welchen Aufgabentyp wählen?

Um das Budget nicht zu überlasten, nutzen Sie einen differenzierten Ansatz für die Lastverteilung.

### 8.1. Auswahlstrategien für Fable 5 und Opus

:::tabs
=== Fable 5 (Flaggschiff-Aufgaben)
Beginnen Sie mit dem Standard-Level **high**. Das Level `high` bei Fable 5 übertrifft die Qualität von `xhigh` früherer Modellgenerationen. Wechseln Sie zu `xhigh` nur dann, wenn der Agent Aufgaben bearbeitet, die länger als 30 Minuten dauern, oder eine neue Architektur von Grund auf entwirft.
=== Opus 4.8 / 4.7 (Coding)
Empfohlener Start für die Entwicklung ist das Level **xhigh**. Es schließt das maximale Potenzial der Code-Analyse in Opus auf. Aktivieren Sie das Level `medium` erst nach Validierung der Tests, um das Budget zu optimieren.
=== Hintergrundautomatisierung (low)
Nutzen Sie das Level **low** für routinemäßige Teilaufgaben, Dokumentationsgenerierung, schnelles Parsen und Sub-Agenten, wo Latency kritischer ist als tiefe Analytik.
:::

### 8.2. Mehrlagige Architektur: Orchestrator und Sub-Agenten

Das effektivste Muster in der Produktion ist die Agent-Hierarchie:
- **Haupt-Orchestrator:** Fable 5 auf Level `high` oder `xhigh` (baut den Aufgabenbaum auf und validiert Code).
- **Arbeits-Sub-Agenten:** Sonnet 4.6 oder Fable 5 auf Level `low` (führen schnell lokale, isolierte Änderungen aus).

---

## 9. Wie setzt man effort praktisch: Claude Code und API

Den Parameter können Sie sowohl über die CLI-Oberfläche des Entwicklers als auch programmatisch über die Messages API steuern.

### 9.1. Einstellungen in Claude Code CLI und ultracode-Modus

Das Dienstprogramm Claude Code bietet flexible Steuerungsmöglichkeiten:
- Der Befehl `/effort` ruft ein interaktives Menü auf.
- Start-Flag: `claude --effort xhigh`.
- Umgebungsvariable: `export CLAUDE_CODE_EFFORT_LEVEL=xhigh`.

> [!NOTE]
> Der **ultracode**-Modus im Menü `/effort` ist ein interner Modus von Claude Code, der das Level `xhigh` mit erweiterten Rechten des Orchestrators für die Ausführung langer autonomer Aktionszyklen kombiniert.

### 9.2. Aufrufe über die Messages API und Interaktion mit fast mode

:::tabs
=== Python SDK
```python
import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=64000,
    output_config={"effort": "xhigh"},
    messages=[
        {"role": "user", "content": "Проведи аудит архітектури мікросервісів"}
    ]
)
print(response.content[0].text)
```
=== TypeScript SDK
```typescript
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

const response = await anthropic.messages.create({
  model: "claude-fable-5",
  max_tokens: 64000,
  output_config: { effort: "xhigh" },
  messages: [
    { role: "user", content: "Проведи аудит архітектури мікросервісів" }
  ],
});
console.log(response.content[0]);
```
=== cURL (Messages API)
```bash
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 64000,
    "output_config": {"effort": "high"},
    "messages": [{"role": "user", "content": "Hello Fable!"}]
  }'
```
:::

---

## 10. Häufig gestellte Fragen (FAQ)

### 10.1. Verfügbarkeit des Levels xhigh und Fallbacks zwischen Modellen

> **Frage:** Kann ich `xhigh` auf allen Claude-Modellen verwenden?  
> **Antwort:** Nein. Das Level `xhigh` ist ausschließlich für Fable 5, Mythos 5, Opus 4.8 und Opus 4.7 verfügbar. Wenn Sie in Claude Code `xhigh` für Opus 4.6 oder Sonnet 4.6 wählen, führt das System die Anfrage automatisch auf Level `high` aus.

### 10.2. Preisgestaltung pro Token vs. Gesamtkosten

> **Frage:** Erhöht das Level `effort` den Preis pro Token?  
> **Antwort:** Nein, der Preis pro 1.000.000 Tokens ist fixiert ($10 Input / $50 Output für Fable 5). Die höheren Kosten einer Anfrage sind ausschließlich darauf zurückzuführen, dass das Modell mehr versteckte Reasoning-Tokens generiert und mehr Tool-Calls ausführt.

### 10.3. Unterschiede zwischen ultracode und der System-Instruktion ultrathink

> **Frage:** Worin liegt der Unterschied zwischen `ultracode` und `ultrathink`?  
> **Antwort:** `ultracode` ist eine Konfiguration der Claude Code-Umgebung (Level `xhigh` + erweiterte Autonomie-Rechte). `ultrathink` hingegen ist ein textueller Prompt-Trigger des Nutzers im Chat, der darum bittet, im aktuellen Schritt maximal tiefgehend zu reasonen.

### 10.4. Sinnhaftigkeit des Dauerbetriebs auf maximalen Einstellungen

> **Frage:** Sollte man Fable 5 immer auf Level `xhigh` betreiben?  
> **Antwort:** Nein. Laut Angaben der Anthropic-Entwickler übertrifft Fable 5 auf Level `high` bereits die früheren Flaggschiffe auf deren Maximum. Ein dauerhafter Betrieb auf `xhigh` führt zu spürbarer Latency und schnellem Verbrauch der Limits ohne wesentlichen Qualitätszuwachs bei normalen Aufgaben.