> ## 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.
# Wählen Sie einen Berechtigungsmodus
> Steuern Sie, ob Claude vor dem Bearbeiten von Dateien oder dem Ausführen von Befehlen fragt. Wechseln Sie Modi mit Shift+Tab in der CLI, dem Modusindikator in VS Code oder dem Moduswahlschalter in Desktop.
Ein Berechtigungsmodus legt fest, welche Aktionen Claude in einer Sitzung ausführen kann, ohne Sie vorher zu fragen. Im Manual-Modus hält Claude Code inne und fragt Sie, bevor die meisten Aktionen ausgeführt werden, die Dateien bearbeiten, Shell-Befehle ausführen oder das Netzwerk erreichen. Im [Auto-Modus](#eliminate-prompts-with-auto-mode) überprüft ein zweites Modell, der Klassifizierer, Aktionen statt Ihnen; [wie der Klassifizierer Aktionen bewertet](#how-the-classifier-evaluates-actions) listet auf, welche Aktionen er überprüft und welche er überspringt.
Mit Claude Code v2.1.283 oder später ist der Auto-Modus der integrierte Standard-Berechtigungsmodus für interaktive Terminal- und VS Code-Sitzungen. Bei früheren Versionen ist er der integrierte Standard-Berechtigungsmodus nur bei Pro-, Max- und Team-Plänen. [Welcher Modus eine Sitzung startet](#which-mode-a-session-starts-in) behandelt die Oberflächen und Einstellungen, die den Standard-Berechtigungsmodus ändern. Sie können auch den Berechtigungsmodus einer laufenden Sitzung jederzeit ändern.
Verfügbare Modi
Jeder Modus stellt einen anderen Kompromiss zwischen Benutzerfreundlichkeit und Überwachung dar. Die folgende Tabelle zeigt, was Claude in jedem Modus ohne Berechtigungsaufforderung tun kann. Der Manual-Modus wird unter seinem Konfigurationswert `default` angezeigt.
| Modus | Was ohne Nachfrage ausgeführt wird | Am besten geeignet für |
| :- | :- | :- |
| `default` | Nur Lesevorgänge | Überprüfung jeder Aktion selbst, sensible Arbeiten |
| [`acceptEdits`](#auto-approve-file-edits-with-acceptedits-mode) | Lesevorgänge, Dateibearbeitungen und häufige Dateisystembefehle (`mkdir`, `touch`, `mv`, `cp` usw.) | Iteration bei Code-Überprüfung |
| [`plan`](#analyze-before-you-edit-with-plan-mode) | Lesevorgänge, plus vom Klassifizierer genehmigte Befehle, wenn [Auto-Modus](#eliminate-prompts-with-auto-mode) verfügbar ist | Erkundung einer Codebasis vor Änderungen |
| [`auto`](#eliminate-prompts-with-auto-mode) | Alles, mit Sicherheitsprüfungen im Hintergrund | Lange Aufgaben, Reduzierung von Aufforderungsmüdigkeit |
| [`dontAsk`](#allow-only-pre-approved-tools-with-dontask-mode) | Dateilesevorgänge innerhalb Ihrer Arbeitsverzeichnisse und vorab genehmigte Tools; alles, was eine Berechtigungsabfrage auslösen würde, wird abgelehnt | Gesperrte CI und Skripte |
| [`bypassPermissions`](#skip-all-checks-with-bypasspermissions-mode) | Alles | Nur isolierte Container und VMs |
Der Modus, der jede Aktion überprüft, wird in der CLI, in `claude --help`, in den VS Code- und JetBrains-Erweiterungen und in der Desktop-App als **Manual** bezeichnet. Sein Konfigurationswert ist `default`, was Hooks und SDK-Integrationen verwenden. Die CLI akzeptiert `manual` als Alias überall dort, wo Sie den Wert eingeben, zum Beispiel `claude --permission-mode manual` oder `"defaultMode": "manual"`.
Schreibvorgänge in [geschützte Pfade](#protected-paths) werden niemals automatisch genehmigt, außer im `bypassPermissions`-Modus und in Plan-Mode-Sitzungen, in denen Bypass-Berechtigungen verfügbar sind, was bedeutet, dass Sitzungen auf eine Weise gestartet wurden, die [`bypassPermissions` in den Moduszyklus](#switch-permission-modes) aufnimmt.
Modi legen die Grundlage fest. Überlagern Sie [Berechtigungsregeln](/docs/de/permissions#manage-permissions) darauf, um bestimmte Tools vorab zu genehmigen oder zu blockieren. Deny-Regeln blockieren in jedem Modus, einschließlich `bypassPermissions`. Deny- und Ask-Regeln gelten nicht für [`EndConversation`](/docs/de/tools-reference#endconversation-tool-behavior), solange Claude noch mindestens ein anderes Tool aufrufen kann. Allow-Regeln haben keine Auswirkung in `bypassPermissions`.
Aktionen, die kein Modus automatisch genehmigt
Claude Code genehmigt die folgenden in keinem Modus automatisch, einschließlich `bypassPermissions`. Jeder Punkt verlinkt auf den Abschnitt, der sagt, was stattdessen in jedem Modus passiert:
* Tools, die einer expliziten [Ask-Regel](/docs/de/permissions#manage-permissions) entsprechen
* Connector-Tools, die Ihre Organisation [auf `ask` gesetzt hat](/docs/de/mcp#organization-controls-on-connector-tools), in Sitzungen, in denen diese Einstellung Claude Code erreicht
* Tools, die Benutzerinteraktion erfordern: das integrierte `AskUserQuestion`-Tool und MCP-Tools, die mit [`requiresUserInteraction`](/docs/de/mcp#require-approval-for-a-specific-tool) gekennzeichnet sind
* `rm` und `rmdir` Löschungen, die auf einen [kritischen Pfad](#critical-paths) abzielen, den keine Allow-Regel oder `PreToolUse` Hook `"allow"` genehmigt
* Die [Cross-Session-Messaging-Schutzmaßnahmen](#skip-all-checks-with-bypasspermissions-mode)
* Lesevorgänge außerhalb der Arbeitsverzeichnisse, während [`permissions.blockReadsOutsideWorkingDirectories`](/docs/de/settings-reference#permissions-blockreadsoutsideworkingdirectories) aktiviert ist: erkannte Datei-lesende Bash-Befehle und jeder [unsandboxed Retry](/docs/de/sandboxing#the-unsandboxed-retry-escape-hatch), der Genehmigung benötigt, um außerhalb der Sandbox zu laufen, fordern auch im Auto-Modus und `bypassPermissions`-Modus auf. Erfordert Claude Code v2.1.257 oder später.
Ein Befehl, den der Shell-Parser nicht verfolgen kann, wie einer, der das Verzeichnis mehr als einmal wechselt oder eine Subshell ausführt, fordert auf die gleiche Weise auf, auch wenn er keinen außerhalb liegenden Pfad benennt. Diese Aufforderung gilt nicht, wenn der Befehl in der [Sandbox](/docs/de/sandboxing) ausgeführt wird und die Sandbox die Blockierung erzwingt.
Häufige Setups
Berechtigungsmodi entscheiden, ob Claude vor einer Aktion fragt, und die [Bash-Sandbox](/docs/de/sandboxing) und äußere [Isolationsgrenzen](/docs/de/sandbox-environments) entscheiden, was eine Aktion erreichen kann, sobald sie läuft. Jede Zeile unten paart ein Ziel mit den Flags oder Einstellungen, die Sie dorthin bringen, und der Isolation, die es benötigt, als Ausgangspunkt. [Verfügbare Modi](#available-modes) listet auf, was in jedem Modus ohne Aufforderung läuft.
| Sie möchten | Starten Sie mit | Isolation erforderlich | Notizen |
| :- | :- | :- | :- |
| Jede Aktion selbst überprüfen | Manual-Modus: `claude --permission-mode default` | Keine | Sensible Arbeiten, unbekannter Code |
| Lokal mit weniger Aufforderungen iterieren, ohne einen Klassifizierer | Manual-Modus plus die Bash-Sandbox im [Auto-Allow-Modus](/docs/de/sandboxing#sandbox-modes): `claude --permission-mode default`, dann `/sandbox` ausführen und Auto-Allow auswählen | Die integrierte Bash-Sandbox, auf macOS, Linux und WSL2 | Deny-Regeln gelten weiterhin, und Ask-Regeln, die einen Befehl benennen, wie `Bash(git push *)`, fordern weiterhin auf. Um die Sandbox stattdessen aus einer Einstellungsdatei zu aktivieren, setzen Sie [`sandbox.enabled`](/docs/de/settings-reference#sandbox-enabled) auf `true` |
| Erkunden Sie, bevor Sie etwas ändern | `claude --permission-mode plan` | Keine | Claude Code blockiert Bearbeitungen, bis Sie einen Plan [genehmigen](#review-and-approve-a-plan) |
| Arbeiten Sie freihändig im Auto-Modus | `claude --permission-mode auto`, der [integrierte Standard-Berechtigungsmodus](#which-mode-a-session-starts-in) mit v2.1.283 oder später | Keine; eine Sandbox oder ein Container fügt Verteidigungstiefe hinzu | Erfordert ein [unterstütztes Modell](#eliminate-prompts-with-auto-mode), und Ihre Organisation kann [Auto-Modus ausschalten](#eliminate-prompts-with-auto-mode) |
| Führen Sie in CI mit einer genauen Allowlist aus | `claude -p "run the test suite" --permission-mode dontAsk --allowedTools "Bash(npm test)" "Read"` | Keine über das hinaus, was Ihr CI-Runner bietet | [Cloud-Sitzungen](/docs/de/claude-code-on-the-web) ignorieren `dontAsk` aus Einstellungsdateien |
| Führen Sie vollständig unbeaufsichtigt in einem Container aus | `claude -p "" --dangerously-skip-permissions` | Erforderlich: ein Container, VM oder die [Sandbox-Laufzeit](/docs/de/sandbox-environments#sandbox-runtime); auf Linux und macOS, führen Sie es als [Nicht-Root-Benutzer](#skip-all-checks-with-bypasspermissions-mode) aus | Cloud-Sitzungen ignorieren diesen Modus aus Einstellungsdateien. In diesem `-p` Lauf werden die [wenigen Aufrufe, die weiterhin auffordern würden](#skip-all-checks-with-bypasspermissions-mode) stattdessen verweigert |
Die Bash-Sandbox und der Auto-Modus funktionieren unabhängig und kombinieren sich, mit den Ausnahmen, die unter [Sandbox-Modi](/docs/de/sandboxing#sandbox-modes) aufgelistet sind. Für die vollständige Interaktion siehe [Wie Sandboxing sich auf Berechtigungen und Berechtigungsmodi bezieht](/docs/de/sandboxing#how-sandboxing-relates-to-permissions-and-permission-modes) und [Wie Isolation sich auf Berechtigungsmodi bezieht](/docs/de/sandbox-environments#how-isolation-relates-to-permission-modes).
Welcher Modus eine Sitzung startet
Wenn Sie eine neue Sitzung in einem Terminal starten, nimmt Claude Code den Berechtigungsmodus aus dem ersten dieser Punkte, der zutrifft:
1. Das `--permission-mode` Flag oder `--dangerously-skip-permissions`
2. `permissions.defaultMode` in einer [Einstellungsdatei](/docs/de/settings#where-settings-live)
Wenn Sie `"auto"` in `.claude/settings.json` oder `.claude/settings.local.json` setzen, wird der Wert nicht wirksam, und Claude Code verwendet dann stattdessen den integrierten Standard, anstatt einen `defaultMode` aus `~/.claude/settings.json` zu verwenden. Wenn Sie `"bypassPermissions"` in diesen beiden Dateien setzen, wird es auch nicht wirksam, und die Sitzung startet im Manual-Modus. Die anderen Werte gelten aus jeder Einstellungsdatei.
3. Der integrierte Standard
Konversationen, die die VS Code-Erweiterung startet, folgen der eigenen Liste der Erweiterung in [Berechtigungsmodi wechseln](#switch-permission-modes). Für den Berechtigungsmodus, in dem Claude Code eine fortgesetzte Sitzung startet, siehe [Berechtigungsmodus beim Fortsetzen](/docs/de/sessions#permission-mode-on-resume).
Der integrierte `auto` Standard erfordert Claude Code v2.1.228 oder später auf macOS, Linux und WSL, und v2.1.233 oder später auf nativem Windows. Bei früheren Versionen ist der integrierte Standard Manual.
Der integrierte Standard hängt davon ab, wie Sie Claude Code ausführen. Die erste Zeile, die Ihrer Sitzung entspricht, gilt. Die Tabelle behandelt Sitzungen, die Sie in einem Terminal oder über die VS Code-Erweiterung starten; für die Desktop-App und claude.ai siehe die Desktop- und Web-Registerkarten in [Berechtigungsmodi wechseln](#switch-permission-modes).
| Wie Sie Claude Code ausführen | Integrierter Start-Berechtigungsmodus |
| :- | :- |
| Eine Einstellungsdatei setzt `disableAutoMode` auf `"disable"` | `default` |
| `claude -p` oder das [Agent SDK](/docs/de/agent-sdk/permissions#permission-modes) | `default` in Sitzungen, die [Feature-Flags abrufen](/docs/de/env-vars#features-that-need-feature-flag-fetching). In Sitzungen, die dies nicht tun, wie bei einem Drittanbieter oder mit deaktivierter Telemetrie, `auto` mit Claude Code v2.1.285 oder später und `default` bei früheren Versionen. Eine Sitzung in einer Organisation, deren Richtlinie den `auto` Standard vorenthält, startet stattdessen in `default` |
| Auf Ihre Organisation ist die [HIPAA-Konfiguration](#hipaa-configuration) angewendet und die Sitzung ist [dafür berechtigt](/docs/de/hipaa-setup#check-how-developers-sign-in-and-connect) | `default` mit Claude Code v2.1.285 oder später; der Auto-Modus bleibt verfügbar, um dorthin zu wechseln |
| In einem Terminal oder über die [VS Code-Erweiterung](/docs/de/vs-code) | `auto` mit Claude Code v2.1.283 oder später; bei früheren Versionen `auto` bei Pro-, Max- oder Team-Plänen in Sitzungen, die [Feature-Flags abrufen](/docs/de/env-vars#features-that-need-feature-flag-fetching), und `default` andernfalls |
In Ihrer [ersten Sitzung nach einer Installation oder einem Upgrade](/docs/de/env-vars#first-session-after-an-install-or-upgrade) kann Claude Code den Start-Berechtigungsmodus wählen, bevor seine Feature-Flags ankommen. Diese Sitzung kann in einem anderen Berechtigungsmodus starten als die Tabelle angibt.
Wenn das Flag, eine Einstellungsdatei oder der integrierte Standard `auto` auswählt, aber Auto-Modus nicht für die Sitzung verfügbar ist, startet Claude Code die Sitzung stattdessen im Manual-Modus. Auto-Modus ist nicht verfügbar, wenn die Sitzung die [Verfügbarkeitsanforderungen](#eliminate-prompts-with-auto-mode) nicht erfüllt, wie eine Einstellungsdatei, die ihn ausschaltet, oder ein Modell, das ihn nicht unterstützt, oder wenn Anthropic ihn vorübergehend serverseitig ausgeschaltet hat.
Das erste Mal, wenn der integrierte Standard eine Ihrer Sitzungen im Auto-Modus startet, zeigt Claude Code einen Hinweis, der auf diese Seite verlinkt:
* In einem Terminal, einmal, oben in der Sitzung
* In der VS Code-Erweiterung, als Karte auf dem Bildschirm für neue Konversationen, die bleibt, bis Sie sie schließen
Wenn Ihre `~/.claude/settings.json` einen `defaultMode` setzt, der nicht `auto` ist, und keine andere Einstellungsdatei setzt einen, starten Ihre Sitzungen weiterhin in diesem Modus. Bei Pro-, Max- und Team-Plänen und in Sitzungen, die [keine Feature-Flags abrufen](/docs/de/env-vars#features-that-need-feature-flag-fetching), fragt Claude Code einmal, im Terminal oder in der VS Code-Erweiterung, ob die Einstellung auf Auto-Modus geändert werden soll. Wenn Sie ablehnen, bleibt Ihre Einstellung wie sie ist.
Starten Sie in einem anderen Berechtigungsmodus
Sie können den Start-Berechtigungsmodus für eine Sitzung oder als Standard für jede Sitzung auf einem Computer, in einem Projekt oder in einer Organisation festlegen. Wenn mehr als eine Einstellungsdatei `permissions.defaultMode` setzt, entscheidet der [Vorrang der Einstellungen](/docs/de/settings#settings-precedence), sodass ein Projekt- oder verwalteter Wert `~/.claude/settings.json` übertrumpft. Um den Berechtigungsmodus einer bereits laufenden Sitzung zu ändern, siehe [Berechtigungsmodi wechseln](#switch-permission-modes).
| Um den Start-Berechtigungsmodus festzulegen für | Tun Sie dies |
| :- | :- |
| Eine Sitzung, die Sie gerade starten | Übergeben Sie den Berechtigungsmodus als Flag, zum Beispiel `claude --permission-mode default` |
| Jede Terminal-Sitzung, die Sie auf diesem Computer starten | Setzen Sie `permissions.defaultMode` in `~/.claude/settings.json`. Für das, was die VS Code-Erweiterung liest, siehe [Berechtigungsmodi wechseln](#switch-permission-modes) |
| Jede Terminal-Sitzung, die Sie in einem Projekt starten | Setzen Sie `permissions.defaultMode` in `.claude/settings.json` des Projekts. Sitzungen, die Sie in einem Terminal starten, respektieren jeden Wert außer `auto` und `bypassPermissions`; Sitzungen, die die VS Code-Erweiterung startet, lesen keine Projekteinstellungen für den Start-Berechtigungsmodus |
| Jede Terminal-Sitzung in Ihrer Organisation | Setzen Sie `permissions.defaultMode` in [verwalteten Einstellungen](/docs/de/managed-settings). Terminal-Sitzungen starten in diesem Modus und Personen können weiterhin zum Auto-Modus wechseln; für das, was die VS Code-Erweiterung liest, siehe [Berechtigungsmodi wechseln](#switch-permission-modes). Um Auto-Modus zu entfernen, damit niemand ihn auswählen kann, setzen Sie stattdessen `permissions.disableAutoMode` auf `"disable"` |
Dieses Beispiel macht jede Terminal-Sitzung auf Ihrem Computer im Manual-Modus starten, dessen Konfigurationswert `default` ist. Speichern Sie es in `~/.claude/settings.json`:
```json theme={null}
{
"permissions": {
"defaultMode": "default"
}
}
```
Die nächste Sitzung, die Sie starten, zeigt `⏸ manual mode on` in der Statusleiste.
Berechtigungsmodi mit der HIPAA-Konfiguration
In einer Organisation, auf die die [HIPAA-Konfiguration](/docs/de/hipaa-setup) angewendet ist, gilt der integrierte `auto` Standard nicht. Eine Terminal- oder VS Code-Sitzung startet im Manual-Modus, wenn nichts anderes ihren Start-Berechtigungsmodus festlegt. Eine Terminal-Sitzung zeigt außerdem `Auto mode isn't the default for your organization · Shift+Tab to switch` an, und die VS Code-Erweiterung zeigt keinen Hinweis an. [Prüfen, wie sich Entwickler anmelden und verbinden](/docs/de/hipaa-setup#check-how-developers-sign-in-and-connect) listet die Sitzungen auf, für die dies gilt.
Auto-Modus und `bypassPermissions` bleiben verfügbar:
* **Zum Auto-Modus wechseln**: Drücken Sie `Shift+Tab` oder verwenden Sie [das Bedienelement Ihrer Oberfläche](#switch-permission-modes)
* **Im Auto-Modus starten**: Übergeben Sie `--permission-mode auto` oder setzen Sie `permissions.defaultMode` auf `auto` in Ihren Benutzereinstellungen oder in verwalteten Einstellungen für Ihre gesamte Organisation. Siehe [Starten Sie in einem anderen Berechtigungsmodus](#start-in-a-different-mode)
* **Auto-Modus entfernen**: Setzen Sie [`permissions.disableAutoMode`](/docs/de/settings-reference#disableautomode) in verwalteten Einstellungen auf `"disable"`
* **`bypassPermissions` blockieren**: Setzen Sie [`permissions.disableBypassPermissionsMode`](/docs/de/settings-reference#permissions-disablebypasspermissionsmode) in verwalteten Einstellungen auf `"disable"`
Erfordert Claude Code v2.1.285 oder später, die [Mindestversion für die HIPAA-Konfiguration](/docs/de/hipaa-setup#update-claude-code-and-claude-desktop).
Berechtigungsmodi wechseln
Jede Schnittstelle hat ihre eigene Kontrolle zum Wechseln von Berechtigungsmodi während einer Sitzung und ihre eigene Weise, den Berechtigungsmodus zu wählen, den neue Sitzungen starten. Wählen Sie Ihre Schnittstelle aus, um ihre Kontrollen zu sehen.
**Während einer Sitzung**: Drücken Sie `Shift+Tab`, um Berechtigungsmodi zu durchlaufen. Von `auto` wechselt der erste Druck zu `default`, und der Zyklus läuft dann `default` → `acceptEdits` → `plan`. Optionale Modi werden nach `plan` eingefügt. Die Statusleiste zeigt den aktiven Modus als graues `⏸ manual mode on` für `default` oder als `⏵⏵ accept edits on`, `⏸ plan mode on`, `⏵⏵ auto mode on`, `⏵⏵ don't ask on` oder `⏵⏵ bypass permissions on`.
Beobachten Sie die Statusleiste in diesem Clip einer Sitzung, die im Auto-Modus gestartet wurde. Jedes Mal, wenn Sie `Shift+Tab` drücken, wechselt sie von `auto mode on` zu `manual mode on`, `accept edits on`, `plan mode on` und zurück zu `auto mode on`.
Nicht jeder Modus ist im Standard-Zyklus enthalten:
* `auto`: wird angezeigt, wenn [Auto-Modus verfügbar ist](#eliminate-prompts-with-auto-mode); das Wechseln zu ihm schaltet Berechtigungsmodi ohne Bestätigungsaufforderung um
* `bypassPermissions`: wird angezeigt, nachdem Sie mit `--permission-mode bypassPermissions`, `--dangerously-skip-permissions`, `--allow-dangerously-skip-permissions` oder `permissions.defaultMode: "bypassPermissions"` in [Benutzer-, `--settings`- oder verwalteten Einstellungen](/docs/de/settings-reference#permissions-defaultmode) starten. Die `--allow-` Variante fügt den Berechtigungsmodus zum Zyklus hinzu, ohne ihn zu aktivieren
* `dontAsk`: wird nie im Zyklus angezeigt; setzen Sie ihn mit `--permission-mode dontAsk`
Aktivierte optionale Modi werden nach `plan` eingefügt, mit `bypassPermissions` zuerst und `auto` zuletzt. Wenn Sie beide aktiviert haben, wechseln Sie durch `bypassPermissions` auf dem Weg zu `auto`.
**Von einer Bash-Berechtigungsaufforderung**: im Manual- und `acceptEdits`-Berechtigungsmodus, wenn [Auto-Modus](#eliminate-prompts-with-auto-mode) verfügbar ist, fügt Claude Code **Ja, und zum Auto-Modus wechseln** zu einer Bash-Befehlsberechtigungsaufforderung hinzu. Wählen Sie es aus, um den Befehl zu genehmigen und die Sitzung zum Auto-Modus zu wechseln. [PowerShell-Tool](/docs/de/tools-reference#powershell-tool) Aufforderungen bieten die Option nicht an. Erfordert Claude Code v2.1.247 oder später.
Claude Code fügt die Option nicht zu Aufforderungen hinzu, die von einer Ihrer [`ask` Regeln](/docs/de/permissions#manage-permissions) oder von einem [Hook](/docs/de/hooks#pretooluse-decision-control) erzwungen werden, da Auto-Modus diese Aufforderungen immer noch zeigt, sodass das Wechseln sie nicht entfernen würde.
**Beim Start**: Übergeben Sie den Berechtigungsmodus als Flag.
```bash theme={null}
claude --permission-mode plan
```
**Als Standard**: Setzen Sie `permissions.defaultMode` im Bereich, den Sie möchten, wie in [Starten Sie in einem anderen Berechtigungsmodus](#start-in-a-different-mode) beschrieben.
Das gleiche `--permission-mode` Flag funktioniert mit `-p` für [nicht-interaktive Ausführungen](/docs/de/headless).
**Während einer Sitzung**: Klicken Sie auf den Modusindikator am unteren Rand des Eingabefelds. Er verwendet diese Beschriftungen für die Modi auf dieser Seite:
| UI-Beschriftung | Modus |
| :- | :- |
| Manual | `default` |
| Edit automatically | `acceptEdits` |
| Plan | `plan` |
| Auto | `auto` |
| Bypass permissions | `bypassPermissions` |
**Als Standard**: Um den Berechtigungsmodus zu fixieren, in dem Konversationen starten, setzen Sie `claudeCode.initialPermissionMode` in Ihren VS Code-Benutzereinstellungen auf `default`, `manual`, `acceptEdits`, `plan` oder `bypassPermissions`. Die Einstellung akzeptiert nicht `auto`; um im Auto-Modus zu starten, lassen Sie sie ungesetzt und wählen Sie **Auto** aus dem Modusindikator einmal aus, wie Punkt 2 unten beschreibt. Die Erweiterung startet jede neue Konversation in der ersten dieser Punkte, die zutrifft:
1. `claudeCode.initialPermissionMode`
2. Der Modus, den Sie zuletzt aus dem Modusindikator gewählt haben, wenn er Manual, Edit automatically oder Auto war. Das Auswählen von Plan oder Bypass permissions gilt nur für diese Konversation
3. `permissions.defaultMode` aus [verwalteten Einstellungen](/docs/de/managed-settings) oder `~/.claude/settings.json`
4. Der [integrierte Standard](#which-mode-a-session-starts-in) für Ihren Plan, Anbieter und Organisationseinstellungen
Die Erweiterung liest nie `.claude/settings.json` oder `.claude/settings.local.json` eines Projekts für den Standard-Berechtigungsmodus. Wenn `claudeCode.claudeProcessWrapper` gesetzt ist, gelten Punkte 3 und 4 nicht: Diese Konversationen starten im Manual-Modus, es sei denn, Punkt 1 oder Punkt 2 setzt einen Berechtigungsmodus.
Vor v2.1.283 galt Punkt 3 nur bei Pro-, Max- und Team-Plänen in Sitzungen, die [Feature-Flags abrufen](/docs/de/env-vars#features-that-need-feature-flag-fetching).
Auto wird im Modusindikator angezeigt, wenn [Auto-Modus verfügbar ist](#eliminate-prompts-with-auto-mode).
Bypass permissions erfordert den Schalter **Allow dangerously skip permissions** in den Erweiterungseinstellungen. Ohne ihn wird der Berechtigungsmodus nicht im Indikator angezeigt, und ein `bypassPermissions` Wert aus Punkt 1 oder Punkt 3 startet die Konversation stattdessen im Manual-Modus. Auto aus jedem Punkt startet die Konversation ebenfalls im Manual-Modus, wenn Auto-Modus nicht verfügbar ist.
Siehe den [VS Code-Leitfaden](/docs/de/vs-code) für erweiterungsspezifische Details.
Das JetBrains-Plugin führt Claude Code im IDE-Terminal aus, daher funktioniert das Wechseln von Berechtigungsmodi genauso wie in der CLI: Drücken Sie `Shift+Tab` zum Durchlaufen, oder übergeben Sie `--permission-mode` beim Start.
**Während einer Sitzung**: Verwenden Sie auf der Registerkarte Code den Moduswahlschalter neben der Schaltfläche zum Senden. Nicht jeder Modus wird im Wahlschalter angezeigt:
* **Auto**: wird angezeigt, wenn [Auto-Modus verfügbar ist](#eliminate-prompts-with-auto-mode)
* **Bypass permissions**: erfordert den Schalter **Allow bypass permissions mode** in den Desktop-Einstellungen bei Pro- und Max-Plänen; bei Team- und Enterprise-Plänen wird dies stattdessen durch die Organisationsrichtlinie gesteuert
Die Registerkarte Cowork verwendet diese Modi nicht. Cowork hat seine eigenen Berechtigungsmodi, die separat aktiviert werden, und die Registerkarte Cowork zeigt überhaupt keinen Moduswahlschalter, bis ein Modus über seinen Standard für Ihr Konto aktiviert wird. Siehe die [Cowork-Dokumentation](https://claude.com/docs/cowork/overview).
Für Desktop-spezifische Details siehe [Wählen Sie einen Berechtigungsmodus](/docs/de/desktop#choose-a-permission-mode) im Desktop-Leitfaden.
**Als Standard**: Setzen Sie `defaultMode` in [Einstellungen](/docs/de/settings#where-settings-live). Die Desktop-App liest die gleichen Einstellungsdateien wie die CLI und wendet den Berechtigungsmodus auf neue lokale Sitzungen an.
Ein Modus, den Sie im Moduswahlschalter auswählen, wird pro Ordner gespeichert und hat Vorrang vor `defaultMode` für diesen Ordner. Plan ist die Ausnahme: Das Auswählen gilt nur für die aktuelle Sitzung.
Wo `defaultMode` in einer Einstellungsdatei steht, sehen Sie im Beispiel unter [Starten Sie in einem anderen Berechtigungsmodus](#start-in-a-different-mode).
Verwenden Sie auf [claude.ai/code](https://claude.ai/code) das Modusmenü neben dem Eingabefeld. Tippen Sie in der mobilen App auf die Schaltfläche **+** im Eingabefeld und dann auf **Permission**. Cloud-Sitzungen und Remote-Control-Sitzungen bieten unterschiedliche Berechtigungsmodi:
* **[Cloud-Sitzungen](/docs/de/claude-code-on-the-web)**: Bearbeitungen akzeptieren, Plan und Auto. Bearbeitungen akzeptieren entspricht dem `default` Modus: Cloud-Sitzungen genehmigen Dateibearbeitungen vorab, unabhängig vom Modus, daher zeigt das Menü Bearbeitungen akzeptieren statt Manual an. Cloud-Sitzungen respektieren weiterhin `defaultMode: "acceptEdits"` aus den Einstellungen. Der Auto-Modus wird nur angezeigt, wenn Ihre Organisation ihn zulässt und das ausgewählte Modell ihn unterstützt. Bypass permissions ist nicht verfügbar.
* **[Remote Control](/docs/de/remote-control)-Sitzungen** auf Ihrem lokalen Computer: Manual, Bearbeitungen akzeptieren, Plan und Auto für eine Sitzung, die Sie selbst gestartet haben, und Sie können Bypass permissions nicht aus der App auswählen. Um Auto zu verwenden, muss die Sitzung die [Verfügbarkeitsanforderungen](#eliminate-prompts-with-auto-mode) des Auto-Modus erfüllen. Für einen Projekt-Thread, der auf Ihrem Computer läuft, siehe [Führen Sie einen Thread auf Ihrem eigenen Computer aus](/docs/de/claude-projects#run-a-thread-on-your-own-computer).
* Außer für Bypass permissions zeigt das Menü den Berechtigungsmodus an, in dem sich die lokale Sitzung befindet, einschließlich eines vom Terminal aus festgelegten Modus. Es wird aktualisiert, wenn sich der Berechtigungsmodus in der App oder im Terminal ändert.
* Sitzungen, die von der [Desktop-App](/docs/de/desktop) oder der [VS Code-Erweiterung](/docs/de/vs-code) gehostet werden, melden Berechtigungsmodus-Änderungen an claude.ai, während sie passieren, genauso wie Sitzungen, die in einem Terminal gehostet werden.
* Vor v2.1.202 meldeten Sitzungen, die mit `/remote-control` oder `claude --remote-control` verbunden waren, ihren Berechtigungsmodus überhaupt nicht, daher konnten claude.ai und die mobile App einen Berechtigungsmodus anzeigen, in dem sich die Sitzung nicht befand. Die Nichtübereinstimmung betraf nur die Beschriftung. Claude Code generierte Berechtigungsabfragen aus dem tatsächlichen Berechtigungsmodus der Sitzung, und sie wurden weiterhin in der App zur Genehmigung angezeigt.
Für Remote Control muss der lokale Computer, auf dem die Sitzung läuft, mit Ihrem claude.ai-Konto angemeldet sein; API-Schlüssel werden nicht unterstützt. Sie können auch den Standard-Berechtigungsmodus beim Start dieser lokalen Sitzung festlegen:
```bash theme={null}
claude remote-control --permission-mode acceptEdits
```
Dateibearbeitungen mit acceptEdits-Modus automatisch genehmigen
Der `acceptEdits`-Modus ermöglicht es Claude, Dateien in Ihrem Arbeitsverzeichnis zu erstellen und zu bearbeiten, ohne Sie zu fragen. Die Statusleiste zeigt `⏵⏵ accept edits on` an, während dieser Modus aktiv ist.
Zusätzlich zu Dateibearbeitungen genehmigt der `acceptEdits`-Modus automatisch häufige Bash-Befehle im Dateisystem: `mkdir`, `touch`, `rm`, `rmdir`, `mv`, `cp` und `sed`. Diese Befehle werden auch automatisch genehmigt, wenn sie mit sicheren Umgebungsvariablen wie `LANG=C` oder `NO_COLOR=1` oder Prozess-Wrappern wie `timeout`, `nice` oder `nohup` vorangestellt sind. Wie bei Dateibearbeitungen gilt die automatische Genehmigung nur für Pfade in Ihrem Arbeitsverzeichnis oder `additionalDirectories`.
Jeder Pfad durchläuft auch die [Symlink-Prüfung](/docs/de/permissions#symlinks), daher wird ein Schreibvorgang, der außerhalb dieses Bereichs aufgelöst wird, ebenfalls nicht automatisch genehmigt. Pfade außerhalb dieses Bereichs, Schreibvorgänge in [geschützte Pfade](#protected-paths), `rm` und `rmdir` Löschungen, die auf einen [kritischen Pfad](#critical-paths) abzielen, und alle anderen Bash-Befehle außer dem [integrierten schreibgeschützten Satz](/docs/de/permissions#read-only-commands) erfordern weiterhin eine Genehmigung.
Wenn das [PowerShell-Tool](/docs/de/tools-reference#powershell-tool) aktiviert ist, genehmigt der `acceptEdits`-Modus auch automatisch `Set-Content`, `Add-Content`, `Clear-Content` und `Remove-Item` auf Pfaden im Gültigkeitsbereich, zusammen mit ihren häufigen Aliasen. Die gleichen Bereichs- und Schutzpfad-Regeln gelten, und `Remove-Item` erhält [seine eigene Prüfung](#remove-item-in-powershell). Ein Positionsargument, das ein Anführungszeichen enthält, wie das Apostroph in `Set-Content .\notes.txt "It's done"`, fordert weiterhin auf, auch auf Pfaden im Gültigkeitsbereich, da Claude Code ein Argument, dessen zitierte und unzitierte Lesarten unterschiedlich sind, nicht statisch validieren kann. Übergeben Sie den Inhalt durch einen benannten Parameter wie `-Value`, um die Aufforderung zu vermeiden.
Verwenden Sie `acceptEdits`, wenn Sie Änderungen in Ihrem Editor oder über `git diff` im Nachhinein überprüfen möchten, anstatt jede Bearbeitung inline zu genehmigen.
Drücken Sie `Shift+Tab` einmal vom Manual-Modus aus, um ihn zu aktivieren, oder starten Sie direkt damit:
```bash theme={null}
claude --permission-mode acceptEdits
```
Analysieren Sie vor dem Bearbeiten mit dem Plan-Modus
Der Plan-Modus weist Claude an, Änderungen zu recherchieren und vorzuschlagen, ohne sie vorzunehmen. Claude liest Dateien, führt Shell-Befehle aus, um zu erkunden, und schreibt einen Plan, bearbeitet aber nicht Ihre Quelle. Außer in interaktiven Terminal-Sitzungen mit [verfügbaren Bypass-Berechtigungen](#skip-all-checks-with-bypasspermissions-mode) bleiben Bearbeitungen blockiert, bis Sie den Plan genehmigen.
Was mit einem Shell-Befehl während der Planung geschieht, hängt von der Sitzung ab, und der erste dieser Fälle, der zutrifft, gilt:
* **Interaktive Terminal-Sitzungen mit verfügbaren Bypass-Berechtigungen**: Weder der Klassifizierer noch eine Aufforderung gilt für Planungsbefehle. [Alle Überprüfungen mit bypassPermissions-Modus überspringen](#skip-all-checks-with-bypasspermissions-mode) behandelt die wenigen Dinge, die dort weiterhin auffordern.
* **[Auto-Modus](/docs/de/auto-mode-config) verfügbar und die `useAutoModeDuringPlan` Einstellung aktiviert**, was die Standardeinstellung ist: Der Klassifizierer überprüft Shell-Befehle außer [kritischen Pfad-Entfernungen](#critical-paths) statt Sie zu fragen. Genehmigte Befehle laufen, und abgelehnte werden blockiert.
* **Auto-Modus nicht verfügbar oder `useAutoModeDuringPlan` deaktiviert**: Befehle außerhalb des [integrierten schreibgeschützten Satzes](/docs/de/permissions#read-only-commands) fordern zur Genehmigung auf, auch wenn der Sandbox-[Auto-Allow-Modus](/docs/de/sandboxing#sandbox-modes) aktiviert ist.
Geben Sie den Plan-Modus ein, indem Sie `Shift+Tab` drücken oder einem einzelnen Prompt `/plan` voranstellen. Sie können auch vom CLI aus im Plan-Modus starten:
```bash theme={null}
claude --permission-mode plan
```
Drücken Sie `Shift+Tab` erneut, um den Plan-Modus zu verlassen, ohne einen Plan zu genehmigen.
Überprüfen und genehmigen Sie einen Plan
Wenn der Plan fertig ist, präsentiert Claude ihn und fragt, wie Sie vorgehen möchten. Von dieser Aufforderung aus können Sie wählen:
* **Ja, und Auto-Modus verwenden**: Genehmigen und im [Auto-Modus](#eliminate-prompts-with-auto-mode) starten. Wenn Auto-Modus nicht [für Ihre Sitzung verfügbar](#eliminate-prompts-with-auto-mode) ist, beispielsweise weil Ihre Organisation ihn deaktiviert hat, liest diese Option **Ja, Auto-Bearbeitungen akzeptieren**. Wenn Sie die Sitzung mit aktivierten Bypass-Berechtigungen gestartet haben, liest die Option **Ja, und zum BYPASS PERMISSIONS (keine weiteren Aufforderungen) für diese Sitzung wechseln** statt.
* **Ja, Bearbeitungen manuell genehmigen**: Genehmigen und jede Bearbeitung einzeln überprüfen.
* **Nein, weiter planen**: Bleiben Sie im Plan-Modus und sagen Sie Claude, was zu ändern ist.
Das Genehmigen eines Plans beendet den Plan-Modus und wechselt die Sitzung zum Berechtigungsmodus, den jede Genehmigungsoption beschreibt, sodass Claude mit der Bearbeitung beginnt. Um erneut zu planen, wechseln Sie mit `Shift+Tab` zurück zum Plan-Modus, oder stellen Sie Ihrem nächsten Prompt `/plan` voran.
Drücken Sie `Ctrl+G`, um den vorgeschlagenen Plan in Ihrem Standard-Texteditor zu öffnen und ihn direkt zu bearbeiten, bevor Claude fortfährt. Wenn [`showClearContextOnPlanAccept`](/docs/de/settings-reference#showclearcontextonplanaccept) aktiviert ist, erhält die Liste eine erste Option, die den Plan genehmigt und den Planungskontext löscht.
Das Akzeptieren eines Plans gibt der Sitzung auch einen [generierten Titel](/docs/de/sessions#name-your-sessions) basierend auf dem Plan, es sei denn, Sie haben die Sitzung bereits benannt.
Legen Sie den Plan-Modus als Standard fest
Um den Plan-Modus als Standard für die Terminal-Sitzungen eines Projekts festzulegen, setzen Sie `defaultMode` auf `plan` in `.claude/settings.json`, wie das Beispiel unter [Starten Sie in einem anderen Berechtigungsmodus](#start-in-a-different-mode) zeigt. Konversationen, die die [VS Code-Erweiterung](/docs/de/vs-code) startet, lesen keine Projekteinstellungen für den Standard-Berechtigungsmodus. Dort setzen Sie stattdessen `claudeCode.initialPermissionMode` auf `plan` in Ihren VS Code-Benutzereinstellungen.
Berechtigungsabfragen mit dem Auto-Modus eliminieren
Der Auto-Modus ermöglicht es Claude, ohne routinemäßige Berechtigungsabfragen auszuführen. Ein separates Klassifikatormodell überprüft Aktionen, bevor sie ausgeführt werden, und blockiert alles, das über Ihre Anfrage hinausgeht, auf nicht erkannte Infrastruktur abzielt oder von feindseligem Inhalt angetrieben zu sein scheint, den Claude gelesen hat. Explizite [Ask-Regeln](/docs/de/permissions#manage-permissions) erzwingen weiterhin eine Abfrage.
Mit Claude Code v2.1.283 oder später ist der Auto-Modus der [integrierte Standard-Berechtigungsmodus](#which-mode-a-session-starts-in) für interaktive Terminal- und VS Code-Sitzungen in jedem Plan und bei jedem Anbieter. Bei früheren Versionen ist er der integrierte Standard-Berechtigungsmodus nur bei Pro-, Max- und Team-Plänen.
Der Klassifikator überprüft auch jede Nachricht, die Claude mit [`SendMessage`](/docs/de/tools-reference) an einen anderen Agenten sendet, ob als Klartext oder als strukturierte [Agent-Team](/docs/de/agent-teams)-Nachricht, bevor Claude Code sie zustellt, sowohl im Auto-Modus als auch im [Plan-Modus, während der Klassifikator Befehle überprüft](#analyze-before-you-edit-with-plan-mode); die Überprüfung beim Senden erfordert Claude Code v2.1.222 oder später.
Standardmäßig überprüft der Klassifikator `rm`- und `rmdir`-Löschungen, die auf einen kritischen Pfad abzielen, wie `rm -rf /` oder `rm -rf ~`, nicht. [Kritische Pfade](#critical-paths) behandelt, was mit ihnen in jedem Berechtigungsmodus geschieht.
Der Auto-Modus ermutigt Claude auch, ohne Unterbrechung für Klärungsfragen weiterzuarbeiten, obwohl Claude immer noch fragt, wenn Ihr Prompt oder ein Skill explizit darauf angewiesen ist. Für stärkeres autonomes Verhalten in einem Modus, der Sie weiterhin um Bestätigung bittet, stellen Sie stattdessen den [Proactive-Ausgabestil](/docs/de/output-styles) ein.
Der Auto-Modus reduziert Berechtigungsabfragen, garantiert aber keine Sicherheit. Verwenden Sie ihn für Aufgaben, bei denen Sie der allgemeinen Richtung vertrauen, nicht als Ersatz für eine Überprüfung bei sensiblen Operationen.
Der Auto-Modus ist nur verfügbar, wenn Ihr Konto alle diese Anforderungen erfüllt:
* **Plan**: Alle Pläne.
* **Organisation**: Bei Team und Enterprise ist der Auto-Modus standardmäßig verfügbar. Administratoren können ihn für die Organisation deaktivieren, indem sie `permissions.disableAutoMode` in [verwalteten Einstellungen](/docs/de/managed-settings) auf `"disable"` setzen.
* **Modell**: Bei der Anthropic API und [Claude Platform auf AWS](/docs/de/claude-platform-on-aws) Claude Opus 4.6 oder später, Sonnet 4.6 oder später, Haiku 5.5 oder ein [Fable-Modell](/docs/de/model-config#work-with-fable). Bei Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry und angemeldeten [Claude-Apps-Gateway](/docs/de/claude-apps-gateway)-Sitzungen nur Claude Sonnet 5 oder später, Opus 4.7 oder später, Haiku 5.5 und die Fable-Modelle. Ältere Modelle, einschließlich Sonnet 4.5, Opus 4.5, Haiku 4.5 und claude-3-Modelle, werden bei keinem Anbieter unterstützt.
* **Anbieter**: Standardmäßig verfügbar bei der Anthropic API, Claude Platform auf AWS, Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry und angemeldeten Claude-Apps-Gateway-Sitzungen.
Wenn Claude Code meldet, dass der Auto-Modus nicht verfügbar ist, überprüfen Sie zunächst diese Anforderungen und ob eine Einstellungsdatei [`disableAutoMode`](/docs/de/settings-reference#disableautomode) setzt. Anthropic kann den Auto-Modus auch serverseitig deaktiviert haben, oder der Server kann den Auto-Modus für Ihr Konto abgelehnt haben. Eine Sitzung, die eine dieser Antworten erhalten hat, behält den Auto-Modus aus, bis die Sitzung endet. Starten Sie daher später eine neue Sitzung.
Eine separate Nachricht, die ein Modell benennt und sagt, dass der Auto-Modus die Sicherheit einer Aktion „nicht bestimmen kann“, bedeutet, dass eine Klassifikatoranfrage fehlgeschlagen ist. Dieser Fehler ist normalerweise vorübergehend, kann sich aber bei Amazon Bedrock wiederholen, bis Ihr Konto das benannte Modell aufrufen kann. Siehe die [Fehlerreferenz](/docs/de/errors#auto-mode-cannot-determine-the-safety-of-an-action) für die Ursachen und was zu tun ist.
Wenn Sie `defaultMode: "auto"` in [Einstellungen](/docs/de/settings-reference#all-settings) setzen und eine Terminal-Sitzung ohne Fehler im Manual-Modus startet, befindet sich die Einstellung wahrscheinlich in `.claude/settings.json` oder `.claude/settings.local.json`. `auto` wird aus diesen Dateien nicht wirksam. Verschieben Sie es nach `~/.claude/settings.json`. Überprüfen Sie für eine Konversation, die die VS Code-Erweiterung gestartet hat, stattdessen die eigene Liste der Erweiterung in [Berechtigungsmodi wechseln](#switch-permission-modes).
Bei [Amazon Bedrock](/docs/de/amazon-bedrock), [Google Cloud's Agent Platform](/docs/de/google-vertex-ai), [Microsoft Foundry](/docs/de/microsoft-foundry) und angemeldeten [Claude-Apps-Gateway](/docs/de/claude-apps-gateway)-Sitzungen ist der Auto-Modus standardmäßig verfügbar. Wenn nichts anderes einen Berechtigungsmodus setzt, ist er auch der [integrierte Standard-Berechtigungsmodus](#which-mode-a-session-starts-in), auf den Versionen, die die Tabelle jenes Abschnitts auflistet. Um den Standard-Berechtigungsmodus selbst zu wählen, setzen Sie `permissions.defaultMode` wie in [In einem anderen Berechtigungsmodus starten](#start-in-a-different-mode) beschrieben, oder wählen Sie einen Berechtigungsmodus aus dem Modus-Indikator der VS Code-Erweiterung.
Nur Claude Sonnet 5 oder später, Opus 4.7 oder später, Haiku 5.5 und die Fable-Modelle werden auf diesen Anbietern unterstützt. Bei jedem anderen Modell startet die Sitzung stattdessen im Manual-Modus. Der Auto-Modus mit Haiku 5.5 auf diesen Anbietern erfordert Claude Code v2.1.293 oder später.
Um Entwickler daran zu hindern, den Auto-Modus zu verwenden, setzen Sie `disableAutoMode` in [verwalteten Einstellungen](/docs/de/managed-settings) auf `"disable"`. Dies entfernt `auto` aus dem `Shift+Tab`-Zyklus, und eine Sitzung, die mit `--permission-mode auto` gestartet wird, startet stattdessen im Manual-Modus. Eine bereits im Auto-Modus laufende Sitzung verlässt ihn, wenn die Einstellung diese Sitzung aus einer [von Administratoren bereitgestellten Quelle](/docs/de/managed-settings#which-managed-source-claude-code-uses) erreicht, und zeigt `auto mode disabled by settings`. Vor v2.1.251 behielt eine laufende Sitzung den Auto-Modus bis zu ihrem Ende.
In v2.1.158 bis v2.1.206 war der Auto-Modus auf diesen Anbietern aus, bis Sie `CLAUDE_CODE_ENABLE_AUTO_MODE=1` setzten, und Claude Code ignorierte `defaultMode: "auto"` auf diesen Anbietern, es sei denn, die Variable war ebenfalls gesetzt. Die Variable wird aus Kompatibilitätsgründen weiterhin akzeptiert und hat ab v2.1.207 keine Auswirkung.
Serverseitige Klassifikatorüberprüfung
Im Auto-Modus kann Claude Code den Server bitten, die Aktionen zu überprüfen, die [die Entscheidungsreihenfolge](#how-the-classifier-evaluates-actions) zur Überprüfung sendet, als Teil der Modellanfragen der Sitzung, anstatt eigene Klassifikatoranfragen zu senden. Diese Sitzungen fragen beim Server an:
* **Eine direkte Verbindung zur Anthropic API**: in interaktiven Terminal-Sitzungen sowie in `-p`-, Agent SDK-, [VS Code-Erweiterungs](/docs/de/vs-code)- und [Desktop-App](/docs/de/desktop)-Sitzungen, unabhängig von Ihrem Plan oder Kontotyp, während Anthropic dies einführt. In interaktiven Terminal-Sitzungen erfordert dies Claude Code v2.1.271 oder später bei Pro-, Max- und Team-Plänen und v2.1.278 oder später bei Enterprise-Plänen und Claude API-Konten. In `-p`-, Agent SDK-, VS Code-Erweiterungs- und Desktop-App-Sitzungen erfordert dies Claude Code v2.1.281 oder später. Ab v2.1.282 fragt eine Sitzung, die [keine Feature-Flags abruft](/docs/de/env-vars#features-that-need-feature-flag-fetching), zum Beispiel weil Sie die Telemetrie deaktiviert haben, in jeder Art von Sitzung standardmäßig beim Server an.
* **Ein Cloud-Anbieter oder ein LLM-Gateway oder Proxy**: bei [Claude Platform auf AWS](/docs/de/claude-platform-on-aws), Amazon Bedrock, Google Cloud's Agent Platform und Microsoft Foundry, und wann immer Sie `ANTHROPIC_BASE_URL` auf ein [LLM-Gateway oder einen Proxy](/docs/de/llm-gateway) verweisen lassen, unabhängig von Ihrem Plan. Das standardmäßige Anfragen erfordert Claude Code v2.1.278 oder später.
* **Eine angemeldete [Claude-Apps-Gateway](/docs/de/claude-apps-gateway)-Sitzung**: erfordert Claude Code v2.1.280 oder später
Wenn der Server die Aktionen überprüft, entscheiden seine Urteile über sie. Zwei weitere Ergebnisse sind möglich:
* **Der Server überprüft die Sitzung nicht**: Eine Antwort wird ohne Überprüfungsergebnisse abgeschlossen, oder der Server antwortet, dass er diese Sitzung nicht überprüft. Die häufigsten Ursachen sind ein LLM-Gateway oder Proxy, das die Anfrage zur Überprüfung oder die Ergebnisse verwirft, und eine Plattform, Region oder Anmeldedaten, für die es noch keine serverseitigen Überprüfungen gibt. Claude Code fällt auf seine eigenen Klassifikatoranfragen zurück. Sobald dieser Fallback für den Rest der Sitzung gilt, zeigt es bei Konten, bei denen diese Anfragen in Rechnung gestellt werden, einen [Hinweis zu Gebühren für Klassifikatoranfragen](/docs/de/auto-mode-classifier-billing).
* **Der Server gibt kein Urteil für eine Aktion ab**: Claude Code verweigert die Aktion, anstatt sie ungeprüft auszuführen. Bei jeder Verbindung geschieht dies, wenn die Antwort endet, bevor die Überprüfungsergebnisse ankommen, oder die Ergebnisse in einer Form ankommen, die Claude Code nicht lesen kann. Ein LLM-Gateway oder Proxy, das Antworten kürzt oder die Ergebnisse umschreibt, kann beides verursachen. Bei einer direkten Verbindung zur Anthropic API geschieht dies auch, wenn die Überprüfung des Servers für die Aktion fehlschlägt, zum Beispiel durch ein Timeout. [Der Server hat kein Sicherheitsurteil zurückgegeben](/docs/de/errors#the-server-returned-no-safety-verdict) behandelt die Verweigerungsmeldung, was geschieht, wenn sich Verweigerungen wiederholen, und was zu tun ist.
Um die Anfrage beim Server zu überspringen und immer die eigenen Klassifikatoranfragen von Claude Code zu verwenden, setzen Sie [`CLAUDE_CODE_AUTO_MODE_SERVER=0`](/docs/de/env-vars). Bei einer direkten Verbindung zur Anthropic API erfordert die Variable Claude Code v2.1.281 oder später. Wenn Sie sie dort auf `1` setzen, wird die Serverüberprüfung in einer Sitzung aktiviert, die sie noch nicht hat, es sei denn, Sie haben auch `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1` gesetzt. Wenn Sie `CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1` setzen und `CLAUDE_CODE_AUTO_MODE_SERVER` nicht setzen, fragt Claude Code ebenfalls nicht mehr beim Server an, außer wie in [Vorabversions-Funktionen deaktivieren](/docs/de/llm-gateway-protocol#disable-pre-release-capabilities) beschrieben.
Was der Klassifikator standardmäßig blockiert
Der Klassifikator vertraut Ihrem Arbeitsverzeichnis und den Remotes, die dafür konfiguriert waren, als die Sitzung begann. Einem Remote, das während der Sitzung mit `git remote add` oder `git remote set-url` hinzugefügt oder umgeleitet wird, wird nicht vertraut, und alles andere wird als extern behandelt, bis Sie [vertrauenswürdige Infrastruktur konfigurieren](/docs/de/auto-mode-config).
**Standardmäßig blockiert**:
* Herunterladen und Ausführen von Code, wie `curl | bash`
* Senden sensibler Daten an externe Endpunkte
* Produktionsbereitstellungen und Migrationen
* Massenlöschung in Cloud-Speicher
* Gewährung von IAM- oder Repo-Berechtigungen
* Änderung gemeinsam genutzter Infrastruktur
* Irreversibles Zerstören von Dateien, die vor der Sitzung existierten
* Force Push
* Committen oder Pushen einer Änderung, die bei ihrer Ausführung Geheimnisse oder sensible Daten aus dem Repository hinaussenden oder erweitern würde, was eine Bereitstellung offenlegt. Dies umfasst einen CI-Workflow oder eine Bereitstellungskonfiguration, die ein Geheimnis an ein Ziel übergibt, das es nicht bereits erhält, ein Skript oder einen Setup-Schritt, der einen Geheimnisspeicher liest und die Daten hinaussendet, und eine Konfigurationsänderung, die erweitert, was eine Bereitstellung veröffentlicht, etwa eine Registry-, Sichtbarkeits-, Artefakt- oder Sourcemap-Einstellung. Die Prüfung gilt auf jedem Branch, gilt auch, wenn das Repository öffentlich ist, und greift, wenn die Änderung committet oder gepusht wird, unabhängig davon, ob dieser Commit oder Push die Pipeline auslöst; um sie aufzuheben, muss der Ausführungseffekt benannt werden, nicht nur der Commit oder Push. Vor v2.1.211 war diese Prüfung stattdessen auf den Standard-Branch beschränkt: Ein Push dorthin wurde blockiert, wenn er sensiblen Inhalt enthielt, Änderungen gegenüber Ihrer Anfrage verbarg oder falsch beschrieb, von außerhalb des Repositorys übernommenen Inhalt enthielt oder eine von Ihnen verlangte Überprüfung umging
* `git reset --hard`, `git checkout -- .`, `git restore .`, `git clean -fd`, `git stash drop` oder `git stash clear`, von denen der Klassifikator annimmt, dass sie nicht committete Änderungen verwerfen würden
* `git commit --amend`, wenn der Commit am HEAD nicht in dieser Sitzung erstellt wurde
* Ab v2.1.198 `git commit --amend`, wenn der Commit am HEAD bereits gepusht wurde. Eine reine Umformulierung der Nachricht wird nicht blockiert: `--amend -m` ohne neu gestagte Änderungen, bei einem Commit, den Claude während dieser Sitzung erstellt hat
* `terraform destroy`, `pulumi destroy`, `cdk destroy` oder `terragrunt destroy` sowie das Anwenden eines Plans, der Ressourcen zerstört
* Schreiben in einen Secret Manager oder Ändern von DNS-Einträgen oder TLS-Zertifikaten
* Mergen eines Pull Requests, den kein Mensch genehmigt hat, Genehmigen von Claudes eigenem Pull Request oder Deaktivieren von CI-Prüfungen
* Posten eines Kommentars, der selbst ein Befehl an eine Automatisierung ist, wie `atlantis apply` oder `/deploy` bzw. `/merge` eines Bots
* Umschalten, schrittweises Hochfahren oder Löschen eines Produktions-Feature-Flags
* Anwenden von Infrastrukturänderungen auf einen geschützten IaC-Bereich oder Leeren und Entfernen von Cluster-Knoten
* Schreibvorgänge in einen gemeinsam genutzten Compute-Cluster, die über die von Ihnen benannte Ressource hinausgehen, wie ein Label-Selektor oder `--all`, der Jobs anderer Benutzer erfasst
* Erstellen von Kubernetes-Ressourcen, die auf jedem Knoten laufen oder Cluster-Verkehr abfangen, wie DaemonSets und Admission Webhooks
* Interaktive Shells oder Port-Forwards in ein sensibles Remote-Ziel
* Öffnen eines Tunnels oder einer Reverse Shell, die einen lokalen Dienst aus dem öffentlichen Internet erreichbar macht
* Ausgeben gültiger Anmeldedaten oder eines Tokens in das Transkript oder eine Datei
* Zugreifen auf einen Ort, der in Ihrer [Umgebung](/docs/de/auto-mode-config#define-trusted-infrastructure) als sensibler Datenort aufgeführt ist, Kopieren von Daten daraus oder Senden von Daten daraus an eine Zielgruppe, die der Eintrag ausschließt
* Umleiten einer Paketinstallation an Ihrer internen Paket-Registry vorbei zu einer öffentlichen Registry. Dies gilt, wenn eine interne Registry oder ein Mirror in Ihrer Umgebung aufgeführt ist oder wenn Sie Claude in der Konversation mitgeteilt haben, dass eine solche existiert
* Ausführen eines Befehls mit einem Flag, das einen Sicherheitsschutz deaktiviert, wie `--insecure`
* Starten einer autonomen Agentenschleife, die ohne menschliche Genehmigung oder Sandbox läuft, etwa einer mit `--dangerously-skip-permissions` oder `--no-sandbox` gestarteten. Dies umfasst das Ausführen eines Drittanbieter-Agenten oder Eval-Harness mit deaktivierter Isolation und deaktivierter Genehmigung pro Aktion, etwa eines mit `--yes-always` gestarteten Runners
* Browser-Aktionen von [Claude in Chrome](/docs/de/chrome), die Seiteninhalte, Cookies oder Anmeldedaten an einen anderen Origin senden könnten
* Löschen von Dateien in `/tmp`, `$TMPDIR` oder einem anderen gemeinsam genutzten Scratch- oder Cache-Verzeichnis per Wildcard, Glob oder Altersfilter statt über einen konkret benannten Pfad
* Einbeziehen sensibler Details in Inhalte, die an andere Personen oder gemeinsam genutzte Systeme gesendet, hochgeladen, veröffentlicht oder geschrieben werden, wenn Ihre eigene Nachricht diese Details für diesen Empfänger nicht autorisiert hat. PR- und Issue-Texte, Commit-Nachrichten und Kommentare zählen als diese Art von ausgehendem Inhalt, wenn das Repository außerhalb der Vertrauensgrenze liegt oder öffentlich ist, einschließlich der eigenen öffentlichen Repositorys Ihrer Organisation; interne Dateipfade, Codenamen, Live-Daten aus API-Antworten wie E-Mails oder Kontokennungen sowie Infrastrukturkennungen zählen als sensible Details. Live-Personendaten aus einer API-Antwort in einem PR- oder Issue-Text, wie eine E-Mail-Adresse, eine Konto- oder Organisationskennung oder eine Nutzungsmetrik, erfordern, dass Sie diese Details und den Empfänger benennen, unabhängig von der Sichtbarkeit oder Vertrauensgrenze des Repositorys. Diese Prüfung erfordert Claude Code v2.1.203 oder später
* Senden von Tastenanschlägen an den eigenen tmux-Bereich von Claude Code, um dessen eigene Oberfläche zu steuern, was der Klassifikator so behandelt, als würde Claude seine eigenen Berechtigungen oder seine eigene Aufsicht ändern
* Auskommentieren, Löschen oder erzwungenes Bestehen eines Tests oder einer Assertion, die Sicherheitsverhalten absichert, wie Authentifizierung, Zugriffskontrolle, Eingabevalidierung oder Sandboxing
* Löschen oder Abbauen einer zustandsbehafteten Ressource, die Claude nicht in der Sitzung erstellt hat, wenn keine spezifischere Löschregel greift und Sie diese Ressource nicht benannt haben
* Umleiten einer API-Basis-URL, eines Proxy-Endpunkts, eines Webhook-Empfängers oder eines Registry-Mirrors auf einen Drittanbieter-Host, der nicht zur Aufgabe passt, auch in Beispieldateien wie `.env.example`
* Ändern, wohin Pushes gehen, mit `git remote set-url` oder `git remote add`, es sei denn, Sie haben das neue Remote benannt
* Pushen von Geheimnissen oder persönlichen oder anvertrauten Daten in ein Repository, das bekanntermaßen öffentlich ist, oder Pushen von vertraulichem Material dorthin, das nicht zur eigenen Arbeit dieses Repositorys gehört. Der eigene Gegenstand eines Dotfiles-Repositorys ist die einzige Ausnahme für persönliche oder anvertraute Daten, und Inhalte aus einem privaten Repository, die eine beliebige öffentliche Oberfläche erreichen, werden auf die gleiche Weise blockiert; beide Verfeinerungen erfordern Claude Code v2.1.203 oder später. Vor v2.1.203 wurden persönliche Daten zusammen mit vertraulichem Material behandelt und nur blockiert, wenn sie nicht zur eigenen Arbeit dieses Repositorys gehörten. Wenn die Sichtbarkeit eines Repositorys nicht feststeht, blockiert der Klassifikator nicht allein deswegen; er beurteilt den Inhalt stattdessen anhand der anderen Regeln
* Öffnen eines Pull Requests gegen ein anderes Repository oder eine andere Organisation, Forken mit `gh repo fork` oder Pushen in ein Drittanbieter-Repository, es sei denn, Sie haben dieses externe Ziel benannt
Mehrere dieser Kategorien hängen von [Umgebungs](/docs/de/auto-mode-config#define-trusted-infrastructure)-Einträgen ab, etwa sensiblen Remote-Zielen und geschützten IaC-Bereichen, die Sie auf konkrete Namen eingrenzen können.
Claude Code v2.1.203 und später blockieren standardmäßig zusätzlich:
* Inhalte aus einem sensiblen lokalen Speicher oder aus einer Datei, deren Name, Pfad oder Typ sie als sensibel kennzeichnet, die in einen Commit, einen Push, einen PR- oder Issue-Text, einen Gist oder Paste oder eine Paketveröffentlichung gelangen, es sei denn, Sie haben sowohl die Quelle als auch das Ziel benannt. Sitzungstranskripte und Konversations-Logs, Punkt-Ordner mit Anmeldedaten und Konfiguration wie SSH-Schlüssel, Cloud-Anmeldedaten, Browser-Profile und Shell-Verlauf sowie Exporte von Benutzerdaten zählen alle dazu, und dass das Repository privat ist, hebt die Blockierung nicht auf
Claude Code v2.1.205 und später blockieren standardmäßig zusätzlich:
* Schreiben in Sitzungstranskripte von Claude Code, also die `.jsonl`-Verlaufsdateien unter `~/.claude/projects/` oder Ihrem konfigurierten Konfigurationsverzeichnis, ob direkt oder über einen Shell-Befehl. Die Regel umfasst auch die Metadatenzeilen, die Claude Code für seine eigenen Prüfungen an jeden Transkripteintrag anhängt. Das Lesen eines Transkripts wird nicht blockiert
* Ein rekursives erzwungenes Löschen wie `rm -rf "$VAR"` oder `Remove-Item -Recurse -Force $dir`, dessen Ziel eine Shell-Variable ist, die nirgendwo in der für den Klassifikator sichtbaren Konversation zugewiesen wird, oder ein Glob, der auf einer solchen Variable aufsetzt. Der Wert stammt nur aus früherer Befehlsausgabe, die der Klassifikator nie erhält, daher kann der Klassifikator das Löschziel nicht anhand der anderen Löschregeln überprüfen. Die Blockierung wird aufgehoben, wenn Sie den genauen zu löschenden Pfad benennen oder wenn Claude das Löschen erneut ausführt und dabei den aufgelösten literalen Pfad in den Befehl schreibt. Löschvorgänge, deren Ziel der Klassifikator auflösen kann, sind nicht betroffen.
Ein Glob direkt unter der Variable, wie in `rm -rf "$VAR"/*`, ist stattdessen ein [kritischer Pfad](#critical-paths). `Remove-Item`-Ziele, die ein bloßes `*` sind oder auf `/*` oder `\*` enden, erreichen den Klassifikator nie: Claude Code [verweigert sie direkt](#remove-item-in-powershell).
Claude Code v2.1.257 und später blockieren standardmäßig zusätzlich:
* Anfordern von Anmeldedaten vom Instanz-Metadaten-Endpunkt der Cloud, wie `169.254.169.254`, oder explizites Authentifizieren eines Cloud-, Cluster- oder Registry-Aufrufs mit dem eigenen Service-Account oder der Knotenidentität der Maschine
* Erreichen eines öffentlichen Hosts auf einem anderen Weg als über eine direkte Anfrage, etwa über einen Tunnel, eine Reverse Shell oder eine Resolver- oder Proxy-Konfiguration, die so umgeschrieben wurde, dass sie nach außen zeigt
* Lesen von Anmeldedaten, die zum Host statt zu Ihrer Aufgabe gehören, wie Knotenzertifikate oder die Container-Registry-Authentifizierung des Knotens
* Verbinden mit oder Scannen von benachbarten Containern, Pods oder VMs, die Claude nicht gestartet hat, oder des Knotens unter dem Container
Wenn Claude Code in einer Umgebung läuft, die eines davon erlauben soll, beschreiben Sie dieses Setup in einem [Host-Containment-Eintrag](/docs/de/auto-mode-config#define-trusted-infrastructure) in `autoMode.environment`.
Claude Code v2.1.261 und später blockieren standardmäßig zusätzlich:
* Posten oder Schreiben eines Links zu einem öffentlichen Paste-, Diagramm- oder Datenaustauschdienst in einer Nachricht, einem PR- oder Issue-Text, einem Dokument oder an einer anderen Stelle, an der der Link geöffnet oder abgerufen wird, wenn die URL selbst den geteilten Inhalt enthält, es sei denn, Sie haben diesen Dienst benannt
**Standardmäßig erlaubt**:
* Lokale Dateivorgänge in Ihrem Arbeitsverzeichnis
* Installieren von Abhängigkeiten, die in Ihren Lock-Dateien oder Manifesten deklariert sind
* Lesen von `.env` und Senden von Anmeldedaten an die zugehörige API
* Nur lesende HTTP-Anfragen
* Pushen zu jedem Branch des Repositorys, in dem Sie arbeiten, einschließlich des Standard-Branchs. Ein anderer als der Standard-Branch, dessen Name ihn als Bereitstellungs- oder Veröffentlichungsziel kennzeichnet, wie `production` oder `gh-pages`, ist nicht abgedeckt: Der Klassifikator beurteilt einen Push dorthin für sich. Der Inhalt des Pushs wird weiterhin anhand der anderen Regeln geprüft, [`permissions.deny`-Regeln](/docs/de/permissions#manage-permissions) können Push-Befehle [wie geschrieben](/docs/de/permissions#bash-rule-limits) in jedem Modus weiterhin blockieren, und der eigene Branch-Schutz des Remotes gilt weiterhin. Vor v2.1.211 waren standardmäßig nur Pushes zu dem Branch, auf dem Sie begonnen haben, zu Branches, die Claude erstellt hat, und routinemäßige Pushes zum Standard-Branch erlaubt, und vor v2.1.203 war jeder direkte Push zum Standard-Branch blockiert
* Löschen genau der Jobs, die Claude früher in derselben Sitzung erstellt hat
* Lesen, Überprüfen oder Schreiben von sicherheitsbezogenem Code, Konfigurationen und Bedrohungsmodellen als Teil Ihrer Aufgabe
* Nachrichten zwischen Agenten, die in derselben Multi-Agent-Sitzung zusammenarbeiten
* Senden von Daten an die vertrauenswürdigen Domains, Buckets und Dienste, die Sie in [`environment`](/docs/de/auto-mode-config#define-trusted-infrastructure) auflisten. Dies umfasst nur den Datenfluss, nicht destruktive oder Anmeldedaten betreffende Operationen auf derselben Infrastruktur
* Navigation von [Claude in Chrome](/docs/de/chrome) zu einer vertrauenswürdigen internen Domain, zu localhost oder zu einer URL, die Sie benannt haben
In einer Sandbox ausgeführte Befehle erhalten standardmäßig keinen Netzwerkzugriff. Claude benennt die Hosts, die ein Befehl benötigt, direkt am Befehl, der Klassifikator überprüft sie zusammen mit dem Befehl, und eine genehmigte Liste öffnet diese Hosts nur für diesen einen Befehl. [Pro Befehl erlaubte Domains](/docs/de/sandboxing#per-command-allowed-domains-in-auto-mode) behandelt, was eine Liste öffnen kann und was nicht und was geschieht, wenn ein Befehl auf einen nicht aufgeführten Host zugreift.
Führen Sie `claude auto-mode defaults` aus, um die vollständigen Regellisten als JSON auszugeben. Wenn alltägliche Aktionen blockiert werden, kann ein Administrator über die Einstellung `autoMode.environment` vertrauenswürdige Repos, Buckets und Dienste hinzufügen: siehe [Auto-Modus konfigurieren](/docs/de/auto-mode-config).
Pushen zu jedem Branch des Repositorys, in dem Sie arbeiten, und Erstellen eines Pull Requests, der Ihrer Anfrage entspricht, laufen ohne Abfrage, es sei denn, der Push oder Pull Request fällt unter die [Blockierliste](#what-the-classifier-blocks-by-default), etwa Geheimnisse oder sensible Daten, die das Repository verlassen, oder ein Pull Request, der auf ein anderes Repository oder eine andere Organisation abzielt. Um vor diesen Befehlen einen menschlichen Checkpoint zu verlangen und dabei im Auto-Modus zu bleiben, fügen Sie `permissions.ask`-Regeln hinzu, die den Befehl [wie geschrieben](/docs/de/permissions#bash-rule-limits) abgleichen: siehe [Häufige Grenzen](/docs/de/auto-mode-config#common-boundaries).
Der erste Lesezugriff außerhalb der Arbeitsverzeichnisse
Solange [`permissions.blockReadsOutsideWorkingDirectories`](/docs/de/settings-reference#permissions-blockreadsoutsideworkingdirectories) deaktiviert ist, laufen Dateilesevorgänge mit Ausnahme von [Lesezugriffen auf Netzwerkpfade](/docs/de/permissions#network-paths) im Auto-Modus ohne Abfrage, einschließlich Lesezugriffen außerhalb der [Arbeitsverzeichnisse](/docs/de/permissions#working-directories). Wenn Claude das Read-, Grep- oder Glob-Tool zum ersten Mal auf einen Pfad außerhalb davon anwendet, fragt Claude Code, ob dieser Lesezugriff erlaubt werden soll.
Die Abfrage erscheint nicht in nicht-interaktiven `-p`-Läufen oder Hintergrundsitzungen; Lesezugriffe laufen dort wie bisher.
Was auch immer Sie antworten, Claude arbeitet weiter:
* **Ja, und weiterhin alle Lesezugriffe außerhalb der Arbeitsverzeichnisse erlauben**: Der Lesezugriff läuft, spätere Lesezugriffe außerhalb der Arbeitsverzeichnisse laufen wie bisher, und Claude Code speichert Ihre Antwort, damit die Abfrage nicht erneut erscheint
* **Nein, und Lesezugriffe außerhalb der Arbeitsverzeichnisse ab jetzt blockieren**: Der Lesezugriff wird verweigert, und Claude Code setzt [`permissions.blockReadsOutsideWorkingDirectories`](/docs/de/settings-reference#permissions-blockreadsoutsideworkingdirectories) in Ihren Benutzereinstellungen auf `true`, wodurch die Datei-Tools solche Lesezugriffe in jeder späteren Sitzung und in jedem Berechtigungsmodus verweigern. Um Claude später einen solchen Pfad lesen zu lassen, fügen Sie sein Verzeichnis mit `/add-dir` hinzu oder entfernen Sie die Einstellung.
* **Nein, und beim nächsten Mal erneut fragen**: Der Lesezugriff wird verweigert, und beim nächsten Lesezugriff außerhalb der Arbeitsverzeichnisse wird erneut nachgefragt
* **Ja, aber beim nächsten Mal erneut fragen**: Der Lesezugriff läuft, nichts wird gespeichert, und beim nächsten Lesezugriff außerhalb der Arbeitsverzeichnisse wird erneut nachgefragt
Grenzen, die Sie in der Konversation angeben
Der Klassifikator behandelt Grenzen, die Sie in der Konversation angeben, als Blockiersignal. Wenn Sie Claude sagen „nicht pushen“ oder „warte mit dem Deployment, bis ich es überprüft habe“, blockiert der Klassifikator passende Aktionen, auch wenn die Standardregeln sie erlauben würden. Eine Grenze bleibt in Kraft, bis Sie sie in einer späteren Nachricht aufheben. Claudes eigene Einschätzung, dass eine Bedingung erfüllt wurde, hebt sie nicht auf.
Grenzen werden nicht als Regeln gespeichert. Der Klassifikator liest sie bei jeder Prüfung erneut aus dem Transkript, daher kann eine Grenze verloren gehen, wenn die [Kontextkomprimierung](/docs/de/costs#reduce-token-usage) die Nachricht entfernt, in der sie angegeben wurde. Für eine feste Garantie fügen Sie stattdessen eine [Deny-Regel](/docs/de/permissions#permission-rule-syntax) hinzu.
Genehmigungen, die Sie in der Konversation angeben
Wenn Sie Claude sagen, dass eine blockierte Aktion erlaubt ist, liest der Klassifikator das als Ihre Genehmigung und kann die Blockierung aufheben. Wie Sie es formuliert haben, entscheidet, ob die Aktion ausgeführt wird und wie weit die Genehmigung reicht:
* **Benennen Sie die Aktion und ihre Einzelheiten**: Ihre Nachricht muss die Aktion und das konkrete Detail benennen, das sie gefährlich macht, etwa den Branch eines Force Push. Das Verb allein zu nennen, hebt nichts auf, daher lässt „du kannst force-pushen“ die Blockierung bestehen.
* **Rechnen Sie damit, dass sie eine Aktion abdeckt**: Eine Genehmigung deckt die destruktive Aktion ab, die Sie benannt haben, daher wird eine spätere Aktion erneut blockiert, es sei denn, Sie haben die Genehmigung als dauerhaft erteilt. Um ein wiederkehrendes Muster nicht mehr Aktion für Aktion genehmigen zu müssen, fügen Sie es zu [`autoMode.allow`](/docs/de/auto-mode-config#override-the-block-and-allow-rules) hinzu.
* **Einige Blockierungen bleiben bestehen**: [Die Rangfolge des Klassifikators](/docs/de/auto-mode-config#override-the-block-and-allow-rules) legt fest, welche Blockierungen Ihre Genehmigung erreichen kann. Um einen Schritt auszuführen, den sie nicht freigibt, [verlassen Sie den Auto-Modus](#switch-permission-modes) und beantworten Sie die Berechtigungsabfrage.
Wenn der Auto-Modus zurückfällt
Wenn der Auto-Modus die Aktionen Ihrer Sitzung nicht genehmigen kann, hängt das Weitere vom Fall ab:
* **Eine blockierte Aktion**: Claude Code zeigt eine Benachrichtigung und listet die Aktion in `/permissions` auf der Registerkarte **Recently denied** auf, wo Sie `r` drücken können, um sie mit einer manuellen Genehmigung erneut zu versuchen.
* **Wiederholte Blockierungen**: Wenn der Klassifikator eine Aktion 3 Mal hintereinander oder insgesamt 20 Mal blockiert, pausiert der Auto-Modus und Claude Code fragt wieder nach. Das Genehmigen der abgefragten Aktion setzt den Auto-Modus fort. Siehe [Schwellenwerte für wiederholte Blockierungen](#repeated-block-thresholds) für die Zählung der Blockierungen.
* **Kein Urteil vom Klassifikator**: Wenn eine vom Auto-Modus getrennte Sicherheitsprüfung die Anfrage des Klassifikators selbst ablehnt oder die Antwort des Klassifikators nicht geparst werden kann, verweigert Claude Code die Aktion ohne Benachrichtigung und ohne Eintrag unter **Recently denied**. Siehe [Auto-Modus kann die Sicherheit einer Aktion nicht bestimmen](/docs/de/errors#auto-mode-cannot-determine-the-safety-of-an-action) für die Meldung, die jeder Fall zeigt, und was zu tun ist.
* **Kein Urteil vom Server**: Bei [serverseitiger Klassifikatorüberprüfung](#server-side-classifier-review) verweigert Claude Code eine Aktion, für die der Server kein Urteil abgibt, und beendet den Turn nach zehn Antworten in Folge ohne Urteil. Siehe [Der Server hat kein Sicherheitsurteil zurückgegeben](/docs/de/errors#the-server-returned-no-safety-verdict).
* **Ein Moduswechsel während einer Prüfung**: Wenn Sie den Berechtigungsmodus wechseln, während eine Klassifikatorprüfung aussteht, verwirft Claude Code ein Urteil, das der neue Modus nicht angefordert hätte. Sie werden stattdessen um Genehmigung gebeten, oder die Aktion wird im [`dontAsk`-Modus](#allow-only-pre-approved-tools-with-dontask-mode) automatisch verweigert.
Schwellenwerte für wiederholte Blockierungen
Die Schwellenwerte von 3 Blockierungen hintereinander und 20 Blockierungen insgesamt sind nicht konfigurierbar. Der Gesamtzähler bleibt für die Sitzung bestehen und wird nur zurückgesetzt, wenn sein eigenes Limit einen Fallback auslöst. Claude Code zählt eine Verweigerung für keinen der beiden Schwellenwerte, wenn eine vom Auto-Modus getrennte Sicherheitsprüfung die Anfrage des Klassifikators selbst ablehnt.
Ein [nicht-interaktiver](/docs/de/headless) `-p`-Lauf ohne [`--permission-prompt-tool`](/docs/de/cli-reference#cli-flags) hat keine Abfrage, auf die er zurückfallen kann. Wenn wiederholte Blockierungen einen Schwellenwert erreichen, wird die Aktion nicht ausgeführt und Claude arbeitet weiter. Claude Code beendet den Lauf nicht.
Wiederholte Blockierungen bedeuten in der Regel, dass dem Klassifikator Kontext über Ihre Infrastruktur fehlt. Verwenden Sie `/feedback`, um Fehlalarme zu melden, oder lassen Sie einen Administrator [vertrauenswürdige Infrastruktur konfigurieren](/docs/de/auto-mode-config).
Wie der Auto-Modus Aktionen bewertet
Die folgenden Abschnitte behandeln die Reihenfolge, in der Claude Code eine Aktion bewertet, wie der Klassifikator die Arbeit von Subagenten überprüft und was Klassifikatoraufrufe an Kosten und Latenz verursachen.
Jede Aktion durchläuft eine feste Entscheidungsreihenfolge. Der erste passende Schritt gewinnt:
1. Aktionen, die Ihren [Allow-, Ask- oder Deny-Regeln](/docs/de/permissions#manage-permissions) entsprechen, werden sofort entschieden, mit diesen Ausnahmen:
* Schreibvorgänge in [geschützte Pfade](#protected-paths) werden an den Klassifikator weitergeleitet, auch wenn eine Allow-Regel zutrifft. Wenn der geschützte Pfad die Datei ist, auf die eine per Symlink verknüpfte Einstellungsdatei verweist, kann der Schreibvorgang Sie stattdessen fragen, wie in der Liste der [geschützten Pfade](#protected-paths) beschrieben
* Keine Allow-Regel genehmigt `rm`- und `rmdir`-Löschungen, die auf einen [kritischen Pfad](#critical-paths) abzielen
* MCP-Tools, die mit [`requiresUserInteraction`](/docs/de/mcp#require-approval-for-a-specific-tool) gekennzeichnet sind, fragen Sie direkt, auch wenn eine Allow-Regel zutrifft, und dasselbe gilt für Konnektor-Tools, [die Ihre Organisation auf `ask` gesetzt hat](/docs/de/mcp#organization-controls-on-connector-tools), in Sitzungen, in denen diese Einstellung Claude Code erreicht
* Ein Shell-Befehl, der [pro Befehl erlaubte Domains](/docs/de/sandboxing#per-command-allowed-domains-in-auto-mode) mitführt, wird ebenfalls an den Klassifikator weitergeleitet, auch wenn eine Allow-Regel zutrifft, weil eine Regel den Befehl genehmigt, nicht seine Hosts
* Ask-Regeln, die auf den Inhalt eines Befehls abgleichen, wie `Bash(git push *)`, fallen auf eine Berechtigungsabfrage zurück
* Ein Schreibvorgang, den die [Symlink-Prüfung](/docs/de/permissions#symlinks) zu einem geschützten Pfad auflöst, fragt Sie, wenn der von Claude angeforderte Pfad selbst nicht geschützt ist
* Ein Lesezugriff auf einen [Netzwerkpfad](/docs/de/permissions#network-paths) fragt Sie, auch wenn eine Allow-Regel zutrifft
2. Nur lesende Aktionen und Dateibearbeitungen in Ihrem Arbeitsverzeichnis werden automatisch genehmigt, außer Schreibvorgängen in [geschützte Pfade](#protected-paths) und [dem ersten Lesezugriff außerhalb der Arbeitsverzeichnisse](#first-read-outside-the-working-directories), bei denen Sie gefragt werden
* In einer Sitzung mit [serverseitiger Klassifikatorüberprüfung](#server-side-classifier-review) warten nur lesende und [in einer Sandbox ausgeführte](/docs/de/sandboxing#sandbox-modes) Shell-Befehle auf diese Überprüfung und werden blockiert, wenn sie sie kennzeichnet
* Ein Schreibvorgang innerhalb Ihres Arbeitsverzeichnisses, den die [Symlink-Prüfung](/docs/de/permissions#symlinks) zu einem Ort außerhalb davon auflöst, fragt Sie
* Wenn Claude ein [Artefakt liest, das jemand anderes erstellt hat](/docs/de/artifacts#read-an-artifact-shared-with-you), gelten die in jenem Abschnitt aufgeführten Genehmigungsfälle
* Ein Lesezugriff auf einen [Netzwerkpfad](/docs/de/permissions#network-paths) fragt Sie
3. Alles andere geht an den Klassifikator, abgesehen von [Löschungen kritischer Pfade](#critical-paths) bei deren Standardbehandlung. Die Konnektor-Tools und `requiresUserInteraction`-MCP-Tools, die Sie in Schritt 1 direkt fragen, erreichen den Klassifikator ebenfalls nie, sodass weder eine von der Organisation verlangte Genehmigung noch ein Zustimmungsschritt automatisch genehmigt wird
4. Wenn der Klassifikator blockiert, erhält Claude den Grund. In den meisten Sitzungen nennt der Grund die Regel, die der Klassifikator angewendet hat, etwa `[Data Exfiltration]`, statt einer ausformulierten Erklärung; siehe [Verweigerungen überprüfen](/docs/de/auto-mode-config#review-denials)
Ein von Ihnen installierter [Mod](/docs/de/plugins/mods/overview), der `tool.check` verarbeitet, kann eine Aktion vor Schritt 3 genehmigen, und der Klassifikator prüft keine Aktion, die der Mod genehmigt. Siehe [Berechtigungen mit Hooks erweitern](/docs/de/permissions#extend-permissions-with-hooks).
In der VS Code-Erweiterung hängt die Art, wie Browser-Aktionen von [Claude in Chrome](/docs/de/chrome) genehmigt werden, davon ab, wie die Sitzung mit dem Browser verbunden ist: siehe [Berechtigungsabfragen in VS Code-Sitzungen](/docs/de/chrome#permission-prompts-in-vs-code-sessions).
Beim Wechsel in den Auto-Modus werden breite Allow-Regeln, die beliebige Codeausführung gewähren, verworfen:
* Pauschale Regeln `Bash(*)` oder `PowerShell(*)`
* Interpreter mit Wildcard wie `Bash(python*)`
* Run-Befehle von Paketmanagern
* `Agent`-Allow-Regeln
* [`Monitor`](/docs/de/tools-reference#monitor-tool)-Allow-Regeln, weil Claude Code Monitor-Befehle über die Shell ausführt
Enge Regeln wie `Bash(npm test)` bleiben in Kraft. Claude Code stellt die verworfenen Regeln wieder her, wenn Sie den Auto-Modus verlassen. Vor v2.1.236 ließ Claude Code `Monitor`-Allow-Regeln im Auto-Modus in Kraft, sodass eine Regel, die das gesamte Tool abdeckte, Monitor-Befehle ohne Klassifikatorüberprüfung genehmigte.
Claude Code führt außerdem selbst `git status` vor einem Befehl aus, der nicht committete Arbeit verwerfen würde, wie `git reset --hard` oder `rm -rf`, und zeigt dem Klassifikator, ob gestagte, geänderte oder nicht verfolgte Arbeit vorhanden ist. Claude Code meldet nicht verfolgte Dateien in dieser Prüfung auch dann, wenn die Git-Konfiguration des Repositorys `status.showUntrackedFiles=no` setzt.
In den Klassifikatoranfragen, die Claude Code selbst sendet, sieht der Klassifikator Benutzernachrichten, Tool-Aufrufe außer nur lesenden Abfragen wie Dateilesevorgängen und Suchen sowie Ihren CLAUDE.md-Inhalt. Tool-Ergebnisse werden aus diesen Anfragen entfernt, sodass feindseliger Inhalt in einer Datei oder Webseite den Klassifikator nicht direkt manipulieren kann.
Sie können das Ergebnis eines Aufrufs mit dem [`classifierContext`-Feld eines PostToolUse-Hooks](/docs/de/hooks#annotate-a-result-for-the-auto-mode-classifier) annotieren, das der Klassifikator als von der Anwendung bereitgestellten Kontext liest. Das Feld erfordert Claude Code v2.1.236 oder später.
Eine separate serverseitige Prüfung scannt eingehende Tool-Ergebnisse und kennzeichnet verdächtige Inhalte, bevor Claude sie liest. Mehr darüber, wie diese Ebenen zusammenwirken, erfahren Sie in der [Ankündigung des Auto-Modus](https://claude.com/blog/auto-mode) und im [technischen Deep Dive](https://www.anthropic.com/engineering/claude-code-auto-mode).
Der Klassifikator prüft die Arbeit von [Subagenten](/docs/de/sub-agents) an drei Punkten:
1. Bevor ein Subagent startet, wird die delegierte Aufgabenbeschreibung bewertet, sodass eine gefährlich aussehende Aufgabe bereits beim Starten blockiert wird.
2. Während der Subagent läuft, durchläuft jede seiner Aktionen dieselbe [Entscheidungsreihenfolge](#how-the-classifier-evaluates-actions) wie in der übergeordneten Sitzung, mit denselben Block- und Allow-Regeln. Ein `permissionMode` im Frontmatter des Subagenten wird ignoriert.
3. Wenn der Subagent fertig ist, überprüft der Klassifikator seine Arbeit und seinen Abschlussbericht, bevor die übergeordnete Sitzung den Bericht liest. Wenn der Klassifikator die Arbeit oder den Bericht des Subagenten kennzeichnet oder eine separate API-Sicherheitsprüfung die Überprüfung ablehnt, wird der Bericht dennoch zugestellt, jedoch mit vorangestellter Sicherheitswarnung. Wenn der Klassifikator für die Überprüfung nicht verfügbar ist, wird der Bericht mit dem Hinweis zugestellt, die Arbeit des Subagenten zu überprüfen, bevor darauf aufgebaut wird.
Der Klassifikator läuft standardmäßig auf Claude Sonnet 5 statt auf dem Modell, das Sie mit `/model` ausgewählt haben. Ein Klassifikatormodell, das Anthropic serverseitig konfiguriert, hat Vorrang vor diesem Standard. Wenn das Modell Ihrer Sitzung Claude Sonnet 4.6 ist oder wenn [`availableModels`](/docs/de/model-config#restrict-model-selection) Sonnet 5 ausschließt, läuft der Klassifikator stattdessen auf dem Modell der Sitzung oder auf einem Opus-Modell, wenn die Sitzung auf einem [Fable-Modell](/docs/de/model-config#work-with-fable) läuft. Bei anderen Anbietern als der Anthropic API ist dieser Opus-Fallback das Modell, das Sie in [`ANTHROPIC_DEFAULT_OPUS_MODEL`](/docs/de/model-config#environment-variables) festgelegt haben, oder Opus 5, wenn Sie keines festgelegt haben.
Die erste Auto-Modus-Anfrage der Sitzung validiert den Sonnet 5-Standard: Wenn die Anfrage erfolgreich ist, bleibt Sonnet 5 das Klassifikatormodell der Sitzung, und wenn sie fehlschlägt, weil das Modell nicht verfügbar ist, verwendet die Sitzung stattdessen den Fallback.
Bei Enterprise-Plänen und bei Konten, die die Claude API, [Claude Platform auf AWS](/docs/de/claude-platform-on-aws), Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry verwenden, zählen Klassifikatoraufrufe zu Ihrer Token-Nutzung. Jede Prüfung sendet einen Teil des Transkripts plus die ausstehende Aktion und fügt vor der Ausführung einen Roundtrip hinzu. Lesezugriffe und Bearbeitungen im Arbeitsverzeichnis außerhalb geschützter Pfade überspringen den Klassifikator, daher entsteht der Overhead hauptsächlich durch Shell-Befehle und Netzwerkoperationen. Wenn der Server die Aktionen als Teil der Modellanfragen der Sitzung überprüft, gibt es keine separaten Klassifikatoraufrufe, die gezählt werden; siehe [Serverseitige Klassifikatorüberprüfung](#server-side-classifier-review).
Netzwerkzugriff in der Sandbox verursacht keine Klassifikatoranfragen pro Verbindung. Der Klassifikator beurteilt [die Hosts, die ein Befehl benennt](/docs/de/sandboxing#per-command-allowed-domains-in-auto-mode), zusammen mit dem Befehl in einer einzigen Überprüfung, und Claude Code prüft jede Verbindung anhand der genehmigten Liste, ohne den Klassifikator erneut aufzurufen.
Wenn Sie den `dontAsk`-Modus einstellen, lehnt Claude Code automatisch jeden Tool-Aufruf ab, der Sie sonst auffordern würde. Claude führt weiterhin Aktionen aus, die im Manual-Modus keine Genehmigung benötigen, wie z. B. Dateilesevorgänge in Ihren Arbeitsverzeichnissen und [schreibgeschützte Bash-Befehle](/docs/de/permissions#read-only-commands), sowie Aktionen, die Ihren `permissions.allow`-Regeln entsprechen, und Aufrufe, die von einem [PreToolUse-Hook](/docs/de/permissions#extend-permissions-with-hooks) genehmigt wurden. Verwenden Sie diesen Modus für CI-Pipelines oder eingeschränkte Umgebungen, in denen Sie vorab definieren, was Claude tun darf; die Sitzung wartet nie auf Eingaben. Die Statusleiste zeigt `⏵⏵ don't ask on`, während dieser Modus aktiv ist.
Claude Code lehnt Aufrufe ab, die Ihren expliziten [`ask`-Regeln](/docs/de/permissions#manage-permissions) entsprechen, anstatt bei Ihnen nachzufragen. Es lehnt auch das integrierte `AskUserQuestion`-Tool ab, selbst wenn Ihre Allow-Regeln damit übereinstimmen, und macht dasselbe mit Konnektor-Tools, [die Ihre Organisation auf `ask` gesetzt hat](/docs/de/mcp#organization-controls-on-connector-tools), in Sitzungen, in denen diese Einstellung Claude Code erreicht. Es lehnt MCP-Tools, die mit [`_meta["anthropic/requiresUserInteraction"]`](/docs/de/mcp#require-approval-for-a-specific-tool) gekennzeichnet sind, auf die gleiche Weise ab, da ihre Genehmigungskarte eine Antwort benötigt, die dieser Modus nie erfasst.
`rm`- und `rmdir`-Löschungen, die auf einen [kritischen Pfad](#critical-paths) abzielen, wie z. B. `rm -rf /` und `rm -rf ~`, werden abgelehnt, selbst wenn eine Allow-Regel damit übereinstimmt oder ein `PreToolUse`-Hook sie zulässt. Ein Lesevorgang von einem [Netzwerkpfad](/docs/de/permissions#network-paths) wird auf die gleiche Weise abgelehnt.
Cloud-Sitzungen auf [Claude Code im Web](/docs/de/claude-code-on-the-web) ignorieren `defaultMode: "dontAsk"`; siehe [bypassPermissions](#skip-all-checks-with-bypasspermissions-mode) für Details.
Stellen Sie es beim Start mit dem Flag ein:
```bash theme={null}
claude --permission-mode dontAsk
```
Alle Überprüfungen mit bypassPermissions-Modus überspringen
Der `bypassPermissions`-Modus deaktiviert Berechtigungsaufforderungen und Sicherheitsüberprüfungen, sodass Tool-Aufrufe sofort ausgeführt werden, einschließlich Schreibvorgänge in [geschützte Pfade](#protected-paths).
Bei den [Aktionen, die kein Modus automatisch genehmigt](#actions-no-mode-auto-approves), wird auch in diesem Modus weiterhin nachgefragt. Das Lesen des [öffentlichen Artefakts einer anderen Organisation](/docs/de/artifacts#read-an-artifact-shared-with-you) erfordert Ihre Genehmigung, und dieser Modus fragt nicht danach, daher kann Claude ein solches Artefakt nicht lesen. Die [Remove-Item in PowerShell](#remove-item-in-powershell) Verweigerungen gelten auch in diesem Modus.
Zwei [Cross-Session-Messaging](/docs/de/cross-session-messaging) Schutzmaßnahmen gelten weiterhin in diesem Modus und in interaktiven Terminal-Plan-Mode-Sitzungen, in denen Bypass-Berechtigungen verfügbar sind:
* Die [`isolatePeerMachines`](/docs/de/settings-reference#isolatepeermachines) Genehmigungsaufforderung für Nachrichten an Ihre Sitzungen über diese Maschine hinaus wird weiterhin angezeigt.
* Wenn kein [`crossSessionInbound`](/docs/de/cross-session-messaging#control-inbound-messages) Wert zutrifft, hält Claude Code eine eingehende Nachricht von einer anderen Ihrer Sitzungen für Ihre Genehmigung und liefert ohne Fragen nur, wenn die sendende Sitzung sich selbst als auch Berechtigungsaufforderungen umgehend identifiziert. Wenn Sie den Berechtigungsmodus verlassen, während Nachrichten gehalten werden, wendet Claude Code die eingehenden Regeln erneut an und liefert jede gehaltene Nachricht, die sie jetzt akzeptieren.
In interaktiven Terminal-Sitzungen mit verfügbaren Bypass-Berechtigungen erzwingt Claude Code auch nicht [Plan-Mode's](#analyze-before-you-edit-with-plan-mode) Blockierungen. Claude wird immer noch angewiesen, ohne Bearbeitung zu planen, aber ein Dateibearbeitungs- oder Shell-Befehl, den es während der Planung versucht, läuft ohne Aufforderung. Explizite [Ask-Regeln](/docs/de/permissions#manage-permissions) und `rm` und `rmdir` Löschungen, die auf einen [kritischen Pfad](#critical-paths) abzielen, fordern weiterhin auf.
Der Plan-Mode behält seine Blockierungen überall dort bei, wo Claude Code ohne interaktives Terminal läuft, einschließlich [nicht-interaktiver Ausführungen](/docs/de/headless) mit `-p`, [Agent SDK](/docs/de/agent-sdk/permissions#plan-mode-plan) Sitzungen und Unterhaltungen im Chat-Panel der [VS Code-Erweiterung](/docs/de/vs-code). Dort macht `--allow-dangerously-skip-permissions` `bypassPermissions` später auswählbar.
Verwenden Sie diesen Modus nur in isolierten Umgebungen wie Containern, VMs oder Dev-Containern ohne Internetzugang, in denen Claude Code Ihr Host-System nicht beschädigen kann.
Sie können `bypassPermissions` nicht aus einer Sitzung eingeben, die Sie ohne ihn gestartet haben. Aktivieren Sie es beim Start mit [`permissions.defaultMode: "bypassPermissions"`](/docs/de/settings-reference#permissions-defaultmode) oder mit einem aktivierenden Flag:
```bash theme={null}
claude --permission-mode bypassPermissions
```
Das Flag `--dangerously-skip-permissions` ist gleichwertig.
Claude Code verweigert `bypassPermissions` in einer Sitzung, die Sie mit [`--restricted`](/docs/de/cli-reference#cli-flags) starten. `--restricted` erfordert Claude Code v2.1.248 oder später.
Das erste Mal, wenn Sie eine interaktive Sitzung mit diesem Modus aktiviert starten, zeigt Claude Code einen Warnungsdialog, der Sie auffordert, Verantwortung für Aktionen ohne Berechtigungsprüfungen zu übernehmen:
* **Wenn Sie akzeptieren**: Claude Code setzt `skipDangerousModePermissionPrompt` auf `true` in `~/.claude/settings.json`, sodass spätere Sitzungen den Dialog überspringen. Um den Dialog erneut zu sehen, entfernen Sie den Schlüssel aus dieser Datei oder setzen Sie ihn auf `false`. Die [`skipDangerousModePermissionPrompt` Referenz](/docs/de/settings-reference#skipdangerousmodepermissionprompt) listet die anderen Einstellungsdateien auf, in denen Sie oder Ihre Organisation ihn setzen können.
* **Wenn Sie ablehnen**: Claude Code wird beendet.
Im [nicht interaktiven Modus](/docs/de/headless) wird kein Dialog angezeigt. Eine [Hintergrund-Sitzung](/docs/de/agent-view) berücksichtigt Ihre Zustimmung, wenn diese in Benutzer- oder verwalteten Einstellungen gespeichert ist:
* Ohne gespeicherte Zustimmung wird `claude --bg --permission-mode bypassPermissions` verweigert, bis Sie den Dialog in einer interaktiven Sitzung akzeptieren.
* Wenn `skipDangerousModePermissionPrompt` nur in `.claude/settings.local.json` gesetzt ist, startet die Hintergrund-Sitzung, ignoriert die Bypass-Anfrage und heftet den Hinweis `Bypass permissions was requested at launch and ignored · if that was you, ~/.claude/settings.json needs "skipDangerousModePermissionPrompt": true` an. Damit der Bypass berücksichtigt wird, fügen Sie diesen Schlüssel zu `~/.claude/settings.json` hinzu und starten Sie dann eine neue Hintergrund-Sitzung.
Auf Linux und macOS weigert sich Claude Code, in diesem Modus zu starten, wenn es als Root oder unter `sudo` ausgeführt wird:
```text theme={null}
--dangerously-skip-permissions cannot be used with root/sudo privileges for security reasons
```
Die Überprüfung wird automatisch in einer erkannten Sandbox übersprungen. Um autonom in einem Container zu laufen, verwenden Sie die [Dev-Container](/docs/de/devcontainer) Konfiguration, die Claude Code als Nicht-Root-Benutzer ausführt.
[Cloud-Sitzungen](/docs/de/claude-code-on-the-web) berücksichtigen `defaultMode: "bypassPermissions"` oder `"dontAsk"` aus Ihren Einstellungsdateien nicht, daher können die eingecheckten Einstellungen eines Repositorys keine Cloud-Sitzung im Bypass-Permissions-Modus starten. Die Einstellung wird stillschweigend ignoriert und die Sitzung startet im Berechtigungsmodus, der im Modusmenü angezeigt wird. Siehe [Berechtigungsmodi wechseln](#switch-permission-modes), welche Modi Cloud-Sitzungen bieten.
`bypassPermissions` bietet keinen Schutz vor Prompt-Injection oder unbeabsichtigten Aktionen. Verwenden Sie stattdessen den [Auto-Modus](#eliminate-prompts-with-auto-mode) für Hintergrund-Sicherheitsüberprüfungen mit deutlich weniger Berechtigungsaufforderungen. Administratoren können diesen Modus blockieren, indem sie `permissions.disableBypassPermissionsMode` auf `"disable"` in [verwalteten Einstellungen](/docs/de/managed-settings) setzen.
Geschützte Pfade
Schreibvorgänge in eine kleine Anzahl von Pfaden werden niemals automatisch genehmigt, außer im `bypassPermissions`-Modus und in interaktiven Terminal-Sitzungen im Plan-Modus mit [verfügbaren Bypass-Berechtigungen](#skip-all-checks-with-bypasspermissions-mode). Dies verhindert versehentliche Beschädigungen des Repository-Status und der eigenen Konfiguration von Claude.
| Modus | Schreibvorgänge in geschützten Pfaden |
| :- | :- |
| `default`, `acceptEdits` | Abgefragt |
| `plan` | Erlaubt in interaktiven Terminal-Sitzungen mit [verfügbaren Bypass-Berechtigungen](#skip-all-checks-with-bypasspermissions-mode). Andernfalls zum Klassifizierer geleitet, wenn [Auto-Modus](#eliminate-prompts-with-auto-mode) während der Planung verfügbar ist, und abgefragt, wenn nicht |
| `auto` | Zum Klassifizierer geleitet |
| `dontAsk` | Verweigert |
| `bypassPermissions` | Erlaubt |
In einer Sitzung, die mit [`--restricted`](/docs/de/cli-reference#cli-flags) gestartet wurde, was Claude Code v2.1.248 oder später erfordert, kann der Klassifizierer Schreibvorgänge in geschützten Pfaden nicht genehmigen.
In den Modi, die Schreibvorgänge in geschützten Pfaden zum Klassifizierer leiten, fordert ein Schreibvorgang, den die [Symlink-Prüfung](/docs/de/permissions#symlinks) in einen geschützten Pfad auflöst, Sie auf, wenn der Pfad, den Claude angefordert hat, selbst nicht geschützt ist.
[`permissions.allow`](/docs/de/permissions#manage-permissions) Regeln in Einstellungsdateien genehmigen Schreibvorgänge in geschützten Pfaden nicht im Voraus. Die Sicherheitsprüfung wird ausgeführt, bevor Claude Code die Allow-Regeln aus den Einstellungen auswertet, daher ändert ein Eintrag wie `Edit(.claude/**)` in `~/.claude/settings.json` oder `.claude/settings.json` das Ergebnis pro Modus in der obigen Tabelle nicht. In Modi, die abfragen, bietet die Eingabeaufforderung für einen Schreibvorgang in den `.claude/`-Ordner des Projekts oder in `~/.claude/` eine dieser sitzungsbezogenen Optionen an:
* Für den `.claude/`-Ordner des Projekts: **Ja, und Claude darf Dateien in diesem `.claude`-Ordner des Projekts für diese Sitzung bearbeiten**
* Für `~/.claude/`: **Ja, und Claude darf Dateien in seinem `~/.claude/`-Ordner für diese Sitzung bearbeiten**
Geschützte Verzeichnisse:
* `.git`
* `.config/git`
* `.vscode`
* `.idea`
* `.husky`
* `.cargo`
* `.devcontainer`
* `.yarn`
* `.mvn`
* `.claude`, mit einigen Ausnahmen, beispielsweise:
* Die eigenen Git-Worktrees von Claude unter `.claude/worktrees/`
* Die eigenen Plandateien der aktuellen Sitzung in `~/.claude/plans/` oder in dem von Ihnen festgelegten [`plansDirectory`](/docs/de/settings-reference#plansdirectory)
* Das eigene Scratch-Verzeichnis einer [Hintergrundsitzung](/docs/de/agent-view#where-state-is-stored) unter `~/.claude/jobs//tmp/`
* Markdown-Dateien im [Auto-Memory](/docs/de/memory#storage-location)-Verzeichnis des Projekts, beispielsweise `~/.claude/projects//memory/`, in einer Sitzung, die ohne `--restricted` gestartet wurde
* Markdown-Dateien in einem [Subagenten-Memory](/docs/de/sub-agents#enable-persistent-memory)-Verzeichnis, beispielsweise `.claude/agent-memory/`, in einer Sitzung, die ohne `--restricted` gestartet wurde
* Ein Verzeichnis, das Sie mit [`--plugin-dir`](/docs/de/plugins/mods/create#change-a-mod-with-claude) geladen haben, da Claude Code den Code eines Mods von dort aus neu lädt und ausführt, wenn sich eine Datei ändert
Geschützte Dateien:
* `.gitconfig`, `.gitmodules`
* `.bashrc`, `.bash_profile`, `.bash_login`, `.bash_aliases`, `.bash_logout`, `.zshrc`, `.zprofile`, `.zshenv`, `.zlogin`, `.zlogout`, `.profile`, `.envrc`
* `.npmrc`, `.yarnrc`, `.yarnrc.yml`, `.pnp.cjs`, `.pnp.loader.mjs`, `.pnpmfile.cjs`, `bunfig.toml`, `.bunfig.toml`
* `.bazelrc`, `.bazelversion`, `.bazeliskrc`
* `.pre-commit-config.yaml`, `lefthook.yml`, `lefthook.yaml`, `.lefthook.yml`, `.lefthook.yaml`
* `gradle-wrapper.properties`, `maven-wrapper.properties`
* `.devcontainer.json`
* `.ripgreprc`, `pyrightconfig.json`
* `.mcp.json`, `.claude.json`
* Die Datei, auf die Ihre Benutzer-, Projekt- oder lokale [Einstellungsdatei](/docs/de/settings#settings-files-and-who-they-affect) verweist, wenn die Einstellungsdatei selbst ein symbolischer Link ist, beispielsweise in ein Dotfiles-Repository. In den Modi, die Schreibvorgänge in geschützten Pfaden zum Klassifikator leiten, fragt ein Schreibvorgang in diese Datei stattdessen bei Ihnen nach, selbst wenn eine Allow-Regel zutrifft. Ist der eigene Pfad der Datei zugleich der Pfad einer Einstellungsdatei, beispielsweise `.claude/settings.json` in einem anderen Ordner, wird der Schreibvorgang wie andere Schreibvorgänge in geschützten Pfaden zum Klassifikator geleitet
Kritische Pfade
Kritische Pfade sind die Verzeichnisse, die Claude Code vor `rm`- und `rmdir`-Befehlen schützt, wie das Dateisystem-Root, Ihr Home-Verzeichnis und Ihr Arbeitsverzeichnis.
Claude Code lässt niemals zu, dass eine [`permissions.allow`](/docs/de/permissions#manage-permissions)-Regel oder ein [`PreToolUse`-Hook](/docs/de/permissions#extend-permissions-with-hooks), der `"allow"` zurückgibt, einen `rm`- oder `rmdir`-Befehl genehmigt, der auf einen kritischen Pfad abzielt, auch nicht in Modi, die andere Eingabeaufforderungen überspringen. Dieser Schutzschalter schützt vor Modellfehlern. Eine entsprechende Deny-Regel blockiert den Befehl dennoch vollständig.
Was stattdessen geschieht, [hängt von Ihrem Berechtigungsmodus ab](#critical-path-removals-in-each-permission-mode). `Remove-Item` und die `cmd`-Entfernungs-Built-ins haben ihre eigenen Überprüfungen, die in [Remove-Item in PowerShell](#remove-item-in-powershell) behandelt werden.
Welche Pfade sind kritisch
Claude Code behandelt ein `rm`- oder `rmdir`-Ziel als kritischen Pfad, wenn es eines der folgenden ist:
* Das Dateisystem-Root
* Verzeichnisse der obersten Ebene, d. h. alle direkten Unterordner des Root, wie `/usr`, `/etc` oder `/data`
* Ihr Home-Verzeichnis. Unter Windows zählt auch sein 8.3-Kurzname, wie `C:\Users\LONGNA~1`
* Windows-Laufwerk-Roots und ihre Verzeichnisse der obersten Ebene, wie `C:\` und `C:\Windows`. Schreibweisen wie `\\?\C:\` und `\\localhost\C$` zählen als `C:\`
* Ihr Arbeitsverzeichnis und seine übergeordneten Verzeichnisse
* Ihre zusätzlichen Arbeitsverzeichnisse und ihre übergeordneten Verzeichnisse, aber nur wenn die Entfernung ein Glob unter einem von ihnen ist, wie `rm -rf /*`. `rm -rf ` im Verzeichnis selbst löst diese Überprüfung nicht aus
Die Überprüfungen des 8.3-Kurznamens des Home-Verzeichnisses sowie der Schreibweisen `\\?\C:\` und `\\localhost\C$` erfordern Claude Code v2.1.292 oder später.
Andere Ziele, die als kritische Pfade zählen
Claude Code behandelt auch die folgenden `rm`- und `rmdir`-Ziele als kritische Pfade. Die letzte Spalte sagt, warum jedes zählt.
| Ziel | Beispiel | Warum es zählt |
| :- | :- | :- |
| Ein Glob oder nachgestellter Schrägstrich direkt unter einer Shell-Variable | `rm -rf "$DIR"/*` | Der Befehl wird zu einer Entfernung vom Dateisystem-Root, wenn die Variable leer ist |
| Die gleiche Form unter einem Positionsparameter wie `$1` oder `$@`, wenn nichts im Befehl ihm einen Wert gibt | `rm -rf "$1"/*` | Der Befehl erweitert sich zu einer Entfernung vom Root |
| Eine Shell-Variable gefolgt von einem häufigen Namen eines Verzeichnisses der obersten Ebene, wie `mnt`, `tmp`, `usr` oder `Users` | `rm -rf "$TMPDIR/mnt"` | Wenn die Variable leer erweitert wird, entfernt der Befehl `/mnt` |
| Eine Variable, die derselbe Befehl aus einer Verzeichnis-Druck-Ersetzung zuweist, wie `$(pwd)` oder `$(git rev-parse --show-toplevel)` | `D=$(pwd); rm -rf "$D"` | Der Wert kann Ihr Arbeitsverzeichnis oder Repository-Root benennen |
| Ein Ziel, das nur die Ausgabe einer Befehlsersetzung ist, wenn der `rm` rekursiv ist | `rm -rf "$(pwd)"` | Claude Code kann das Ziel nicht vor der Ausführung des Befehls überprüfen |
| Eine nachgestellte Befehlsersetzung nach einem kritischen Pfad | `rm -rf ~/$(cmd)` | Claude Code überprüft den Pfad, der bleiben würde, wenn die Ersetzung leer erweitert wird, hier Ihr Home-Verzeichnis |
| Ein Ziel, das nur Backslashes ist | `rm -rf "\\"` | Git Bash unter Windows liest einen einzelnen Backslash als Root des aktuellen Laufwerks, daher gilt die Überprüfung auf jeder Plattform |
| Ein Windows-Pfad, der ein Volume per GUID statt per Laufwerksbuchstabe benennt | `rm -rf '\\?\Volume{GUID}\work\build'` | Der Pfad gibt nicht an, auf welchem Laufwerk er liegt, daher könnte er ein kritischer Pfad sein. Erfordert Claude Code v2.1.292 oder später |
| Einige Ziele, die auf `/*` oder `/*/` enden | `rm -rf logs/*/*`, `rm -rf logs/*/`, `cd logs && rm -rf a/*` | Claude Code kann vor der Ausführung des Befehls nicht erkennen, welche Verzeichnisse sie erreichen |
Um die Überprüfung auf einem Ziel auszuschalten, das nur Befehlsersetzungsausgabe ist, setzen Sie [`CLAUDE_CODE_DISABLE_SUBSTITUTION_RM_PROMPT=1`](/docs/de/env-vars#variables) in der Umgebung, die Claude Code startet.
Entfernungen in verschachtelten Befehlen und Inline-Skripten
Claude Code schaut auch in diese Konstrukte:
* **Verschachtelte Befehle**: eine Subshell mit `(...)`, eine Brace-Gruppe mit `{ ...; }`, Befehlsersetzung mit `$(...)` oder Backticks, oder Prozessersetzung mit `<(...)`. Claude Code findet eine Entfernung eines kritischen Pfads, ob sie sich in der verschachtelten Form befindet, wie in `(rm -rf ~)` oder `echo "$(rm -rf ~)"`, oder anderswo im gleichen Befehl.
* **Inline-Skripte**: ein Skript, das mit `-c` an `sh`, `bash`, `zsh` oder eine ähnliche POSIX-Shell übergeben wird, wie in `bash -c 'rm -rf ~'`.
* Wenn das Skript in doppelte Anführungszeichen gesetzt ist, erweitert die aufrufende Shell seine Variablen, bevor die innere Shell das Skript erhält. In `find . -name '*.tmp' -exec sh -c "rm -rf \"$1\"/*" _ {} \;` erweitert sich der Befehl zu einer Entfernung vom Dateisystem-Root einmal pro Treffer, und Claude Code behandelt es als Entfernung eines kritischen Pfads.
* Ein einfach angeführtes Skript, das `$1` an einen echten Wert bindet, wie `sh -c 'rm -rf "$1"/*' _ {}` es tut, wird nicht gekennzeichnet.
Um die Überprüfung für einen kritischen Pfad auszuschalten, der direkt in einem `-c`-Skript eingegeben wird, wie `~`, setzen Sie [`CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT=1`](/docs/de/env-vars#variables) in der Umgebung, die Claude Code startet.
Einen gekennzeichneten Befehl umschreiben
Wie man einen Befehl umschreibt, damit er die Überprüfung besteht, hängt davon ab, welche der [anderen Ziele](#other-targets-that-count-as-critical-paths) er verwendet:
* **Ein Glob oder nachgestellter Schrägstrich unter einer Variable wie `$DIR`**: schützen Sie jede Erweiterung, damit die Shell mit einem Fehler stoppt, wenn die Variable nicht gesetzt oder leer ist, wie in `rm -rf "${DIR:?}"/*`, oder verwenden Sie einen literalen Pfad. Eine Entfernung, deren Erweiterungen auf diese Weise geschützt sind, besteht diese Überprüfung, daher wird sie im `bypassPermissions`-Modus ohne Eingabeaufforderung ausgeführt, es sei denn, eine andere [kritische Pfad](#critical-paths)-Überprüfung kennzeichnet sie.
* **Ein Glob oder nachgestellter Schrägstrich unter einer Variable, die normalerweise gesetzt ist, wie `$HOME`**: verwenden Sie einen literalen Pfad.
* **Eine Variable, die aus einer Verzeichnis-Druck-Ersetzung zugewiesen wird**: verwenden Sie einen literalen Pfad. Ein `"${D:?}"`-Schutz löscht diese Überprüfung nicht, da die Variable nicht leer ist.
* **Ein Ziel, das nur Befehlsersetzungsausgabe ist**: führen Sie die Ersetzung zuerst selbst aus, dann entfernen Sie die literalen Pfade, die sie ausgibt. Die Eingabeaufforderung teilt Claude mit, dasselbe zu tun.
Für einen Glob oder nachgestellten Schrägstrich unter einer Variable benennt die Eingabeaufforderung den gekennzeichneten `rm` und sagt, wie man ihn umschreibt, damit die Überprüfung besteht.
Entfernungen kritischer Pfade in jedem Berechtigungsmodus
Was Claude Code mit einer Entfernung eines kritischen Pfads tut, hängt von Ihrem Berechtigungsmodus ab:
| Modus | Ergebnis |
| :- | :- |
| `default`, `acceptEdits` | Fordert Sie auf, dies zu genehmigen |
| `plan` | Fordert Sie auf, dies zu genehmigen. Wenn [der Klassifizierer Befehle während der Planung überprüft](#analyze-before-you-edit-with-plan-mode) und keine Bypass-Berechtigungen verfügbar sind, behandelt er dies wie im `auto`-Modus |
| `auto` | Fordert Sie auf, dies im Terminal zu genehmigen, mit einem [Zeitlimit](#time-limits-and-denials-in-auto-and-bypasspermissions-modes). Anderswo lehnt es ab |
| `dontAsk` | Lehnt es ab |
| `bypassPermissions` | Fordert Sie auf, dies zu genehmigen, mit einem Zeitlimit im Terminal |
Wenn eine explizite [Ask-Regel](/docs/de/permissions#manage-permissions) dem Befehl entspricht, fordert Claude Code Sie stattdessen auf, auch im `auto`-Modus und ohne Zeitlimit. In Modi, die fragen, kann ein [`PermissionRequest`-Hook](/docs/de/hooks#permissionrequest) die Eingabeaufforderung beantworten.
Zeitlimits und Ablehnungen in auto- und bypassPermissions-Modi
In `auto`- und `bypassPermissions`-Modi zeigt die Terminal-Eingabeaufforderung für eine Entfernung eines kritischen Pfads einen Countdown von zwei Minuten:
* Wenn der Countdown abläuft, bevor Sie antworten, lehnt Claude Code den Befehl ab und teilt Claude mit, was stattdessen zu tun ist, damit eine unbeaufsichtigte Sitzung weiterarbeitet.
* Drücken Sie eine beliebige Taste, während die Eingabeaufforderung offen ist, um den Countdown zu stoppen und die Eingabeaufforderung warten zu lassen, bis Sie antworten.
* Nachdem drei dieser Eingabeaufforderungen in einer Sitzung unbeantwortet ablaufen, zeigt Claude Code sie nicht mehr an und lehnt weitere Entfernungen kritischer Pfade sofort ab. Das Senden einer neuen Nachricht setzt den Zähler zurück.
Im `auto`-Modus lehnt Claude Code den Befehl sofort ab, wenn es Ihnen keine Terminal-Eingabeaufforderung anzeigen kann, beispielsweise in [nicht-interaktiven Ausführungen](/docs/de/headless) mit `-p`, in [Agent SDK](/docs/de/agent-sdk/permissions)-Sitzungen und im Chat-Panel der VS Code-Erweiterung und der Desktop-App. Die Ablehnung teilt Claude mit, was es löschen wollte, und überlässt die Entfernung Ihnen.
Die Behandlung von `auto` und `bypassPermissions` erfordert Claude Code v2.1.281 oder später. Um dies auszuschalten, setzen Sie [`CLAUDE_CODE_DISABLE_DANGEROUS_RM_TIMEOUT=1`](/docs/de/env-vars#variables) in der Umgebung, die Claude Code startet. Im `auto`-Modus gehen Entfernungen kritischer Pfade dann stattdessen an den Klassifizierer, und im `bypassPermissions`-Modus hat die Eingabeaufforderung kein Zeitlimit.
Remove-Item in PowerShell
Wenn Sie das [PowerShell-Tool](/docs/de/tools-reference#powershell-tool) aktivieren, gibt Claude Code `Remove-Item` und den `cmd`-Built-ins `rd`, `rmdir`, `del` und `erase` ihre eigenen Überprüfungen, getrennt von der `rm`-Liste kritischer Pfade. Für `Remove-Item` hängt das Ergebnis vom Ziel ab, und der erste passende Fall gilt:
* **Systempfade**: das Dateisystem-Root und seine Verzeichnisse der obersten Ebene, Laufwerk-Roots und ihre Verzeichnisse der obersten Ebene sowie Ihr Home-Verzeichnis. Claude Code lehnt den Befehl in jedem Modus ab, ohne Sie zu fragen.
* **Platzhalter**: ein bloßes `*` oder ein beliebiges Ziel, das auf `/*` oder `\*` endet, einschließlich eines Globs unter einer Shell-Variable wie `$dir/*`. Claude Code lehnt den Befehl in jedem Modus ab, ohne Sie zu fragen, bevor der [Klassifizierer](#eliminate-prompts-with-auto-mode) ihn sieht.
* **Ihr Arbeitsverzeichnis oder eines seiner übergeordneten Verzeichnisse mit `-Recurse`**: Claude Code behandelt den Befehl wie jeden anderen, der in Ihrem Berechtigungsmodus genehmigt werden muss, daher fordert es Sie in Modi auf, die fragen, sendet es in `auto`-Modus an den Klassifizierer und lehnt es im `dontAsk`-Modus ab. Der `bypassPermissions`-Modus überspringt diese Überprüfung.
Der Fall der Systempfade gilt auch für `rd`, `rmdir`, `del` und `erase`, wenn Claude sie über `cmd` ausführt, wie in `cmd /c rd /s /q C:\Users`. Standardmäßig lehnt Claude Code einen solchen Befehl in jedem Modus ab, ohne Sie zu fragen. Diese `cmd`-Überprüfung erfordert Claude Code v2.1.283 oder später.
Bei der Beurteilung eines `cmd`-Ziels behandelt Claude Code eine PowerShell-Variable, die auf literalen Text folgt, als leer. Das macht `cmd /c rd /s /q "C:\$name"` zu einer Entfernung von `C:\`, daher wird sie auch abgelehnt. Ein nachgestellter Platzhalter zählt als der Ordner, den er leert, daher wird `cmd /c del /q C:\*` abgelehnt und `cmd /c del /q dist\*` in Ihrem Projekt nicht.
Um die `cmd`-Überprüfung auszuschalten, setzen Sie [`CLAUDE_CODE_DISABLE_POWERSHELL_CMD_RM_DENY=1`](/docs/de/env-vars#variables) in der Umgebung, die Claude Code startet. Claude Code ignoriert diese Variable in einem `env`-Block einer Einstellungsdatei. `Remove-Item` auf einem Systempfad bleibt in jedem Fall abgelehnt.
Siehe auch
* [Berechtigungen](/docs/de/permissions): Allow-, Ask- und Deny-Regeln; verwaltete Richtlinien
* [Auto-Modus konfigurieren](/docs/de/auto-mode-config): Teilen Sie dem Klassifizierer mit, welche Infrastruktur Ihre Organisation vertraut
* [Hooks](/docs/de/hooks): Benutzerdefinierte Berechtigungslogik über `PreToolUse` und `PermissionRequest` Hooks
* [Sicherheit](/docs/de/security): Schutzmaßnahmen und Best Practices
* [Sandboxing](/docs/de/sandboxing): Dateisystem- und Netzwerkisolation für Bash-Befehle
* [Nicht-interaktiver Modus](/docs/de/headless): Führen Sie Claude Code mit dem Flag `-p` aus