> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Modellkonfiguration
> Erfahren Sie mehr über die Claude Code-Modellkonfiguration, einschließlich Modellaliase wie `opusplan`
Verfügbare Modelle
Für die `model`-Einstellung in Claude Code können Sie konfigurieren:
* Einen **Modellalias**
* Einen **Modellnamen**
* Anthropic API: Einen vollständigen **[Modellnamen](https://platform.claude.com/docs/de/about-claude/models/overview)**
* Bedrock: ein Inference-Profil-ARN
* Foundry: einen Bereitstellungsnamen
* Vertex: einen Versionsnamen
`ANTHROPIC_BASE_URL` ändert, wohin Anfragen gesendet werden, nicht welches Modell sie beantwortet. Um Claude durch ein LLM-Gateway zu leiten, siehe [LLM-Gateways](/de/llm-gateway).
Modellaliase
Modellaliase bieten eine bequeme Möglichkeit, Modelleinstellungen auszuwählen, ohne sich genaue Versionsnummern merken zu müssen:
| Modellalias | Verhalten |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`default`** | Spezieller Wert, der jede Modellüberschreibung löscht und auf das empfohlene Modell für Ihren Kontotyp zurückgesetzt wird. Ist selbst kein Modellalias |
| **`best`** | Verwendet Fable 5, wo Ihre Organisation Zugriff darauf hat, andernfalls das neueste Opus-Modell |
| **`fable`** | Verwendet Claude Fable 5 für Ihre schwierigsten und längsten Aufgaben |
| **`sonnet`** | Verwendet das neueste Sonnet-Modell für tägliche Codierungsaufgaben |
| **`opus`** | Verwendet das neueste Opus-Modell für komplexe Reasoning-Aufgaben |
| **`haiku`** | Verwendet das schnelle und effiziente Haiku-Modell für einfache Aufgaben |
| **`sonnet[1m]`** | Verwendet Sonnet mit einem [1-Million-Token-Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows#1m-token-context-window) für lange Sitzungen. Hat keine Auswirkung, wenn `sonnet` bereits zu Sonnet 5 mit seinem nativen 1M-Fenster aufgelöst wird; hinter einem [LLM-Gateway](/de/llm-gateway) wählt es das 1M-Fenster für Sonnet 5 aus |
| **`opus[1m]`** | Verwendet Opus mit einem [1-Million-Token-Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows#1m-token-context-window) für lange Sitzungen |
| **`opusplan`** | Spezieller Modus, der `opus` während des Plan Mode verwendet und dann zu `sonnet` für die Ausführung wechselt |
Bei der Anthropic API wird `opus` zu Opus 4.8 und `sonnet` zu Sonnet 5 aufgelöst. Bei [Claude Platform on AWS](/de/claude-platform-on-aws) wird `opus` zu Opus 4.7 und `sonnet` zu Sonnet 4.6 aufgelöst. Bei Bedrock, Vertex und Foundry wird `opus` zu Opus 4.6 und `sonnet` zu Sonnet 4.5 aufgelöst; neuere Modelle sind bei diesen Anbietern verfügbar, indem Sie den vollständigen Modellnamen explizit auswählen oder `ANTHROPIC_DEFAULT_OPUS_MODEL` oder `ANTHROPIC_DEFAULT_SONNET_MODEL` setzen.
Aliase verweisen auf die empfohlene Version für Ihren Anbieter und werden im Laufe der Zeit aktualisiert. Um eine bestimmte Version zu fixieren, verwenden Sie den vollständigen Modellnamen, z. B. `claude-opus-4-8`, oder setzen Sie die entsprechende Umgebungsvariable wie `ANTHROPIC_DEFAULT_OPUS_MODEL`.
Sonnet 5 erfordert Claude Code v2.1.197 oder später. Opus 4.8 erfordert v2.1.154 oder später. Führen Sie `claude update` aus, um zu aktualisieren.
Mit Fable 5 arbeiten
[Claude Fable 5](https://platform.claude.com/docs/de/about-claude/models/introducing-claude-fable-5-and-claude-mythos-5) ist das leistungsfähigste Modell in Claude Code, geeignet für Aufgaben, die länger als eine einzelne Sitzung dauern. Es unterstützt lange autonome Sitzungen, untersucht vor dem Handeln und überprüft seine Arbeit häufiger als kleinere Modelle.
Fable 5 ist nicht das Standardmodell. Wählen Sie es mit `/model fable` aus. Anfragen, die seine Sicherheitsklassifizierer kennzeichnen, meist in Cybersicherheits- und Biologie-Bereichen, lösen [automatisches Modell-Fallback](#automatic-model-fallback) aus.
Um das Beste aus Fable 5 herauszuholen:
* **Beschreiben Sie das Ergebnis, nicht die Schritte**: Geben Sie ihm das Ergebnis, das Sie möchten, und lassen Sie es den Weg planen. Um es arbeiten zu lassen, bis dieses Ergebnis eintritt, [setzen Sie ein Ziel](/de/goal).
* **Geben Sie ihm mehrdeutige Probleme**: Root-Cause-Untersuchungen, Ausfalldebugging und Architekturentscheidungen sind Bereiche, in denen die zusätzliche Untersuchung und Überprüfung sich auszahlt.
* **Überspringen Sie die Überprüfungserinnerungen**: Es überprüft seine eigene Arbeit mit weniger Aufforderungen, daher sind Erinnerungen zum Testen oder Überprüfen normalerweise unnötig.
* **Größere Aufgaben einschätzen**: Geben Sie ihm Arbeit, die Sie normalerweise in Teile aufteilen würden. Es hält lange Sitzungen, ohne den Faden zu verlieren.
Fable 5 erfordert Claude Code v2.1.170 oder später. Ältere Versionen zeigen Fable 5 nicht in der Modellauswahl an und können es nicht auswählen. Führen Sie `claude update` aus, um zu aktualisieren. Fable 5 ist nicht unter [Zero Data Retention](/de/zero-data-retention) verfügbar, wo die `/model`-Auswahl es entweder auslässt oder deaktiviert anzeigt.
Einstellung Ihres Modells
Sie können Ihr Modell auf mehrere Arten konfigurieren, aufgelistet nach Priorität:
1. **Während der Sitzung**: Verwenden Sie `/model `, um sofort zu wechseln, oder führen Sie `/model` ohne Argument aus, um die Auswahl zu öffnen. Die Auswahl fordert zur Bestätigung auf, wenn das Gespräch vorherige Ausgaben hat, da die nächste Antwort den vollständigen Verlauf ohne zwischengespeicherten Kontext erneut liest
2. **Beim Start**: Starten Sie mit `claude --model `
3. **Umgebungsvariable**: Setzen Sie `ANTHROPIC_MODEL=`
4. **Einstellungen**: Konfigurieren Sie dauerhaft in Ihrer Einstellungsdatei mit dem `model`-Feld
Ab v2.1.153 speichert `/model` Ihre Auswahl als Standard für neue Sitzungen, indem das `model`-Feld in Ihren Benutzereinstellungen geschrieben wird. In der Auswahl:
* `Enter`: Modell wechseln und als Standard speichern
* `s`: Modell nur für diese Sitzung wechseln
Die direkte Eingabe von `/model ` verhält sich wie `Enter`. Projekt- und verwaltete Einstellungen haben weiterhin Vorrang und werden beim nächsten Start erneut angewendet.
In v2.1.144 bis v2.1.152 galt `/model` nur für die aktuelle Sitzung und `d` in der Auswahl speicherte einen Standard.
Das `--model`-Flag und die `ANTHROPIC_MODEL`-Umgebungsvariable gelten nur für die Sitzung, mit der Sie sie starten. Um verschiedene Modelle in verschiedenen Terminals gleichzeitig auszuführen, starten Sie jedes mit seinem eigenen `--model`-Flag, anstatt mit `/model` zu wechseln.
Fortgesetzte Sitzungen, die mit `claude --resume`, `--continue` oder der `/resume`-Auswahl gestartet werden, behalten das Modell bei, das sie verwendeten, als das Transkript gespeichert wurde, unabhängig von der aktuellen `model`-Einstellung. Wenn das angeforderte Modell eingestellt wurde oder durch [`availableModels`](#restrict-model-selection) ausgeschlossen ist, fällt die Sitzung auf die normale Prioritätsreihenfolge zurück. Dies verhindert, dass die `/model`-Auswahl einer anderen Sitzung das Modell beim Fortsetzen ändert.
Ein Modell, das Sie für den neuen Start mit `--model` oder `ANTHROPIC_MODEL` auswählen, hat weiterhin Vorrang vor dem wiederhergestellten Modell. {/* min-version: 2.1.195 */}Ab v2.1.195 gilt dies auch für eine [`ANTHROPIC_DEFAULT_OPUS_MODEL`](#environment-variables)-Familienvariable.
Wenn das aktive Modell beim Start aus Projekt- oder verwalteten Einstellungen stammt und nicht aus Ihrer eigenen Auswahl, zeigt der Startheader an, welche Einstellungsdatei es festgelegt hat. Führen Sie `/model` aus, um es zu überschreiben; die Projekt- oder verwaltete Einstellung wird beim nächsten Start erneut angewendet.
Wenn das angeforderte Modell ein geplantes Ruhestandsdatum hat oder automatisch auf eine neuere Version neu zugeordnet wird, zeigt Claude Code eine Warnung an, die das angeforderte Modell benennt. Interaktive Sitzungen zeigen es als Startnachricht an. Ab v2.1.182 wird die gleiche Warnung in [nicht-interaktivem Modus](/de/headless) auf stderr geschrieben, wenn das Standard-Textausgabeformat verwendet wird. Die Überprüfung deckt auch ein `model` ab, das in [Subagent-Frontmatter](/de/sub-agents) festgelegt ist. Die stderr-Warnung wird für `--output-format json` und `stream-json` unterdrückt; lesen Sie das tatsächliche Modell stattdessen aus dem `modelUsage`-Feld der [Ergebnisnachricht](/de/headless#get-structured-output).
Beispielverwendung:
```bash theme={null}
# Mit Opus starten
claude --model opus
# Während der Sitzung zu Sonnet wechseln
/model sonnet
```
Beispiel-Einstellungsdatei:
```json theme={null}
{
"permissions": {
...
},
"model": "opus"
}
```
Modellauswahl einschränken
Enterprise-Administratoren können `availableModels` in [verwalteten oder Richtlinieneinstellungen](/de/settings#settings-files) verwenden, um einzuschränken, welche Modelle Benutzer auswählen können. Einträge entsprechen einer Modellfamilie wie `sonnet`, einem Versionspräfix wie `claude-sonnet-4-5` oder einer vollständigen Modell-ID wie `claude-sonnet-4-5-20250929`.
Wenn `availableModels` gesetzt ist, gilt die Zulassungsliste überall dort, wo ein Benutzer ein Modell angeben kann:
* **Hauptsitzungsmodell**: `/model`, das `--model`-Flag, die `ANTHROPIC_MODEL`-Umgebungsvariable, die `model`-Einstellung und das Modell, das beim [Fortsetzen einer Sitzung](#setting-your-model) wiederhergestellt wird
* **Alias-Auflösung**: {/* min-version: 2.1.176 */}die Umgebungsvariablen `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL` und `ANTHROPIC_DEFAULT_FABLE_MODEL` können einen zulässigen Alias nicht zu einem Modell außerhalb der Liste umleiten
* **Schnellmodus**: {/* min-version: 2.1.176 */}`/fast` weigert sich umzuschalten, wenn dies implizit zu einem Opus-Modell außerhalb der Liste führen würde, mit der Meldung „is not in your organization's allowed models"
* **Subagent-Modelle**: das `model`-Feld in [Subagent](/de/sub-agents#choose-a-model)-Frontmatter, der `model`-Parameter des Agent-Tools, die Modellauswahl in `/agents` und `CLAUDE_CODE_SUBAGENT_MODEL`
* **Skill- und Befehlsmodelle**: das `model`-Frontmatter in [Skills und Befehlen](/de/skills)
* **Advisor-Modell**: die konfigurierte [`advisorModel`](/de/advisor)-Einstellung und das `--advisor`-Flag
* **Hintergrund-Agent-Modell**: das Modell, das in der [Dispatch-Auswahl](/de/agent-view) ausgewählt ist
Das Wechseln zu einem blockierten Modell mit `/model` wird mit einem Fehler abgelehnt, während ein blockiertes `--model`-Flag, `ANTHROPIC_MODEL` oder `model`-Einstellungswert beim Start mit einer Warnung ersetzt wird, die sowohl das angeforderte als auch das ersetzte Modell benennt, und die Sitzung startet auf dem Standardmodell. Ein blockierter Subagent-, Skill- oder Befehl-Override fällt auf das geerbte oder Standardmodell zurück, anstatt die Anfrage fehlschlagen zu lassen; eine blockierte `advisorModel`-Einstellung deaktiviert den Advisor für die Sitzung, während ein blockiertes `--advisor`-Flag-Wert beim Start mit einem Fehler beendet wird. Ausgeschlossene Modelle sind in der `/model`-Auswahl verborgen.
Automatische Modellwechsel werden auf die gleiche Weise überprüft: Elemente einer [Fallback-Modellkette](#fallback-model-chains) außerhalb der Zulassungsliste werden gelöscht, ein Plan-Modus-Upgrade wie [`opusplan`](#opusplan-model-setting) zu einem ausgeschlossenen Modell wird übersprungen, sodass die Planung auf dem Sitzungsmodell fortgesetzt wird, und ein [automatisches Modell-Fallback](#automatic-model-fallback), dessen Ziel ausgeschlossen ist, wird nicht ausgeführt, sodass die gekennzeichnete Anfrage stattdessen mit einer Ablehnung endet. Das Aktivieren des [Schnellmodus](/de/fast-mode) wird abgelehnt, wenn das Modell, auf dem die Sitzung danach ausgeführt würde, außerhalb der Zulassungsliste liegt.
```json theme={null}
{
"availableModels": ["sonnet", "haiku"]
}
```
Oberflächenabdeckung
Jede Oberfläche erzwingt die Zulassungsliste, die sie erhält. Welcher Bereitstellungsmechanismus jede Oberfläche erreicht, unterscheidet sich:
| Bereitstellungsmechanismus | CLI und IDE | Desktop-Lokalsitzungen | Web-, Mobil- und Cloud-Sitzungen | Agent SDK und nicht-interaktiv | Cowork |
| :---------------------------------------------------------------------------------- | :---------- | :--------------------- | :------------------------------- | :----------------------------- | :--------------------------- |
| [Serververwaltete Einstellungen](/de/server-managed-settings) aus der Admin-Konsole | Erzwungen | Erzwungen | Erzwungen | Erzwungen | Nicht bereitgestellt |
| [MDM oder verwaltete Einstellungsdateien](/de/settings#settings-files) | Erzwungen | Erzwungen | Nicht bereitgestellt | Erzwungen | Erzwungen, wo bereitgestellt |
* Cloud-Sitzungen auf [Claude Code im Web](/de/claude-code-on-the-web) oder in der Desktop-App werden auf von Anthropic verwalteten VMs ausgeführt: Einstellungen, die auf Ihrem Gerät bereitgestellt werden, erreichen sie nicht, daher stellen Sie die Zulassungsliste über serververwaltete Einstellungen bereit. Ein Modellwechsel während einer Sitzung in einer Cloud-Sitzung wird abgelehnt, wenn das angeforderte Modell durch die Zulassungsliste ausgeschlossen ist. Die serverseitige Ablehnung bei der Sitzungserstellung gilt für [Organisationsmodellbeschränkungen](#organization-model-restrictions), nicht für den `availableModels`-Einstellungsschlüssel.
* Cowork, die agentengesteuerte Arbeitsregisterkarte in der Claude Desktop-App, ist keine Claude Code-Oberfläche und erhält serververwaltete Einstellungen nicht absichtlich. Eine verwaltete Einstellungsdatei gilt für Cowork-Sitzungen, wenn sie dort vorhanden ist, wo die Sitzung ausgeführt wird; Remote-Cowork-Sitzungen werden auf von Anthropic verwalteten VMs ausgeführt, wo eine gerätebereits bereitgestellte Datei nicht vorhanden ist.
* Sitzungen auf [Drittanbieter-Anbietern](/de/server-managed-settings#platform-availability) wie Bedrock, Vertex AI, Foundry und [Claude Platform auf AWS](/de/claude-platform-on-aws) erhalten keine serververwalteten Einstellungen, daher stellen Sie die Zulassungsliste dort über MDM oder verwaltete Einstellungsdateien bereit.
* Die serververwaltete Bereitstellung erfordert auch, dass sich die Sitzung mit einem Organisationslogin oder einem direkt konfigurierten API-Schlüssel authentifiziert. Flotten, die Schlüssel nur über ein [`apiKeyHelper`](/de/settings#available-settings)-Skript generieren, sollten die Zulassungsliste über MDM oder verwaltete Einstellungsdateien bereitstellen.
* Die Desktop Code-Registerkarte hostet auch [SSH-Sitzungen](/de/desktop#ssh-sessions), die die verwaltete Einstellungsdatei vom Remote-Host lesen, auf dem sie ausgeführt werden. Siehe [Desktop-verwaltete Einstellungen](/de/desktop#managed-settings).
* Die Modellauswahl auf claude.ai und in der Desktop-App verbergen oder graut Modelle aus, die durch die Zulassungsliste Ihrer Organisation ausgeschlossen sind. Der Auswahlzustand ist eine Annehmlichkeit für Benutzer; die Erzwingung erfolgt in der Sitzung.
Standardmodell-Verhalten
Die Option „Standard" in der Modellauswahl wird nicht von `availableModels` beeinflusst, es sei denn, [`enforceAvailableModels`](#enforce-the-allowlist-for-the-default-model) ist auch gesetzt. Allein lässt `availableModels` „Standard" verfügbar, das sich zum Laufzeit-Standard des Systems auflöst, [basierend auf dem Abonnement-Tier des Benutzers](#default-model-setting). Wenn der Tier-Standard ein Modell ist, das Sie einschränken möchten, setzen Sie auch `enforceAvailableModels`.
Ein leeres `availableModels`-Array aktiviert niemals die Erzwingung des Standardmodells: Mit `availableModels: []` werden benannte Modellauswahlen blockiert, aber das Standardmodell für den Kontotyp bleibt unabhängig von `enforceAvailableModels` nutzbar.
Erzwingen Sie die Zulassungsliste für das Standardmodell
Setzen Sie `enforceAvailableModels: true` zusammen mit einer nicht leeren `availableModels` in verwalteten Einstellungen, um die Zulassungsliste auf die Option „Standard" auszudehnen. Dies erfordert Claude Code v2.1.175 oder später.
```json theme={null}
{
"availableModels": ["sonnet", "haiku"],
"enforceAvailableModels": true
}
```
Wenn das Standardmodell für den Kontotyp des Benutzers nicht in der Zulassungsliste enthalten ist, wird die Option „Standard" stattdessen auf den ersten `availableModels`-Eintrag aufgelöst, der ein zulässiges, verfügbares Modell benennt, und die Zeile „Standard" der `/model`-Auswahl zeigt dieses Modell. Dies gilt überall dort, wo der Standard erreicht wird: Sitzungsstart, Auswahl von „Standard" in `/model`, das Schlüsselwort `"default"` in [Fallback-Modellketten](#fallback-model-chains) und das Fallback, das verwendet wird, wenn eine ausgeschlossene Auswahl gelöscht wird.
`enforceAvailableModels` hat keine Auswirkung, wenn `availableModels` nicht gesetzt oder leer ist: Mit `availableModels: []` bleibt das Standardmodell für den Kontotyp nutzbar, sodass die Einstellung Benutzer nicht aus jedem Modell sperren kann. Wenn `availableModels` nicht leer ist, aber kein Eintrag zu einem zulässigen und verfügbaren Modell aufgelöst wird, wird die Erzwingung herabgestuft und „Standard" fällt auf den Kontotyp-Standard zurück, mit einer Warnung, die nur unter `--debug` sichtbar ist. Behalten Sie mindestens einen garantiert verfügbaren Eintrag in der Liste, um dies zu vermeiden.
Stellen Sie beide Schlüssel in der [höchsten Prioritäts-verwalteten Quelle](/de/settings#settings-precedence) bereit: Von Administratoren bereitgestellte verwaltete Quellen werden nicht zusammengeführt, daher wird ein Paar, das in einer verwalteten Einstellungsdatei platziert ist, ignoriert, wenn die Admin-Konsole Einstellungen bereitstellt.
Kontrollieren Sie das Modell, auf dem Benutzer ausgeführt werden
Die `model`-Einstellung ist eine anfängliche Auswahl, keine Erzwingung. Sie legt fest, welches Modell aktiv ist, wenn eine Sitzung startet, aber Benutzer können weiterhin `/model` öffnen und „Standard" auswählen, das sich zum Systemstandard für ihren Tier auflöst, unabhängig davon, was `model` gesetzt ist, es sei denn, [`enforceAvailableModels`](#enforce-the-allowlist-for-the-default-model) leitet es um.
Um die Modellerfahrung vollständig zu kontrollieren, kombinieren Sie diese Einstellungen:
* **`availableModels`**: schränkt ein, welche benannten Modelle Benutzer wechseln können
* **`enforceAvailableModels`**: erweitert die `availableModels`-Zulassungsliste auf die Option „Standard", sodass „Standard" nicht auf ein Modell außerhalb der Liste aufgelöst werden kann
* **`model`**: legt die anfängliche Modellauswahl fest, wenn eine Sitzung startet
* **`ANTHROPIC_DEFAULT_SONNET_MODEL`** / **`ANTHROPIC_DEFAULT_OPUS_MODEL`** / **`ANTHROPIC_DEFAULT_HAIKU_MODEL`** / **`ANTHROPIC_DEFAULT_FABLE_MODEL`**: steuern, worauf sich die Option „Standard" und die Aliase `sonnet`, `opus`, `haiku` und `fable` auflösen
Dieses Beispiel startet Benutzer auf Sonnet 4.5, begrenzt die Auswahl auf Sonnet und Haiku und stellt sicher, dass „Standard" auf ein Modell in der Zulassungsliste aufgelöst wird, anstatt auf den Tier-Standard:
```json theme={null}
{
"model": "claude-sonnet-4-5",
"availableModels": ["claude-sonnet-4-5", "haiku"],
"enforceAvailableModels": true,
"env": {
"ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-5"
}
}
```
Ohne `enforceAvailableModels` oder den `env`-Block würde ein Benutzer, der „Standard" in der Auswahl auswählt, die neueste Version für seinen Tier erhalten und damit die Versionsfixierung in `model` und `availableModels` umgehen. Die beiden Einstellungen decken unterschiedliche Bereiche ab: `enforceAvailableModels` macht „Standard" der Zulassungsliste unterworfen, während der `env`-Block festlegt, auf welche Version ein zulässiger Alias wie `sonnet` aufgelöst wird. Verwenden Sie `enforceAvailableModels` allein, wenn das Einschränken von Modellfamilien ausreicht; fügen Sie den `env`-Block hinzu, wenn Sie auch eine bestimmte Version fixieren müssen.
Merge-Verhalten
Wenn die [höchste Prioritäts-verwaltete Einstellungsquelle](/de/server-managed-settings#settings-precedence) `availableModels` definiert, gilt diese Liste allein: Einträge in Benutzer-, Projekt- oder lokalen Einstellungen können sie nicht erweitern, und von Administratoren bereitgestellte verwaltete Quellen werden nicht miteinander zusammengeführt, daher wird eine Liste, die in einer verwalteten Einstellungsdatei bereitgestellt wird, ignoriert, wenn serververwaltete Einstellungen Schlüssel bereitstellen. Andernfalls werden Listen aus Benutzer-, Projekt- und lokalen Einstellungen wie andere Array-Einstellungen [verkettet und dedupliziert](/de/settings#settings-precedence). {/* min-version: 2.1.175 */}Ab Claude Code v2.1.175 ersetzt die verwaltete Liste Einträge mit niedrigerer Priorität; frühere Versionen führen sie zusammen.
Innerhalb der effektiven Liste deaktiviert ein Eintrag, der ein bestimmtes Modell in einer Familie benennt, ob ein Versionspräfix oder eine vollständige Modell-ID, den Wildcard-Eintrag dieser Familie: `["sonnet", "claude-sonnet-4-5"]` erlaubt nur Sonnet 4.5-Versionen, nicht jedes Sonnet-Modell.
Mantle-Modell-IDs
Wenn der [Bedrock Mantle-Endpunkt](/de/amazon-bedrock#use-the-mantle-endpoint) aktiviert ist, werden Einträge in `availableModels`, die mit `anthropic.` beginnen, als benutzerdefinierte Optionen zur `/model`-Auswahl hinzugefügt und zum Mantle-Endpunkt weitergeleitet. Dies ist eine Ausnahme zu der in [Modelle für Drittanbieter-Bereitstellungen fixieren](#pin-models-for-third-party-deployments) beschriebenen Alias-Zuordnung. Die Einstellung schränkt die Auswahl weiterhin auf aufgelistete Einträge ein, und eine Mantle-ID enthält einen Familiennamen, daher zählt sie als spezifischer Eintrag und deaktiviert den Wildcard dieser Familie: Führen Sie zusammen mit allen Mantle-IDs die Versionspräfixe oder vollständigen IDs auf, die Sie selektierbar halten möchten. Siehe [Merge-Verhalten](#merge-behavior).
Organisationsmodellbeschränkungen
Organisationsadministratoren schränken ein, welche Modelle Mitglieder ausführen können, indem sie einzelne Modelle in der Claude Console deaktivieren. Verwenden Sie den Console-Schalter anstelle von `availableModels`, wenn Ihre Mitglieder sich über die Anthropic API authentifizieren und Sie einen organisationsweiten Schalter ohne Bereitstellung von Einstellungsdateien möchten. Diese Beschränkung wird mit den Berechtigungen des Kontos bereitgestellt, wenn Claude Code sich authentifiziert, getrennt von jeder `availableModels`-Liste in Einstellungen, und der Server erzwingt die gleiche Beschränkung unabhängig, wenn eine Sitzung erstellt wird. Erfordert Claude Code v2.1.187 oder später.
Ein eingeschränktes Modell ist in der `/model`-Auswahl verborgen. Die Auswahl nach Name mit `--model`, der `ANTHROPIC_MODEL`-Umgebungsvariable oder der `model`-Einstellung zeigt die Mitteilung `Model "" is restricted by your organization's settings. Using instead.` und die Sitzung startet auf einem zulässigen Modell. Die Eingabe von `/model ` für ein eingeschränktes Modell wird mit `Model '' is restricted by your organization's settings. Run /model to choose a different model.` abgelehnt und die Sitzung behält ihr aktuelles Modell.
Die beiden Mechanismen setzen sich zusammen: Ein Modell ist nur selektierbar, wenn es durch `availableModels` zulässig ist und nicht durch die Organisation eingeschränkt ist. Organisationsbeschränkungen werden an Sitzungen auf der Anthropic API und [LLM Gateway](/de/llm-gateway)-Bereitstellungen bereitgestellt. Sitzungen auf Bedrock, Vertex AI, Foundry und Claude Platform auf AWS erhalten sie nicht, daher verwenden Sie stattdessen `availableModels` auf diesen Anbietern.
Spezielles Modellverhalten
`default`-Modelleinstellung
Das Verhalten von `default` hängt von Ihrem Kontotyp ab:
* **Max, Team Premium, Enterprise Pay-as-you-go und Anthropic API**: Standard ist Opus 4.8
* **Claude Platform auf AWS**: Standard ist Opus 4.7
* **Pro, Team Standard und Enterprise-Abonnementplätze**: Standard ist Sonnet 5
* **Bedrock, Vertex und Foundry**: Standard ist Sonnet 4.5
Enterprise Pay-as-you-go bedeutet eine Enterprise-Organisation, die nach Nutzung statt nach Abonnementplatz abgerechnet wird.
Wenn verwaltete Einstellungen [die Zulassungsliste für das Standardmodell erzwingen](#enforce-the-allowlist-for-the-default-model) und der Kontotyp-Standard nicht in `availableModels` enthalten ist, wird `default` zum erzwungenen Standard aufgelöst, anstatt zum Kontotyp-Standard oben.
Fable 5 ist auf keinem Kontotyp das Standardmodell. Sitzungen verwenden Fable 5 nur, nachdem Sie es auswählen, mit `/model fable`, einer `model`-Einstellung oder dem `best`-Alias, wo Fable 5 verfügbar ist. Wenn Sie es mit `/model` auswählen, wird es als das ausgewählte Modell in Ihren Benutzereinstellungen gespeichert, sodass spätere Sitzungen auf Fable 5 starten, bis Sie die Modelle ändern.
`opusplan`-Modelleinstellung
Der `opusplan`-Modellalias bietet einen automatisierten Hybrid-Ansatz:
* **Im Plan-Modus**: verwendet `opus` für komplexes Reasoning und Architekturentscheidungen
* **Im Ausführungsmodus**: wechselt automatisch zu `sonnet` für Code-Generierung und Implementierung
Dies kombiniert Opus's Reasoning für die Planung mit Sonnets Effizienz für die Ausführung.
Das Kontextfenster der Plan-Modus-Opus-Phase ist das gleiche wie bei der `opus`-Modelleinstellung. Bei Abonnement-Tiers, bei denen Opus [automatisch auf 1M-Kontext aktualisiert wird](#extended-context), erhält `opusplan` die Aktualisierung auch im Plan-Modus. Um 1M-Kontext für beide Phasen zu erzwingen, wenn Sie sich nicht auf einem Auto-Upgrade-Tier befinden, setzen Sie das Modell auf `opusplan[1m]`.
Wenn [`availableModels`](#restrict-model-selection) Opus ausschließt, bleibt `opusplan` im Plan-Modus auf Sonnet, anstatt zu wechseln. Ähnlich bleibt eine Haiku-Sitzung, die normalerweise im Plan-Modus zu Sonnet aktualisiert würde, auf Haiku, wenn Sonnet ausgeschlossen ist.
Für einen Hybrid-Ansatz, bei dem Claude während einer Aufgabe entscheidet, wann ein zweites Modell konsultiert werden soll, anstatt an der Plan-Grenze zu wechseln, siehe das [Advisor-Tool](/de/advisor).
Fallback-Modellketten
Wenn das primäre Modell überlastet ist, nicht verfügbar ist oder einen anderen nicht wiederholbaren Serverfehler zurückgibt, kann Claude Code zu einem Fallback-Modell wechseln, anstatt die Anfrage fehlschlagen zu lassen. Authentifizierungs-, Abrechnungs-, Rate-Limit-, Anfragegröße- und Transportfehler lösen niemals einen Wechsel aus; diese folgen ihrem normalen Wiederholungs- und Fehlerbehandlung.
Konfigurieren Sie ein oder mehrere Fallback-Modelle und Claude Code versucht sie der Reihe nach, wobei eine Benachrichtigung angezeigt wird, wenn es wechselt. Der Wechsel gilt nur für den aktuellen Durchgang, sodass Ihre nächste Nachricht zuerst wieder das primäre Modell versucht. Ketten sind auf drei Modelle nach Duplikatentfernung begrenzt, und zusätzliche Einträge werden ignoriert.
Setzen Sie eine Kette für eine Sitzung mit dem `--fallback-model`-Flag, das eine kommagetrennte Liste akzeptiert:
```bash theme={null}
claude --fallback-model sonnet,haiku
```
Um eine Kette über Sitzungen hinweg beizubehalten, setzen Sie `fallbackModel` in [Einstellungen](/de/settings) als Array:
```json theme={null}
{
"fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}
```
Das `--fallback-model`-Flag hat Vorrang vor der `fallbackModel`-Einstellung. Jedes Element akzeptiert einen Modellnamen oder Alias, und `"default"` wird auf das Standardmodell erweitert.
Zwei Fälle führen dazu, dass ein Element übersprungen wird:
* **Nicht verfügbares Modell**: Ein Modell, das nicht erreichbar ist, z. B. ein in Einstellungen angeheftetes veraltetes Modell, wird übersprungen und Claude Code fährt mit dem nächsten Element fort.
* **Außerhalb der Zulassungsliste**: Ein Element, das nicht von [`availableModels`](#restrict-model-selection) erlaubt ist, wird gelöscht, wenn die Kette gelesen wird, und wird nie versucht.
Automatisches Modell-Fallback
Dieser Abschnitt behandelt inhaltsbasiertes Fallback von Fable 5. Für verfügbarkeitsbasiertes Fallback, wenn ein Modell überlastet oder nicht verfügbar ist, siehe [Fallback-Modellketten](#fallback-model-chains).
Fable 5 wird mit Sicherheitsklassifizierern für Cybersicherheits- und Biologie-Inhalte ausgeführt. Wenn ein Klassifizierer eine Anfrage kennzeichnet, führt Claude Code diese Anfrage auf dem Standard-Opus-Modell erneut aus und zeigt eine Benachrichtigung im Transkript an: Opus 4.8 auf der Anthropic API und [LLM-Gateway](/de/llm-gateway)-Bereitstellungen oder Opus 4.7 auf [Claude Platform auf AWS](/de/claude-platform-on-aws).
Die Sitzung wird dann auf diesem Opus-Modell fortgesetzt. Um zu Fable 5 zurückzukehren, führen Sie `/model fable` aus.
Das Fallback-Ziel wird gegen [`availableModels`](#restrict-model-selection) überprüft. Wenn es blockiert ist, findet kein Fallback statt. Die Ablehnung erscheint als normaler Fehler und das Modell der Sitzung bleibt unverändert.
Überprüfen Sie, was das Fallback ausgelöst hat
Fallback kann bei der ersten Anfrage einer Sitzung ausgelöst werden, bevor Sie etwas Ungewöhnliches senden, da die erste Anfrage Workspace-Kontext wie Ihren CLAUDE.md-Inhalt und Git-Status trägt. Ein Repository, das Sicherheits- oder Biologie-Material enthält, kann den Klassifizierer allein auf diesem Kontext auslösen.
Um zu überprüfen, ob Anpassungen der Auslöser sind, starten Sie eine Sitzung mit `claude --safe-mode`, das Anpassungen wie CLAUDE.md, Skills, MCP-Server und Hooks deaktiviert. Git-Status und Verzeichnisnamen sind keine Anpassungen und sind immer noch enthalten.
Vor dem Wechsel fragen
Um zu entscheiden, was jedes Mal passiert, wenn eine Anfrage gekennzeichnet wird, anstatt automatisch zu wechseln, führen Sie `/config` aus und schalten Sie „Modelle wechseln, wenn eine Nachricht gekennzeichnet wird" aus. Eine gekennzeichnete Anfrage pausiert dann die Sitzung mit zwei Optionen: zum Opus-Modell wechseln oder den Prompt bearbeiten und auf Fable 5 erneut versuchen.
Einige Fälle verhalten sich unterschiedlich:
* Wenn beide Modelle die gleiche Anfrage kennzeichnen, können Sie den Prompt bearbeiten und erneut versuchen oder eine neue Sitzung starten.
* Bei mobilen [Claude Code im Web](/de/claude-code-on-the-web)-Sitzungen wird das Bearbeiten und erneute Versuchen nicht unterstützt. Wechseln Sie Modelle oder setzen Sie die Sitzung in einem Desktop-Browser oder der Desktop-App fort.
* Im [nicht-interaktiven Modus](/de/cli-reference#cli-flags) und SDK-Integrationen, die den Prompt nicht anzeigen können, endet eine gekennzeichnete Anfrage den Durchgang mit einer Ablehnung.
* Wenn das Fallback-Ziel durch [`availableModels`](#restrict-model-selection) blockiert ist, wird der Prompt nicht angezeigt. Die gekennzeichnete Anfrage endet mit der Ablehnung, genauso wie automatisches Fallback, wenn das Ziel blockiert ist.
Aktivieren Sie Fallback auf Bedrock, Vertex AI und Foundry
Auf [Amazon Bedrock](/de/amazon-bedrock), [Google Vertex AI](/de/google-vertex-ai) und [Microsoft Foundry](/de/microsoft-foundry) sind Modell-IDs anbieter-spezifisch, daher funktioniert automatisches Fallback nur, wenn Claude Code beide beteiligten Modelle identifizieren kann:
* Claude Code muss das aktuelle Modell als Fable 5 erkennen: Die Modell-ID enthält `claude-fable-5`, stimmt mit dem Wert von `ANTHROPIC_DEFAULT_FABLE_MODEL` überein oder ist mit [`modelOverrides`](#override-model-ids-per-version) zugeordnet.
* Das Fallback-Ziel muss zu einem Opus-Modell aufgelöst werden: Der Wert von `ANTHROPIC_DEFAULT_OPUS_MODEL`, falls gesetzt, andernfalls ein Opus 4.8-Eintrag in der Modellliste des Anbieters.
Wenn eines der Modelle nicht identifiziert werden kann, wechselt Claude Code nicht automatisch. Die gekennzeichnete Anfrage endet mit einer Ablehnungsmeldung, und Sie können Modelle mit [`/model`](#setting-your-model) wechseln und erneut versuchen. Um automatisches Fallback auf diesen Anbietern zu aktivieren, setzen Sie `ANTHROPIC_DEFAULT_FABLE_MODEL` auf Ihre Fable 5-Modell-ID und `ANTHROPIC_DEFAULT_OPUS_MODEL` auf Ihre Opus 4.8-Modell-ID.
Sicherheitsforschungs- und Biologie-Workloads
Workloads in offensiver Sicherheit oder Biologie, einschließlich Penetrationstests, Capture the Flag (CTF)-Übungen und biologie-nahe Codebases, lösen häufig Fallback aus, oft bei der ersten Anfrage. Für substantielle Biologie-Arbeit erwarten Sie, dass fast alle Anfragen umgeleitet werden.
Dies ist erwartetes Routing für diese Domänen, kein Konto-Flag. Wenn Ihre Organisation Fable-Klasse-Fähigkeit für diese Arbeit benötigt, fragen Sie Ihr Anthropic-Kontoteam nach vertrauenswürdigen Zugriffsprogrammen.
Anpassung des Aufwandsniveaus
[Aufwandsniveaus](https://platform.claude.com/docs/en/build-with-claude/effort) steuern adaptives Reasoning, das das Modell entscheiden lässt, ob und wie viel es bei jedem Schritt basierend auf der Aufgabenkomplexität denken soll. Niedrigerer Aufwand ist schneller und günstiger für unkomplizierte Aufgaben, während höherer Aufwand tieferes Reasoning für komplexe Probleme bietet.
Die verfügbaren Aufwandsniveaus hängen vom Modell ab. Modelle, die hier nicht aufgeführt sind, unterstützen keinen Aufwand:
| Modell | Ebenen |
| :------------------------------ | :-------------------------------------- |
| Fable 5 | `low`, `medium`, `high`, `xhigh`, `max` |
| Sonnet 5, Opus 4.8 und Opus 4.7 | `low`, `medium`, `high`, `xhigh`, `max` |
| Opus 4.6 und Sonnet 4.6 | `low`, `medium`, `high`, `max` |
Wenn Sie eine Ebene setzen, die das aktive Modell nicht unterstützt, greift Claude Code auf die höchste unterstützte Ebene bei oder unter der von Ihnen gesetzten zurück. Zum Beispiel wird `xhigh` auf Opus 4.6 als `high` ausgeführt.
Der Standard-Aufwand ist `high` auf Fable 5, Sonnet 5, Opus 4.8, Opus 4.6 und Sonnet 4.6 und `xhigh` auf Opus 4.7.
Wenn Sie Fable 5, Opus 4.8 oder Opus 4.7 zum ersten Mal ausführen, wendet Claude Code das Standard-Aufwandsniveau dieses Modells an, auch wenn Sie zuvor ein anderes Niveau für ein anderes Modell gesetzt haben: `high` auf Fable 5 und Opus 4.8 und `xhigh` auf Opus 4.7. Führen Sie `/effort` erneut aus, um nach dem Wechsel ein anderes Niveau zu wählen.
`low`, `medium`, `high` und `xhigh` bleiben über Sitzungen hinweg erhalten. `max` bietet das tiefste Reasoning ohne Einschränkung bei der Token-Ausgabe und gilt nur für die aktuelle Sitzung, außer wenn es über die `CLAUDE_CODE_EFFORT_LEVEL`-Umgebungsvariable gesetzt wird.
Das `/effort`-Menü bietet auch `ultracode`. Ultracode ist eine Claude Code-Einstellung und keine Modell-Aufwandsebene: Es sendet `xhigh` an das Modell und lässt Claude zusätzlich [dynamische Workflows](/de/workflows) für substantielle Aufgaben orchestrieren. Es gilt nur für die aktuelle Sitzung. Setzen Sie es über `/effort` oder übergeben Sie `"ultracode": true` über `--settings` oder eine Agent SDK-Steueranforderung. Es ist nicht Teil der `effortLevel`-Einstellung, des `--effort`-Flags oder `CLAUDE_CODE_EFFORT_LEVEL`.
Wählen Sie ein Aufwandsniveau
Jede Ebene tauscht Token-Ausgabe gegen Fähigkeit. Der Standard eignet sich für die meisten Codierungsaufgaben; passen Sie an, wenn Sie ein anderes Gleichgewicht wünschen.
| Ebene | Wann man es verwendet |
| :---------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `low` | Reservieren Sie für kurze, begrenzte, latenzempfindliche Aufgaben, die nicht intelligenzempfindlich sind |
| `medium` | Reduziert Token-Nutzung für kostensensitive Arbeiten, die etwas Intelligenz opfern können |
| `high` | Balanciert Token-Nutzung und Intelligenz. Standard auf Fable 5, Sonnet 5, Opus 4.8, Opus 4.6 und Sonnet 4.6 |
| `xhigh` | Tieferes Reasoning bei höherer Token-Ausgabe. Standard auf Opus 4.7 |
| `max` | Kann die Leistung bei anspruchsvollen Aufgaben verbessern, kann aber abnehmende Erträge zeigen und ist anfällig für Überdenken. Testen Sie vor breiter Übernahme |
| `ultracode` | Eine Claude Code-Einstellung, die einen [dynamischen Workflow](/de/workflows) für jede substantielle Aufgabe mit `xhigh`-Pro-Nachricht-Reasoning plant. Nur für Sitzungen |
Die Aufwandsskala ist pro Modell kalibriert, daher stellt der gleiche Ebenenname nicht den gleichen zugrunde liegenden Wert über Modelle hinweg dar.
Verwenden Sie ultrathink für einmaliges tiefes Reasoning
Fügen Sie `ultrathink` überall in Ihrem Prompt ein, um tieferes Reasoning bei diesem Durchgang anzufordern, ohne Ihre Sitzungsaufwandseinstellung zu ändern. Claude Code erkennt das Schlüsselwort und fügt eine In-Context-Anweisung hinzu. Das an die API gesendete Aufwandsniveau bleibt unverändert. Andere Phrasen wie „think", „think hard" und „think more" werden als gewöhnlicher Prompt-Text weitergeleitet und werden nicht als Schlüsselwörter erkannt.
Setzen Sie das Aufwandsniveau
Sie können Aufwand durch eine der folgenden Methoden ändern:
* **`/effort`**: Führen Sie `/effort` ohne Argumente aus, um einen interaktiven Schieberegler zu öffnen, `/effort` gefolgt von einem Ebenennamen, um ihn direkt zu setzen, oder `/effort auto`, um auf den Modellstandard zurückzusetzen
* **In `/model`**: Verwenden Sie die Pfeiltasten nach links/rechts, um den Aufwand-Schieberegler anzupassen, wenn Sie ein Modell auswählen
* **`--effort`-Flag**: Übergeben Sie einen Ebenennamen, um ihn für eine einzelne Sitzung beim Starten von Claude Code zu setzen
* **Umgebungsvariable**: Setzen Sie `CLAUDE_CODE_EFFORT_LEVEL` auf einen Ebenennamen oder `auto`
* **Einstellungen**: Setzen Sie `effortLevel` auf `low`, `medium`, `high` oder `xhigh` in Ihrer Einstellungsdatei. `max` und `ultracode` sind [nur für Sitzungen](#adjust-effort-level) und werden hier nicht akzeptiert
* **Skill- und Subagent-Frontmatter**: Setzen Sie `effort` in einer [Skill](/de/skills#frontmatter-reference)- oder [Subagent](/de/sub-agents#supported-frontmatter-fields)-Markdown-Datei, um das Aufwandsniveau zu überschreiben, wenn dieser Skill oder Subagent ausgeführt wird
Die Umgebungsvariable hat Vorrang vor allen anderen Methoden, dann Ihre konfigurierte Ebene, dann der Modellstandard. Frontmatter-Aufwand gilt, wenn dieser Skill oder Subagent aktiv ist, und überschreibt die Sitzungsebene, aber nicht die Umgebungsvariable.
Der Aufwand-Schieberegler erscheint in `/model`, wenn ein unterstütztes Modell ausgewählt ist. Das aktuelle Aufwandsniveau wird auch neben dem Logo und dem Spinner angezeigt, z. B. „with low effort", damit Sie bestätigen können, welche Einstellung aktiv ist, ohne `/model` zu öffnen.
Adaptives Reasoning und feste Thinking-Budgets
Adaptives Reasoning macht Thinking bei jedem Schritt optional, daher kann Claude schneller auf Routine-Prompts reagieren und tieferes Denken für Schritte reservieren, die davon profitieren. Wenn Sie möchten, dass Claude häufiger oder seltener denkt als das aktuelle Niveau erzeugt, können Sie dies direkt in Ihrem Prompt oder in `CLAUDE.md` sagen; das Modell reagiert auf diese Anleitung innerhalb seiner Aufwandseinstellung.
Fable 5, Sonnet 5 sowie Opus 4.7 und später verwenden immer adaptives Reasoning. Der Modus mit festem Thinking-Budget und `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` gelten nicht dafür.
Bei Opus 4.6 und Sonnet 4.6 können Sie `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` setzen, um zum vorherigen festen Thinking-Budget zurückzukehren, das von `MAX_THINKING_TOKENS` gesteuert wird. Siehe [Umgebungsvariablen](/de/env-vars).
Erweitertes Thinking
Erweitertes Thinking ist das Reasoning, das Claude vor der Antwort ausgibt. Bei Modellen, die [adaptives Reasoning](#adjust-effort-level) unterstützen, ist das Aufwandsniveau die primäre Kontrolle dafür, wie viel Thinking stattfindet; die folgenden Einstellungen schalten Thinking ein oder aus und steuern, wie es angezeigt wird.
| Kontrolle | Wie man es setzt |
| :-------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Umschalter für die aktuelle Sitzung | Drücken Sie `Option+T` auf macOS oder `Alt+T` auf Windows und Linux |
| Setzen Sie den globalen Standard | Führen Sie `/config` aus und schalten Sie den Thinking-Modus um. Gespeichert als `alwaysThinkingEnabled` in `~/.claude/settings.json` |
| Deaktivieren Sie unabhängig vom Aufwand | Setzen Sie [`MAX_THINKING_TOKENS=0`](/de/env-vars), das Thinking auf der Anthropic API außer auf Fable 5 ausschaltet. Auf [Drittanbieter-Anbietern](/de/third-party-integrations) wird stattdessen der `thinking`-Parameter weggelassen, und adaptive-Reasoning-Modelle können immer noch denken. Andere Werte gelten nur mit einem [festen Thinking-Budget](#adaptive-reasoning-and-fixed-thinking-budgets) |
Thinking kann auf Fable 5 nicht ausgeschaltet werden. Der Sitzungsumschalter, `alwaysThinkingEnabled` und `MAX_THINKING_TOKENS=0` haben dort keine Auswirkung, und Fable 5 entscheidet pro Schritt, wie viel zu denken ist, basierend auf dem Aufwandsniveau.
Die Thinking-Ausgabe ist standardmäßig zusammengeklappt. Drücken Sie `Ctrl+O`, um den ausführlichen Modus umzuschalten und das Reasoning als grauer kursiver Text zu sehen. Interaktive Sitzungen auf der Anthropic API erhalten standardmäßig redigierte Thinking-Blöcke, daher setzen Sie `showThinkingSummaries: true` in [Einstellungen](/de/settings), wenn Sie die vollständigen Zusammenfassungen verfügbar haben möchten, wenn Sie erweitern. Ihnen werden alle generierten Thinking-Token berechnet, auch wenn sie zusammengeklappt oder redigiert sind.
Erweiterter Kontext
Fable 5, Sonnet 5, Opus 4.6 und später sowie Sonnet 4.6 unterstützen ein [1-Million-Token-Kontextfenster](https://platform.claude.com/docs/en/build-with-claude/context-windows#1m-token-context-window) für lange Sitzungen mit großen Codebases.
Die Verfügbarkeit variiert je nach Modell und Plan. Auf der Anthropic API werden Fable 5, Sonnet 5, Opus 4.8 und Opus 4.7 immer mit dem 1M-Fenster ausgeführt. Bei Max-, Team- und Enterprise-Plänen wird Opus automatisch auf 1M-Kontext ohne zusätzliche Konfiguration aktualisiert. Dies gilt für beide Team Standard- und Team Premium-Plätze. Sonnet 4.6 mit 1M-Kontext ist nicht Teil der automatischen Aktualisierung und erfordert [Nutzungsguthaben](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) bei jedem Abonnementplan, einschließlich Max.
| Plan | Opus mit 1M-Kontext | Sonnet 4.6 mit 1M-Kontext |
| ------------------------ | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| Max, Team und Enterprise | Im Abonnement enthalten | Erfordert [Nutzungsguthaben](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |
| Pro | Erfordert [Nutzungsguthaben](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) | Erfordert [Nutzungsguthaben](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |
| API und Pay-as-you-go | Vollständiger Zugriff | Vollständiger Zugriff |
Um 1M-Kontext vollständig zu deaktivieren, setzen Sie `CLAUDE_CODE_DISABLE_1M_CONTEXT=1`. Dies entfernt 1M-Modellvarianten aus der Modellauswahl. Siehe [Umgebungsvariablen](/de/env-vars).
Das 1M-Kontextfenster verwendet Standard-Modellpreise ohne Aufschlag für Token über 200K. Für Pläne, bei denen erweiterter Kontext in Ihrem Abonnement enthalten ist, bleibt die Nutzung von Ihrem Abonnement abgedeckt. Für Pläne, die über Nutzungsguthaben auf erweiterten Kontext zugreifen, werden Token zu Nutzungsguthaben abgerechnet.
Wenn Ihr Konto 1M-Kontext unterstützt, erscheint die Option in der Modellauswahl (`/model`) in den neuesten Versionen von Claude Code. Wenn Sie sie nicht sehen, versuchen Sie, Ihre Sitzung neu zu starten.
Sie können auch das `[1m]`-Suffix mit Modellaliasen oder vollständigen Modellnamen verwenden:
```bash theme={null}
# Verwenden Sie den opus[1m]- oder sonnet[1m]-Alias
/model opus[1m]
/model sonnet[1m]
# Oder fügen Sie [1m] an einen vollständigen Modellnamen an
/model claude-opus-4-8[1m]
```
Sonnet 5-Kontextfenster
Auf der Anthropic API wird Sonnet 5 immer mit dem 1M-Kontextfenster ausgeführt. Es gibt keine 200K-Variante, kein `[1m]`-Suffix zur Auswahl und keine erforderlichen Nutzungsguthaben bei irgendeinem Plan. Sitzungen werden automatisch komprimiert, bevor das Fenster voll ist, standardmäßig bei etwa 967K Token; setzen Sie [`CLAUDE_CODE_AUTO_COMPACT_WINDOW`](/de/env-vars), um einen anderen Schwellenwert zu wählen.
Zwei Konfigurationen budgetieren das Fenster stattdessen auf 200K und komprimieren automatisch an dieser Grenze:
* **LLM-Gateway**: Wenn `ANTHROPIC_BASE_URL` auf ein [Gateway](/de/llm-gateway) verweist, kann Claude Code die 1M-Unterstützung nicht überprüfen. Um das vollständige Fenster zu verwenden, wählen Sie Sonnet 5 (1M context) in der Modellauswahl aus, was `sonnet[1m]` zugeordnet wird.
* **`CLAUDE_CODE_DISABLE_1M_CONTEXT=1`**: Behandelt Sonnet 5-Sitzungen so, als hätten sie ein 200K-Fenster, für Bereitstellungen, die den Kontext begrenzen müssen.
Überprüfung Ihres aktuellen Modells
Sie können sehen, welches Modell Sie derzeit verwenden, an zwei Stellen:
* In der [Statuszeile](/de/statusline), falls Sie eine konfiguriert haben
* In `/status`, das auch Ihre Kontoinformationen anzeigt
Benutzerdefinierte Modelloption hinzufügen
Verwenden Sie `ANTHROPIC_CUSTOM_MODEL_OPTION`, um einen einzelnen benutzerdefinierten Eintrag zur `/model`-Auswahl hinzuzufügen, ohne die integrierten Aliase zu ersetzen. Dies ist nützlich zum Testen von Modell-IDs, die Claude Code standardmäßig nicht auflistet. Für LLM-Gateway-Bereitstellungen kann Claude Code die Auswahl vom `/v1/models`-Endpunkt des Gateways auffüllen, wenn `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1` gesetzt ist. Daher ist diese Variable nur erforderlich, wenn die Erkennung deaktiviert ist oder das gewünschte Modell nicht zurückgibt. Siehe [Gateway-Modellauswahl](/de/llm-gateway-protocol#model-discovery).
Dieses Beispiel setzt alle drei Variablen, um eine Gateway-gesteuerte Opus-Bereitstellung auswählbar zu machen:
```bash theme={null}
export ANTHROPIC_CUSTOM_MODEL_OPTION="my-gateway/claude-opus-4-8"
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="Opus via Gateway"
export ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION="Custom deployment routed through the internal LLM gateway"
```
Der benutzerdefinierte Eintrag erscheint am unteren Ende der `/model`-Auswahl. `ANTHROPIC_CUSTOM_MODEL_OPTION_NAME` und `ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION` sind optional. Wenn weggelassen, wird die Modell-ID als Name verwendet und die Beschreibung wird standardmäßig auf `Custom model ()` gesetzt.
Claude Code überspringt die Validierung für die Modell-ID, die in `ANTHROPIC_CUSTOM_MODEL_OPTION` gesetzt ist, daher können Sie jeden String verwenden, den Ihr API-Endpunkt akzeptiert. Wenn [`availableModels`](#restrict-model-selection) gesetzt ist, fügen Sie die benutzerdefinierte Modell-ID auch in die Zulassungsliste ein: Der benutzerdefinierte Eintrag wird aus der Auswahl gefiltert und eine `--model`-Auswahl wird wie jedes andere ausgeschlossene Modell abgelehnt. Eine benutzerdefinierte ID, die einen Familiennamen einbettet, wie z. B. `my-gateway/claude-opus-4-8`, zählt als spezifischer Eintrag für diese Familie und deaktiviert deren Wildcard. Daher müssen Sie auch die Versionen auflisten, die Sie auswählbar halten möchten. Siehe [Zusammenführungsverhalten](#merge-behavior).
Umgebungsvariablen
Sie können die folgenden Umgebungsvariablen verwenden, um die Modellnamen zu steuern, auf die die Aliase verweisen. Jeder Wert muss ein vollständiger Modellname oder das entsprechende Äquivalent für Ihren API-Anbieter sein.
| Umgebungsvariable | Beschreibung |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `ANTHROPIC_DEFAULT_FABLE_MODEL` | Das Modell, das für `fable` verwendet werden soll, und die Modell-ID, die Claude Code als Fable 5 für [automatisches Modell-Fallback](#automatic-model-fallback) bei Drittanbieter-Anbietern erkennt |
| `ANTHROPIC_DEFAULT_OPUS_MODEL` | Das Modell, das für `opus` verwendet werden soll, oder für `opusplan`, wenn Plan Mode aktiv ist. |
| `ANTHROPIC_DEFAULT_SONNET_MODEL` | Das Modell, das für `sonnet` verwendet werden soll, oder für `opusplan`, wenn Plan Mode nicht aktiv ist. |
| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | Das Modell, das für `haiku` verwendet werden soll, oder [Hintergrundfunktionalität](/de/costs#background-token-usage) |
| `CLAUDE_CODE_SUBAGENT_MODEL` | Das Modell, das für alle [Subagents](/de/sub-agents#choose-a-model) und [Agent-Teams](/de/agent-teams) verwendet werden soll. Überschreibt den `model`-Parameter pro Aufruf und die `model`-Frontmatter der Subagent-Definition. Setzen Sie auf `inherit`, um stattdessen die normale Modellauflösung zu verwenden |
Hinweis: `ANTHROPIC_SMALL_FAST_MODEL` ist veraltet zugunsten von `ANTHROPIC_DEFAULT_HAIKU_MODEL`.
Modelle für Drittanbieter-Bereitstellungen fixieren
Beim Bereitstellen von Claude Code über [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai), [Foundry](/de/microsoft-foundry) oder [Claude Platform on AWS](/de/claude-platform-on-aws) sollten Sie Modellversionen vor dem Rollout für Benutzer fixieren.
Ohne Fixierung verwendet Claude Code Modellaliase wie `fable`, `opus`, `sonnet` und `haiku`, die zur integrierten Standard-Modell-ID für jeden Anbieter aufgelöst werden. Dieser Standard kann hinter der neuesten Anthropic-Veröffentlichung zurückbleiben, und das Modell, auf das er verweist, ist möglicherweise noch nicht in einem Benutzerkonto aktiviert. Wenn der Standard nicht verfügbar ist, sehen Bedrock- und Vertex AI-Benutzer einen Hinweis und greifen für diese Sitzung auf die vorherige Version zurück, während Foundry-Benutzer Fehler sehen, da Foundry keine entsprechende Startprüfung hat.
Setzen Sie die Modell-Umgebungsvariablen auf spezifische Versions-IDs als Teil Ihres anfänglichen Setups. Das Fixieren ermöglicht es Ihnen, zu kontrollieren, wann Ihre Benutzer zu einem neuen Modell wechseln.
Verwenden Sie die folgenden Umgebungsvariablen mit versionsspezifischen Modell-IDs für Ihren Anbieter:
| Anbieter | Beispiel |
| :-------- | :------------------------------------------------------------------- |
| Bedrock | `export ANTHROPIC_DEFAULT_OPUS_MODEL='us.anthropic.claude-opus-4-8'` |
| Vertex AI | `export ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-8'` |
| Foundry | `export ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-8'` |
Wenden Sie das gleiche Muster auf `ANTHROPIC_DEFAULT_FABLE_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL` und `ANTHROPIC_DEFAULT_HAIKU_MODEL` an. Für aktuelle und ältere Modell-IDs über alle Anbieter hinweg siehe [Modellübersicht](https://platform.claude.com/docs/en/about-claude/models/overview). Um Benutzer auf eine neue Modellversion zu aktualisieren, aktualisieren Sie diese Umgebungsvariablen und stellen Sie erneut bereit.
Um [erweiterten Kontext](#extended-context) für ein fixiertes Modell zu aktivieren, fügen Sie `[1m]` an die Modell-ID in `ANTHROPIC_DEFAULT_OPUS_MODEL` oder `ANTHROPIC_DEFAULT_SONNET_MODEL` an:
```bash theme={null}
export ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-8[1m]'
```
Das `[1m]`-Suffix wendet das 1M-Kontextfenster auf alle Verwendungen der Aliase `opus` und `sonnet` an, einschließlich der Plan-Mode-Opus-Phase von [`opusplan`](#opusplan-model-setting).
* Claude Code entfernt das Suffix, bevor die Modell-ID an Ihren Anbieter gesendet wird.
* Fügen Sie `[1m]` nur an, wenn das zugrunde liegende Modell [1M-Kontext unterstützt](https://platform.claude.com/docs/en/build-with-claude/context-windows#1m-token-context-window).
* Das Suffix wird pro Variable gelesen, nicht pro Modell. Bei Bedrock, Vertex und Foundry verwendet eine Modell-ID ohne `[1m]` in einer Variable 200K-Kontext, auch wenn eine andere Variable das gleiche Modell mit dem Suffix setzt. Sonnet 5 wird auf diesen Anbietern immer mit dem 1M-Fenster ausgeführt und benötigt niemals das Suffix.
Eine `availableModels`-Zulassungsliste, die über [MDM oder eine verwaltete Einstellungsdatei](/de/settings#settings-files) bereitgestellt wird, gilt weiterhin bei Verwendung von Drittanbieter-Anbietern; [server-verwaltete Einstellungen werden dort nicht bereitgestellt](/de/server-managed-settings#platform-availability). Die Filterung stimmt mit einem Modellalias wie `opus`, einem Versionspräfix wie `claude-opus-4-8` oder der vollständigen Modell-ID in Anbieterform überein. Anbieterspezifische Präfixe wie `us.anthropic.` werden nicht entfernt, daher müssen Sie zum Zulassen eines bestimmten Modells die gleiche Anbieterform-ID auflisten, die die Auswahl anzeigt, oder sie durch [`modelOverrides`](#override-model-ids-per-version) zuordnen. Alle `[1m]`-Suffixe werden sowohl aus dem Zulassungslisten-Eintrag als auch aus dem angeforderten Modell vor dem Abgleich entfernt.
Anzeige und Funktionen des fixierten Modells anpassen
Wenn Sie ein Modell bei einem Drittanbieter fixieren, erscheint die anbieterspezifische ID in der `/model`-Auswahl und Claude Code erkennt möglicherweise nicht, welche Funktionen das Modell unterstützt. Sie können den Anzeigenamen und die deklarierten Funktionen mit Begleit-Umgebungsvariablen für jedes fixierte Modell überschreiben.
Diese Variablen wirken sich auf Drittanbieter wie Bedrock, Vertex AI und Foundry aus. Die Variablen `_NAME` und `_DESCRIPTION` wirken sich auch aus, wenn `ANTHROPIC_BASE_URL` auf ein [LLM-Gateway](/de/llm-gateway) verweist. Sie haben keine Auswirkung bei direkter Verbindung zu `api.anthropic.com`.
| Umgebungsvariable | Beschreibung |
| ----------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `ANTHROPIC_DEFAULT_OPUS_MODEL_NAME` | Anzeigename für das fixierte Opus-Modell in der `/model`-Auswahl. Standardmäßig die Modell-ID, wenn nicht gesetzt |
| `ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION` | Anzeige-Beschreibung für das fixierte Opus-Modell in der `/model`-Auswahl. Standardmäßig `Custom Opus model`, wenn nicht gesetzt |
| `ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES` | Komma-getrennte Liste der Funktionen, die das fixierte Opus-Modell unterstützt |
Die gleichen `_NAME`-, `_DESCRIPTION`- und `_SUPPORTED_CAPABILITIES`-Suffixe sind für `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL`, `ANTHROPIC_DEFAULT_FABLE_MODEL` und `ANTHROPIC_CUSTOM_MODEL_OPTION` verfügbar.
Claude Code aktiviert Funktionen wie [Aufwandsniveaus](#adjust-effort-level) und [erweitertes Denken](#extended-thinking) durch Abgleich der Modell-ID mit bekannten Mustern. Anbieterspezifische IDs wie Bedrock-ARNs oder benutzerdefinierte Bereitstellungsnamen stimmen oft nicht mit diesen Mustern überein, wodurch unterstützte Funktionen deaktiviert bleiben. Setzen Sie `_SUPPORTED_CAPABILITIES`, um Claude Code mitzuteilen, welche Funktionen das Modell tatsächlich unterstützt:
| Funktionswert | Aktiviert |
| ---------------------- | -------------------------------------------------------------------------------------------- |
| `effort` | [Aufwandsniveaus](#adjust-effort-level) und der `/effort`-Befehl |
| `xhigh_effort` | {/* min-version: 2.1.111 */}Das `xhigh`-Aufwandsniveau |
| `max_effort` | Das `max`-Aufwandsniveau |
| `thinking` | [Erweitertes Denken](#extended-thinking) |
| `adaptive_thinking` | Adaptives Reasoning, das das Denken dynamisch basierend auf der Aufgabenkomplexität zuordnet |
| `interleaved_thinking` | Denken zwischen Tool-Aufrufen |
Wenn `_SUPPORTED_CAPABILITIES` gesetzt ist, werden aufgelistete Funktionen aktiviert und nicht aufgelistete Funktionen werden für das entsprechende fixierte Modell deaktiviert. Wenn die Variable nicht gesetzt ist, greift Claude Code auf die integrierte Erkennung basierend auf der Modell-ID zurück.
Dieses Beispiel fixiert Opus auf ein benutzerdefiniertes Bedrock-Modell-ARN, setzt einen benutzerfreundlichen Namen und deklariert seine Funktionen:
```bash theme={null}
export ANTHROPIC_DEFAULT_OPUS_MODEL='arn:aws:bedrock:us-east-1:123456789012:custom-model/abc'
export ANTHROPIC_DEFAULT_OPUS_MODEL_NAME='Opus via Bedrock'
export ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION='Opus 4.7 routed through a Bedrock custom endpoint'
export ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES='effort,xhigh_effort,max_effort,thinking,adaptive_thinking,interleaved_thinking'
```
Modell-IDs pro Version überschreiben
Die oben genannten Umgebungsvariablen auf Familienebene konfigurieren eine Modell-ID pro Familienalias. Wenn Sie mehrere Versionen innerhalb der gleichen Familie auf unterschiedliche Anbieter-IDs abbilden müssen, verwenden Sie stattdessen die `modelOverrides`-Einstellung.
`modelOverrides` ordnet einzelne Anthropic-Modell-IDs den anbieterspezifischen Strings zu, die Claude Code an die API Ihres Anbieters sendet. Wenn ein Benutzer ein zugeordnetes Modell in der `/model`-Auswahl auswählt, verwendet Claude Code Ihren konfigurierten Wert anstelle des integrierten Standards.
Dies ermöglicht es Enterprise-Administratoren, jede Modellversion zu einem bestimmten Bedrock-Inference-Profil-ARN, Vertex AI-Versionsnamen oder Foundry-Bereitstellungsnamen für Governance, Kostenzuteilung oder regionales Routing zu leiten.
Setzen Sie `modelOverrides` in Ihrer [Einstellungsdatei](/de/settings#settings-files):
```json theme={null}
{
"modelOverrides": {
"claude-opus-4-7": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-prod",
"claude-opus-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-46-prod",
"claude-sonnet-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/sonnet-prod"
}
}
```
Schlüssel müssen Anthropic-Modell-IDs sein, wie in der [Modellübersicht](https://platform.claude.com/docs/en/about-claude/models/overview) aufgelistet. Für datierte Modell-IDs fügen Sie das Datumssuffix genau so ein, wie es dort angezeigt wird. Unbekannte Schlüssel werden ignoriert.
Überschreibungen ersetzen die integrierten Modell-IDs, die jeden Eintrag in der `/model`-Auswahl unterstützen. Bei Bedrock haben Überschreibungen Vorrang vor allen Inference-Profilen, die Claude Code beim Start automatisch erkennt. Werte, die Sie direkt über `ANTHROPIC_MODEL`, `--model` oder die `ANTHROPIC_DEFAULT_*_MODEL`-Umgebungsvariablen bereitstellen, werden unverändert an den Anbieter übergeben und werden nicht durch `modelOverrides` transformiert.
`modelOverrides` funktioniert zusammen mit `availableModels`. Die Zulassungsliste wird gegen die Anthropic-Modell-ID ausgewertet, nicht gegen den Überschreibungswert, daher ein Eintrag wie `"opus"` in `availableModels` stimmt weiterhin überein, auch wenn Opus-Versionen ARNs zugeordnet sind. Wenn `enforceAvailableModels` in verwalteten Einstellungen gesetzt ist, wird der erzwungene Standard durch `modelOverrides` aus der [höchsten Prioritätsquelle für verwaltete Einstellungen](/de/server-managed-settings#settings-precedence) aufgelöst. Die Zuordnung eines Administrators, wie eine Version, die an ein Inference-Profil-ARN fixiert ist, wird im erzwungenen Standard berücksichtigt. Überschreibungen aus Benutzer- oder Projekteinstellungen beeinflussen ihn nicht.
Prompt-Caching-Konfiguration
Claude Code verwendet automatisch [Prompt-Caching](/de/prompt-caching), um die Leistung zu optimieren und Kosten zu senken. Sie können Prompt-Caching global oder für bestimmte Modell-Tiers deaktivieren:
| Umgebungsvariable | Beschreibung |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `DISABLE_PROMPT_CACHING` | Setzen Sie auf `1`, um Prompt-Caching für alle Modelle zu deaktivieren. Hat Vorrang vor den modellspezifischen Einstellungen |
| `DISABLE_PROMPT_CACHING_HAIKU` | Setzen Sie auf `1`, um Prompt-Caching nur für Haiku-Modelle zu deaktivieren |
| `DISABLE_PROMPT_CACHING_SONNET` | Setzen Sie auf `1`, um Prompt-Caching nur für Sonnet-Modelle zu deaktivieren |
| `DISABLE_PROMPT_CACHING_OPUS` | Setzen Sie auf `1`, um Prompt-Caching nur für Opus-Modelle zu deaktivieren |
| `DISABLE_PROMPT_CACHING_FABLE` | Setzen Sie auf `1`, um Prompt-Caching nur für Fable-Modelle zu deaktivieren |
Um die Cache-TTL zu ändern oder zu erfahren, was einen Cache-Miss auslöst, siehe [Wie Claude Code Prompt-Caching verwendet](/de/prompt-caching).