---
type: "BlogPosting"
title: "Claude-Code-Setup als Baum: Opus high im Main-Loop, Fable als /advisor"
description: "Claude Code als Baum: Opus 5.5 mit Effort high im Main-Loop, Fable 5.1 per /advisor, Subagenten auf Sonnet/Haiku — Setup zum Kopieren plus Kostenrechnung."
resource: "https://www.contextstudios.ai/de/blog/claude-code-setup-als-baum-opus-high-im-main-loop-fable-als-advisor"
language: "de"
tags: ["Claude Code", "Guide", "LLM-Kosten", "Developer Tools"]
generated:
  by: "process:contextstudios-md/1"
  at: "2026-10-05T09:07:21.451Z"
status: "stable"
---

# Claude-Code-Setup als Baum: Opus high im Main-Loop, Fable als /advisor

Published: 2026-09-30
Tags: Claude Code, Guide, LLM-Kosten, Developer Tools

![Claude-Code-Setup als Baum: Opus high im Main-Loop, Fable als /advisor](https://wary-platypus-754.convex.cloud/api/storage/991e7b8f-172e-43ca-936b-9f4b2c4ecd81)

**Kurzfassung:** Statt ein Modell für alles zu bezahlen, fährt dieses Setup Claude Code als Baum: Opus 5.5 mit Effort `high` läuft nur im Main-Loop, Fable 5.1 wird per `/advisor` an den Entscheidungspunkten zugeschaltet, und Subagenten erledigen das Grobe auf Sonnet und Haiku. Jeder Zweig hat eine eigene Kostenlogik — dieser Guide zeigt die Konfiguration zum Kopieren und rechnet jeden Zweig durch.
## Das Problem: ein Modell für alles ist die teuerste Lösung
Zwei Fehler kosten in Claude Code am meisten Geld — und beide sehen im Moment der Entscheidung wie Sparsamkeit aus.
Der erste: alles auf dem Flaggschiff. Wer den Main-Loop, jede Entscheidung über Subagent-Splits und jeden Datei-Read auf dem teuersten Modell laufen lässt, bezahlt Frontier-Preise für Arbeit, die ein Viertel des Preises nicht wert wäre.
Der zweite: Everything auf dem Sparmodell. Wer alles auf Haiku legt, spart pro Token — und zahlt es in Nachläufen zurück, weil das Modell Architekturentscheidungen falsch trifft, die man später mühsam korrigiert.
Der Ausweg ist keine einzelne Modellwahl, sondern eine Struktur: ein Baum, in dem jede Ebene genau die Intelligenz bekommt, die ihre Aufgabe braucht. Genau das macht die folgende Konfiguration.
## Der Baum in drei Ebenen
### Ebene 1: Der Main-Loop — Opus 5.5 mit Effort high
Der Main-Loop ist das Herz der Session: Er hält den Kontext, trifft die Orchestrations-Entscheidungen und schreibt den Kern des Codes. Hier gehört das zweitstärkste Modell rein — mit erhöhtem Effort.
Wichtig zu wissen: Opus 5.5 läuft in Claude Code standardmäßig mit Effort `medium`. Die Stufe `high` ist eine bewusste Entscheidung, kein Default. Sie lässt das Modell vor jedem Antwort-Schritt mehr denken — spürbar besser bei Architektur und Refactoring, sichtbar höher im Output-Token-Verbrauch.
```bash
/model opus
/effort high
```
Beide Angaben landen in deinen User Settings und bleiben über Sessions hinweg erhalten. Mit `/effort auto` löschst du die gespeicherte Stufe für das aktuelle Modell, ohne die anderen Einträge anzufassen.
In der `settings.json` sieht derselbe Zustand so aus:
```json
{
  "model": "opus",
  "modelSettings": {
    "claude-opus-5-5": {
      "effortLevel": "high"
    }
  }
}
```
Versionshinweis: Das `opus`-Alias löst auf der Anthropic API auf Opus 5.5 auf — dafür braucht Claude Code v2.1.280 oder neuer. Wer eine ältere Version pinnt oder über einen Gateway arbeitet, hängt sich per `ANTHROPIC_DEFAULT_OPUS_MODEL` an eine konkrete Modell-ID.
### Ebene 2: Der Advisor — Fable 5.1 per /advisor
Fable 5.1 ist das stärkste Modell im Claude-Katalog — und mit 10 $ pro Million Input-Tokens und 50 $ pro Million Output-Tokens auch das teuerste. Genau deshalb läuft es nicht im Main-Loop, sondern als Advisor.
Die Mechanik: Der Executor (bei dir Opus 5.5 im Main-Loop) entscheidet selbstständig, an welchen Punkten er den Advisor konsultiert — typischerweise bei Schlüsselentscheidungen wie Architekturwahl, Root-Cause-Analysen oder bevor er einen teuren Schritt anstößt. Claude Code kuratiert dann den Kontext und reicht ihn an den Advisor weiter. Abgerechnet wird der Sub-Inference zum Preis des Advisor-Modells.
```bash
/advisor fable
```
Ohne Argument öffnet `/advisor` einen Model-Picker; mit Argument wie oben wird das Modell direkt gesetzt. Die Wahl wird in den User Settings gespeichert und gilt dauerhaft — auch in headless-Läufen, seit v2.1.260 die Textform für Desktop-App, Remote Control und Headless-Modus erweitert hat. Fable 5.1 selbst braucht mindestens v2.1.257.
Zwei Betriebsdetails, die im Alltag zählen:
- **Consent-Prompt:** Auf Pro- und Max-Plänen kann Fable-Nutzung auf Usage Credits buchen. Claude Code fragt dann vor der ersten belasteten Anfrage nach — einmal bestätigt, erscheint die Nachfrage in der Session nicht wieder.
- **Alias-Feinheit:** Das Alias `best` löst auf Fable auf, wo verfügbar, sonst auf Opus. Wer es explizit mag, kann den Main-Loop also auch auf `best` stellen und bekommt denselben Effekt.
### Ebene 3: Subagent-Splits — Sonnet und Haiku
Nach unten wird der Baum billig: Recherchen, Datei-Durchsichten, Testläufe und Boilerplate gehören auf Sonnet 5 oder Haiku 4.5. Das Modell pro Subagent legst du im Frontmatter der Agentendatei fest:
```markdown
---
name: code-explorer
description: Durchsucht die Codebase nach Mustern und erstellt Übersichten
model: sonnet
---
Du durchsuchst den Code und lieferst eine strukturierte Zusammenfassung...
```
Für reine Mechanik-Aufgaben (Dateien listen, Logs sichten, simple Edits vorbereiten) reicht `model: haiku`.
Eine Grenze gibt es: Der Effort-Level ist pro Subagent noch nicht konfigurierbar — nur das Modell. Der entsprechende Feature-Request (Issue #43083 im claude-code-Repo) ist offen. Bis dahin steuerst du die Denktiefe von Subagenten nur über die Modellwahl selbst.
## Was der Baum kostet
Alle Preise pro Million Tokens (Listpreise, Anthropic API):
| Zweig | Modell | Input | Output | Cache-Read | Standard-Effort |
|---|---|---|---|---|---|
| Main-Loop | Opus 5.5 | 4 $ | 20 $ | 0,20 $ (5 %) | `medium` → hier `high` |
| Advisor | Fable 5.1 | 10 $ | 50 $ | 0,25 $ (2,5 %) | `high` (fix) |
| Split (Standard) | Sonnet 5 | 2 $ | 10 $ | 0,20 $ (5 %) | `high` |
| Split (Mechanik) | Haiku 4.5 | 1 $ | 5 $ | 0,10 $ (10 %) | — (nicht unterstützt) |
Zwei Definitionen vor der Beispielrechnung: Ein Main-Loop-Tag ist ein aktiver Arbeitstag mit Claude Code im Projektkontext; ein Advisor-Consult ist eine einzelne Konsultation des Advisor-Modells durch den Executor.
**Beispielrechnung (Listpreise, gerundet).** Ein Main-Loop-Tag mit 2 Mio. Input-Tokens (davon 90 % aus dem Prompt-Cache) und 60.000 Output-Tokens:
- Opus 5.5, Effort high: 0,2 Mio. frische Input × 4 $ = 0,80 $, plus 1,8 Mio. Cache-Reads à 0,20 $ = 0,36 $, plus 60k Output à 20 $ = 1,20 $ → **rund 2,40 $**
- Dasselbe Volumen komplett auf Fable 5.1: 2,00 $ (Input) + 0,45 $ (Cache-Reads à 0,25 $) + 3,00 $ (Output) → **rund 5,45 $**
Der Advisor-Zweig kommt hinzu: Fünf Consults à 50.000 kuratierte Input-Tokens und 4.000 Output-Tokens kosten 5 × (0,50 $ + 0,20 $) = **3,50 $**.
Der Baum-Tag liegt in dieser Rechnung mit rund 5,90 $ knapp über dem Alles-auf-Fable-Tag (rund 5,45 $). Der Unterschied dreht sich aber mit der Sessionlänge: Im Main-Loop wächst Fables Tokenverbrauch mit jedem Loop-Schritt, während der Advisor-Zweig nur mit der Anzahl der Entscheidungspunkte steigt. Bei langen autonomen Sessions gewinnt der Baum deutlich; bei vielen kurzen, entscheidungsintensiven Sessions kann sich Fable direkt als Main-Loop-Modell lohnen — derselbe `/model`-Mechanismus, dieselben Settings.
Drei Kostensenker, die in beiden Varianten greifen:
- **Batch API:** 50 % Rabatt auf alle Modelle, wenn die Anfrage nicht interaktiv sein muss — etwa für Nightly-Analysen.
- **Prompt-Cache warm halten:** Cache-Reads kosten auf Opus 5.5 nur 5 % des Input-Preises, auf Fable 5.1 sogar nur 2,5 %. Eine Session, die länger als die Cache-Lebensdauer (typisch eine Stunde) pausiert, verliert den warmen Cache und bezahlt die Tokens beim Wiederaufbau neu.
- **Effort bewusst wählen:** `high` auf Opus ist der teuerste Denimodus unterhalb von `xhigh`. Für Routine-Tasks im Main-Loop ist `medium` (der Default) völlig ausreichend — `high` gehört in die Phasen, in denen Architektur entsteht.
## Betriebskontrolle: /usage ist das Dashboard des Baums
Der Baum funktioniert nur, wenn du siehst, welcher Zweig brennt. Dafür ist `/usage` gebaut:
- **Attribution:** Die Nutzungsaufteilung zeigt, wie viel auf Skills, Subagenten und einzelne MCP-Server entfällt — jeweils als Prozentsatz. Steigt der Subagenten-Anteil plötzlich, läuft irgendwo ein Split Amok.
- **Behavior Flags:** Verhalten wie langer Kontext oder Cache-Misses werden ab einem Anteil von 10 % markiert. Ein hoher Cache-Miss-Anteil ist meist der teuerste Einzelfehler im Setup.
- **Loop-Zeilen:** Jeder wiederkehrende `/loop`-Task bekommt eine eigene Zeile mit Häufigkeit, Tokenverbrauch je Lauf und letztem Lauf. Hier siehst du, ob ein wiederkehrender Task auf Sonnet läuft, aber ein Volumen produziert, das nur Opus rechtfertigen würde — oder umgekehrt.
- **Prompt-Cache-Zeile:** Ab v2.1.251 zeigt die Session-Block-Zeile `Prompt cache (main)` Trefferquote, Misses und Ursachen. Sie deckt nur den Haupt-Loop ab, nicht Subagenten.
Zur Einordnung: Anthropic beziffert die durchschnittlichen Enterprise-Kosten auf rund 13 $ pro Entwickler und aktivem Tag bzw. 150–250 $ pro Entwickler und Monat; 90 % der Nutzer bleiben unter 30 $ pro aktivem Tag. Wer mit dem Baum über diesen Werten liegt, sollte zuerst Attributions- und Cache-Zeilen prüfen, bevor er am Modell-Mix dreht. In Organisationen mit eigenen Konditionen setzt ein Admin eine `modelPricing`-Tabelle in den Managed Settings — dann rechnet die Kostenanzeige in `/usage` mit euren vertraglichen Preisen statt mit Listenpreisen.
## Wann der Baum nicht passt
Drei Situationen, in denen du die Struktur abwandeln solltest:
1. **Planen und Ausführen trennen genügt:** Der eingebaute `opusplan`-Modus ist nichts anderes als eine Zwei-Ebenen-Version des Baums — Opus im Plan-Modus, Sonnet in der Ausführung. Wer keine Advisor-Feinheit braucht, kommt mit `/model opusplan` und null Zusatzkonfiguration aus.
2. **Entscheidungsintensive Kurz-Sessions:** Wenn deine Sessions aus vielen kurzen, harten Entscheidungen bestehen und wenig mechanischer Arbeit, ist das Verhältnis des Baums ungünstig. Dann direkt `/model fable` (oder `best`) — Fable 5.1 hält lange autonome Sessions, prüft die eigene Arbeit gründlicher und braucht seltener Ermahnungen zum Testen.
3. **Haiku als Main-Loop-Ersatz:** Haiku 4.5 unterstützt keinen Effort-Level und hat einen 200K-Kontext. Als dritte Baumebene unschlagbar, als Main-Loop-Ersatz für komplexe Projekte die falsche Stelle zum Sparen.
## Checkliste zum Umbau
1. Claude Code auf mindestens v2.1.280 heben (`claude update`) — dann laufen alle drei Ebenen mit den aktuellen Modellen.
2. `/model opus` setzen, `/effort high` für Architektur-Phasen.
3. `/advisor fable` setzen und beim ersten Consult den Consent-Prompt für Usage Credits beantworten.
4. Subagenten in `.claude/agents/` anlegen: `model: sonnet` als Standard, `model: haiku` für Mechanik.
5. Nach drei bis fünf Arbeitstagen `/usage` prüfen: Subagenten-Anteil, Cache-Miss-Quote, Loop-Zeilen.
6. Cache-Miss-Quote über 10 %? Session-Pausen und Tool-Definitionen prüfen, bevor am Modell-Mix gedreht wird.
## FAQ
**Warum Opus im Main-Loop, wenn Fable stärker ist?**
Weil der Main-Loop das mit Abstand tokenintensivste Element der Session ist: Jeder Tool-Call, jede Kontextaktualisierung läuft durch ihn. Opus 5.5 kostet ein Viertel von Fable pro Output-Token — und mit Effort `high` erreicht es in Architektur- und Coding-Entscheidungen ein Niveau, das für Loop-Arbeit ausreicht. Die Fable-Intelligenz wird gezielt an den wenigen Punkten zugeschaltet, an denen sie den Unterschied macht.
**Wie entscheidet der Executor, wann der Advisor fragt?**
Der Executor hat die Kontrolle: Er ruft das Advisor-Tool selbstständig auf, wenn eine Entscheidung es wert ist — etwa vor Architekturentscheidungen oder bei widersprüchlichen Befunden. Claude Code kuratiert den Kontext für die Konsultation; der Advisor sieht eine kuratierte Fassung, kein Rohkopien des Verlaufs.
**Was passiert, wenn ich /advisor ohne Modell aufrufe?**
Es öffnet sich der Model-Picker, und die getroffene Wahl wird in den User Settings dauerhaft gespeichert. Mit Argument (`/advisor fable` oder eine volle Modell-ID) wird der Advisor ohne Picker direkt gesetzt.
**Kann ich den Effort auch pro Subagent setzen?**
Noch nicht. Das Modell pro Subagent ist im Frontmatter konfigurierbar, der Effort-Level bisher nicht — der Feature-Request ist als Issue #43083 im claude-code-Repo offen. Bis dahin gilt: höhere Denktiefe im Subagent-Moment = anderes Modell wählen, nicht denselben höher drehen.
**Brauche ich für Fable einen Max-Plan?**
Nein — Fable ist über die API und in Claude Code frei wählbar. Auf Pro- und Max-Abos kann die Nutzung allerdings auf Usage Credits gebucht werden; Claude Code zeigt das im `/model`-Picker an und fragt vor der ersten belasteten Anfrage nach.
**Wie prüfe ich, ob sich der Baum rechnet?**
`/usage` nach einer Woche, dann drei Zahlen gegen die Enterprise-Benchmarks halten: Gesamtsumme pro aktivem Tag, Subagenten-Anteil, Cache-Miss-Quote. Liegt der Tag unter ~30 $ und die Miss-Quote unter 10 %, ist der Baum sauber aufgesetzt.


## Related

- [KI-Agent-Entwicklung](https://www.contextstudios.ai/de/ki-agent-entwicklung.md)
- [KI-Entwicklung](https://www.contextstudios.ai/de/ki-entwicklung.md)
- [LLM-Integration](https://www.contextstudios.ai/de/llm-integration.md)
- [LLM-Entwicklung](https://www.contextstudios.ai/de/llm-entwicklung.md)