> ## 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 oder verwenden Sie den Moduswahlschalter in VS Code, Desktop und claude.ai. Wenn Claude eine Datei bearbeiten, einen Shell-Befehl ausführen oder eine Netzwerkanfrage stellen möchte, pausiert es und fragt Sie um Genehmigung. Berechtigungsmodi steuern, wie oft diese Pause auftritt. Der Modus, den Sie wählen, prägt den Ablauf einer Sitzung: Der Standardmodus lässt Sie jede Aktion überprüfen, während lockerere Modi Claude in längeren ununterbrochenen Abschnitten arbeiten lassen und dann berichten, wenn es fertig ist. Wählen Sie mehr Überwachung für sensible Arbeiten oder weniger Unterbrechungen, wenn Sie der Richtung vertrauen.

Verfügbare Modi

Jeder Modus bietet einen anderen Kompromiss zwischen Komfort und Überwachung. Die folgende Tabelle zeigt, was Claude ohne Berechtigungsaufforderung in jedem Modus tun kann. | Modus | Was ohne Nachfrage ausgeführt wird | Am besten für | | :------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------- | :----------------------------------------------------- | | `default` | Nur Lesevorgänge | Erste Schritte, sensible Arbeiten | | [`acceptEdits`](#auto-approve-file-edits-with-acceptedits-mode) | Lesevorgänge, Dateibearbeitungen und häufige Dateisystem-Befehle (`mkdir`, `touch`, `mv`, `cp` usw.) | Iteration über Code, den Sie überprüfen | | [`plan`](#analyze-before-you-edit-with-plan-mode) | Nur Lesevorgänge | Erkunden einer Codebasis vor Änderungen | | [`auto`](#eliminate-prompts-with-auto-mode) | Alles, mit Hintergrund-Sicherheitsprüfungen | Lange Aufgaben, Reduzierung von Aufforderungsmüdigkeit | | [`dontAsk`](#allow-only-pre-approved-tools-with-dontask-mode) | Nur vorab genehmigte Tools | Gesperrte CI und Skripte | | [`bypassPermissions`](#skip-all-checks-with-bypasspermissions-mode) | Alles | Nur isolierte Container und VMs | In jedem Modus außer `bypassPermissions` werden Schreibvorgänge zu [geschützten Pfaden](#protected-paths) niemals automatisch genehmigt, um den Repository-Status und Claudes eigene Konfiguration vor versehentlicher Beschädigung zu schützen. Modi legen die Grundlage fest. Überlagern Sie [Berechtigungsregeln](/de/permissions#manage-permissions) darauf, um bestimmte Tools vorab zu genehmigen oder zu blockieren. Ablehnungsregeln und explizite Anfragungsregeln gelten in jedem Modus, einschließlich `bypassPermissions`. Genehmigungsregeln haben keine Auswirkung in diesem Modus, da alles andere bereits genehmigt ist.

Berechtigungsmodi wechseln

Sie können Modi während einer Sitzung, beim Start oder als persistenter Standard wechseln. Der Modus wird über diese Steuerelemente festgelegt, nicht durch Fragen an Claude im Chat. Wählen Sie Ihre Schnittstelle unten aus, um zu sehen, wie Sie ihn ändern. **Während einer Sitzung**: Drücken Sie `Shift+Tab`, um `default` → `acceptEdits` → `plan` zu durchlaufen. Der aktuelle Modus wird in der Statusleiste angezeigt. Nicht jeder Modus ist im Standard-Zyklus: * `auto`: wird angezeigt, wenn Ihr Konto die [Auto-Modus-Anforderungen](#eliminate-prompts-with-auto-mode) erfüllt; das Durchlaufen zu Auto schaltet Modi ohne eine Bestätigungsaufforderung um * `bypassPermissions`: wird angezeigt, nachdem Sie mit `--permission-mode bypassPermissions`, `--dangerously-skip-permissions` oder `--allow-dangerously-skip-permissions` starten; die `--allow-`-Variante fügt den Modus zum Zyklus hinzu, ohne ihn zu aktivieren * `dontAsk`: wird niemals im Zyklus angezeigt; legen Sie ihn mit `--permission-mode dontAsk` fest Aktivierte optionale Modi werden nach `plan` eingefügt, mit `bypassPermissions` zuerst und `auto` zuletzt. Wenn Sie beide aktiviert haben, durchlaufen Sie `bypassPermissions` auf dem Weg zu `auto`. **Beim Start**: Übergeben Sie den Modus als Flag. ```bash theme={null} claude --permission-mode plan ``` **Als Standard**: Legen Sie `defaultMode` in [Einstellungen](/de/settings#settings-files) fest. ```json theme={null} { "permissions": { "defaultMode": "acceptEdits" } } ``` Das gleiche `--permission-mode`-Flag funktioniert mit `-p` für [nicht-interaktive Läufe](/de/headless). **Während einer Sitzung**: Klicken Sie auf den Modusindikator am unteren Rand des Eingabefelds. **Als Standard**: Legen Sie `claudeCode.initialPermissionMode` in VS Code-Einstellungen fest, oder verwenden Sie das Einstellungsfenster der Claude Code-Erweiterung. Der Modusindikator zeigt diese Bezeichnungen, die dem Modus zugeordnet sind, auf den sich jede bezieht: | UI-Bezeichnung | Modus | | :----------------------- | :------------------ | | Vor Bearbeitungen fragen | `default` | | Automatisch bearbeiten | `acceptEdits` | | Planungsmodus | `plan` | | Auto-Modus | `auto` | | Berechtigungen umgehen | `bypassPermissions` | Auto-Modus wird im Modusindikator angezeigt, wenn Ihr Konto alle Anforderungen erfüllt, die im [Auto-Modus-Abschnitt](#eliminate-prompts-with-auto-mode) aufgelistet sind. Die `claudeCode.initialPermissionMode`-Einstellung akzeptiert nicht `auto`. Um standardmäßig im Auto-Modus zu starten, legen Sie stattdessen `defaultMode` in Ihren [Benutzereinstellungen](/de/settings#settings-files) fest. Claude Code ignoriert `defaultMode: "auto"` in Projekt- und lokalen Einstellungen. Berechtigungen umgehen erfordert den Umschalter **Berechtigungen gefährlich überspringen zulassen** in den Erweiterungseinstellungen, bevor es im Modusindikator angezeigt wird. Weitere Informationen finden Sie im [VS Code-Leitfaden](/de/vs-code). Das JetBrains-Plugin führt Claude Code im IDE-Terminal aus, daher funktioniert das Wechseln von Modi genauso wie in der CLI: Drücken Sie `Shift+Tab` zum Durchlaufen, oder übergeben Sie `--permission-mode` beim Start. Verwenden Sie den Moduswahlschalter neben der Schaltfläche "Senden". Auto und Berechtigungen umgehen werden nur angezeigt, nachdem Sie sie in Desktop-Einstellungen aktivieren. Weitere Informationen finden Sie im [Desktop-Leitfaden](/de/desktop#choose-a-permission-mode). Verwenden Sie das Modus-Dropdown neben dem Eingabefeld auf [claude.ai/code](https://claude.ai/code) oder in der mobilen App. Berechtigungsaufforderungen werden in claude.ai zur Genehmigung angezeigt. Welche Modi angezeigt werden, hängt davon ab, wo die Sitzung ausgeführt wird: * **Cloud-Sitzungen** auf [Claude Code im Web](/de/claude-code-on-the-web): Bearbeitungen automatisch akzeptieren, Planungsmodus und Auto-Modus. Bearbeitungen automatisch akzeptieren entspricht dem `default`-Modus: Die Cloud-Umgebung genehmigt Dateibearbeitungen unabhängig vom Modus vorab, daher zeigt das Dropdown "Bearbeitungen automatisch akzeptieren" anstelle von "Berechtigungen erfragen" an. `defaultMode: "acceptEdits"` aus den Einstellungen wird weiterhin berücksichtigt. Auto-Modus wird nur angezeigt, wenn Ihre Organisation ihn zulässt und das ausgewählte Modell ihn unterstützt. Berechtigungen umgehen ist nicht verfügbar. * **[Remote Control](/de/remote-control)-Sitzungen** auf Ihrem lokalen Computer: Berechtigungen erfragen, Bearbeitungen automatisch akzeptieren und Planungsmodus. Auto und Berechtigungen umgehen sind nicht verfügbar. Für Remote Control können Sie auch den Startmodus beim Starten des Hosts festlegen: ```bash theme={null} claude remote-control --permission-mode acceptEdits ```

Dateibearbeitungen mit acceptEdits-Modus automatisch genehmigen

Der `acceptEdits`-Modus lässt Claude Dateien in Ihrem Arbeitsverzeichnis erstellen und bearbeiten, ohne zu fragen. Die Statusleiste zeigt `⏵⏵ accept edits on`, während dieser Modus aktiv ist. Zusätzlich zu Dateibearbeitungen genehmigt der `acceptEdits`-Modus automatisch häufige Dateisystem-Bash-Befehle: `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 Dateibearbeitungen gilt die automatische Genehmigung nur für Pfade in Ihrem Arbeitsverzeichnis oder `additionalDirectories`. Pfade außerhalb dieses Bereichs, Schreibvorgänge zu [geschützten Pfaden](#protected-paths) und alle anderen Bash-Befehle fordern weiterhin auf. Wenn das [PowerShell-Tool](/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. Verwenden Sie `acceptEdits`, wenn Sie Änderungen in Ihrem Editor oder über `git diff` überprüfen möchten, anstatt jede Bearbeitung inline zu genehmigen. Drücken Sie `Shift+Tab` einmal vom Standardmodus, um ihn zu betreten, oder starten Sie direkt damit: ```bash theme={null} claude --permission-mode acceptEdits ```

Vor der Bearbeitung mit Planungsmodus analysieren

Der Planungsmodus 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 Ihren Quellcode. Berechtigungsaufforderungen gelten genauso wie im Standardmodus. Betreten Sie den Planungsmodus, indem Sie `Shift+Tab` drücken oder einer einzelnen Aufforderung `/plan` voranstellen. Sie können auch vom CLI aus im Planungsmodus starten: ```bash theme={null} claude --permission-mode plan ``` Drücken Sie `Shift+Tab` erneut, um den Planungsmodus 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 es weitergehen soll. Von dieser Aufforderung aus können Sie: * Genehmigen und im Auto-Modus starten * Genehmigen und Bearbeitungen akzeptieren * Genehmigen und jede Bearbeitung manuell überprüfen * Mit Feedback weiterplanen * Mit [Ultraplan](/de/ultraplan) für browsergestützte Überprüfung verfeinern Das Genehmigen eines Plans beendet den Planungsmodus und wechselt die Sitzung in den Berechtigungsmodus, den jede Genehmigungsoption beschreibt, sodass Claude mit der Bearbeitung beginnt. Um erneut zu planen, kehren Sie mit `Shift+Tab` zum Planungsmodus zurück oder stellen Sie Ihrer nächsten Aufforderung `/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`](/de/settings#available-settings) aktiviert ist, bietet jede Genehmigungsoption auch an, den Planungskontext zuerst zu löschen. Das Akzeptieren eines Plans benennt die Sitzung automatisch aus dem Planinhalt, es sei denn, Sie haben bereits einen Namen mit `--name` oder `/rename` festgelegt.

Legen Sie den Planungsmodus als Standard fest

Um den Planungsmodus als Standard für ein Projekt festzulegen, setzen Sie `defaultMode` in `.claude/settings.json`: ```json theme={null} { "permissions": { "defaultMode": "plan" } } ```

Aufforderungen mit Auto-Modus eliminieren

Auto-Modus erfordert Claude Code v2.1.83 oder später. Auto-Modus lässt Claude ohne Berechtigungsaufforderungen ausführen. Ein separates Klassifizierer-Modell ü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 [Anfrageregelungen](/de/permissions#manage-permissions) erzwingen weiterhin eine Aufforderung. Auto-Modus weist Claude auch an, weiterzuarbeiten, ohne bei Klarstellungsfragen zu stoppen, obwohl Claude immer noch fragt, wenn Ihre Aufforderung oder eine Fähigkeit explizit darauf angewiesen ist. Für stärkeres autonomes Verhalten bei Beibehaltung von Berechtigungsaufforderungen stellen Sie stattdessen den [Proaktiven Ausgabestil](/de/output-styles) ein. Auto-Modus ist eine Forschungsvorschau. Er reduziert Aufforderungen, garantiert aber keine Sicherheit. Verwenden Sie ihn für Aufgaben, bei denen Sie der allgemeinen Richtung vertrauen, nicht als Ersatz für Überprüfung bei sensiblen Operationen. Auto-Modus ist nur verfügbar, wenn Ihr Konto alle diese Anforderungen erfüllt: * **Plan**: Alle Pläne. * **Owner**: Bei Team und Enterprise muss ein Owner ihn in [Claude Code-Administratoreinstellungen](https://claude.ai/admin-settings/claude-code) aktivieren, bevor Benutzer ihn einschalten können. Administratoren können ihn auch sperren, indem sie `permissions.disableAutoMode` in [verwalteten Einstellungen](/de/permissions#managed-settings) auf `"disable"` setzen. * **Modell**: Bei der Anthropic API Claude Opus 4.6 oder später oder Sonnet 4.6 oder später. Bei Amazon Bedrock, Google Cloud Vertex AI, Microsoft Foundry und angemeldeten [Claude-Apps-Gateway](/de/claude-apps-gateway)-Sitzungen nur Claude Sonnet 5, Opus 4.7 und Opus 4.8. Ältere Modelle, einschließlich Sonnet 4.5, Opus 4.5, Haiku und claude-3-Modelle, werden auf keinem Anbieter unterstützt. * **Anbieter**: Standardmäßig auf der Anthropic API verfügbar. Bei Amazon Bedrock, Google Cloud Vertex AI, Microsoft Foundry und angemeldeten Claude-Apps-Gateway-Sitzungen ist Auto-Modus deaktiviert, bis Sie [`CLAUDE_CODE_ENABLE_AUTO_MODE`](#enable-auto-mode-on-bedrock-vertex-ai-or-foundry) setzen. Wenn Claude Code Auto-Modus als nicht verfügbar meldet, ist eine dieser Anforderungen nicht erfüllt; dies ist kein vorübergehender Ausfall. Eine separate Nachricht, die ein Modell benennt und sagt, Auto-Modus "kann die Sicherheit" einer Aktion nicht bestimmen, ist ein vorübergehender Klassifizierer-Ausfall; siehe die [Fehlerreferenz](/de/errors#auto-mode-cannot-determine-the-safety-of-an-action). Wenn Sie `defaultMode: "auto"` in [Einstellungen](/de/settings#available-settings) setzen und die Sitzung im `default`-Modus ohne Fehler startet, befindet sich die Einstellung wahrscheinlich in `.claude/settings.json` oder `.claude/settings.local.json`. Claude Code v2.1.142 und später ignorieren `auto` aus diesen Dateien, daher kann ein Repository sich selbst nicht den Auto-Modus gewähren. Verschieben Sie es zu `~/.claude/settings.json`.

Auto-Modus auf Bedrock, Vertex AI oder Foundry aktivieren

Bei [Amazon Bedrock](/de/amazon-bedrock), [Google Cloud Vertex AI](/de/google-vertex-ai), [Microsoft Foundry](/de/microsoft-foundry) und angemeldeten [Claude-Apps-Gateway](/de/claude-apps-gateway)-Sitzungen wird Auto-Modus nicht im `Shift+Tab`-Zyklus angezeigt, bis `CLAUDE_CODE_ENABLE_AUTO_MODE` auf `1` gesetzt ist. Die Variable funktioniert in Claude Code v2.1.158 und später. Nur Claude Sonnet 5, Opus 4.7 und Opus 4.8 werden auf diesen Anbietern unterstützt. Um es für einen Entwickler zu aktivieren, fügen Sie die Variable zum `env`-Block in `~/.claude/settings.json` hinzu: ```json theme={null} { "env": { "CLAUDE_CODE_ENABLE_AUTO_MODE": "1" } } ``` Um es für Ihre Organisation zu aktivieren, fügen Sie denselben `env`-Block zu [verwalteten Einstellungen](/de/settings#settings-files) hinzu. Sobald die Variable gesetzt ist, wird Auto-Modus im `Shift+Tab`-Zyklus für jede Sitzung angezeigt. Um es zum Standard-Startmodus zu machen, setzen Sie auch `"permissions": {"defaultMode": "auto"}` in Benutzer- oder verwalteten Einstellungen. Bei diesen Anbietern ignoriert Claude Code `defaultMode: "auto"` nicht, es sei denn, `CLAUDE_CODE_ENABLE_AUTO_MODE` ist auch gesetzt. Um Entwickler daran zu hindern, Auto-Modus zu aktivieren, setzen Sie `disableAutoMode` in verwalteten Einstellungen auf `"disable"`. Dies überschreibt die Enable-Variable. Wenn Sie sich über ein [LLM-Gateway](/de/llm-gateway) verbinden, das mit `ANTHROPIC_BASE_URL` konfiguriert ist, ist Auto-Modus möglicherweise bereits ohne die Enable-Variable erreichbar, da das Gateway Anfragen durch die Anthropic API leitet. Dies gilt nicht für eine angemeldete [Claude-Apps-Gateway](/de/claude-apps-gateway)-Sitzung, die ihre eigene Anbieterklasse ist und die Enable-Variable erfordert. Die `disableAutoMode`-Einstellung gilt auf die gleiche Weise in beiden Konfigurationen.

Was der Klassifizierer standardmäßig blockiert

Der Klassifizierer vertraut Ihrem Arbeitsverzeichnis und den konfigurierten Remotes Ihres Repositories. Alles andere wird als extern behandelt, bis Sie [vertrauenswürdige Infrastruktur konfigurieren](/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 auf Cloud-Speicher * Gewährung von IAM- oder Repository-Berechtigungen * Änderung gemeinsamer Infrastruktur * Irreversibles Löschen von Dateien, die vor der Sitzung vorhanden waren * Force-Push oder direktes Pushen zu `main` * {/* min-version: 2.1.182 */}`git reset --hard`, `git checkout -- .`, `git restore .`, `git clean -fd`, `git stash drop` oder `git stash clear`, von denen der Klassifizierer annimmt, dass sie nicht committete Änderungen verwerfen würden * `git commit --amend`, wenn der Commit am HEAD nicht in dieser Sitzung erstellt wurde * `terraform destroy`, `pulumi destroy`, `cdk destroy` oder `terragrunt destroy`, und Anwendung eines Plans, der Ressourcen zerstört Claude Code v2.1.195 und später blockieren standardmäßig weitere Kategorien. Mehrere hängen von [Umgebungs](/de/auto-mode-config#define-trusted-infrastructure)-Einträgen ab, wie sensible Remote-Ziele und geschützte IaC-Bereiche, die Sie auf konkrete Namen eingrenzen können. * Schreiben in einen Secret Manager oder Ändern von DNS-Einträgen oder TLS-Zertifikaten * Zusammenführen eines Pull Request, den kein Mensch genehmigt hat, Genehmigung von Claudes eigenem Pull Request oder Deaktivierung von CI-Prüfungen * Posten eines Kommentars, der selbst ein Befehl für Automatisierung ist, wie `atlantis apply` oder ein Bot-`/deploy` oder `/merge` * Umschalten, Ramping oder Löschen eines Production-Feature-Flags * Anwendung von Infrastrukturänderungen auf einen geschützten IaC-Bereich oder Entleerung und Entfernung von Cluster-Knoten * Schreibvorgänge in einen gemeinsamen Compute-Cluster, die über die benannte Ressource hinausgehen, wie ein Label-Selector oder `--all`, das andere Benutzer-Jobs erfasst * Erstellen von Kubernetes-Ressourcen, die auf jedem Knoten ausgeführt werden oder Cluster-Traffic 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 Service vom öffentlichen Internet erreichbar macht * Drucken einer Live-Anmeldedaten oder eines Tokens in das Transkript oder eine Datei * Zugriff auf einen PII- oder regulierten Datenspeicherort oder Kopieren von Daten aus einem * Umleitung einer Paketinstallation um Ihre interne Paketregistrierung zu einer öffentlichen Registrierung * Ausführung eines Befehls mit einem Flag, das einen Sicherheitsschutz deaktiviert, wie `--insecure` * [Claude in Chrome](/de/chrome)-Browser-Aktionen, die Seiteninhalte, Cookies oder Anmeldedaten off-origin senden könnten **Standardmäßig zugelassen**: * Lokale Dateioperationen in Ihrem Arbeitsverzeichnis * Installation von Abhängigkeiten, die in Ihren Lock-Dateien oder Manifesten deklariert sind * Lesen von `.env` und Senden von Anmeldedaten an ihre entsprechende API * Schreibgeschützte HTTP-Anfragen * Pushen zum Branch, auf dem Sie gestartet haben, oder zu einem, den Claude erstellt hat Claude Code v2.1.195 und später erlauben standardmäßig auch diese: * Löschen der genauen Jobs, die Claude früher in derselben Sitzung erstellt hat * Lesen, Überprüfung oder Schreiben von sicherheitsbezogenem Code, Konfigurationen und Bedrohungsmodellen als Teil Ihrer Aufgabe * Nachrichten zwischen Agenten, die zusammen in derselben Multi-Agent-Sitzung arbeiten * Senden von Daten an die vertrauenswürdigen Domains, Buckets und Services, die Sie in [`environment`](/de/auto-mode-config#define-trusted-infrastructure) auflisten. Dies deckt nur Datenfluss ab, nicht destruktive oder Anmeldedaten-Operationen auf derselben Infrastruktur * [Claude in Chrome](/de/chrome)-Navigation zu einer vertrauenswürdigen internen Domain, localhost oder einer URL, die Sie benannt haben Sandbox-Netzwerkzugriff-Anfragen werden durch den Klassifizierer geleitet, anstatt standardmäßig zugelassen zu werden. Führen Sie `claude auto-mode defaults` aus, um die vollständigen Regellisten zu sehen. Wenn Routineaktionen blockiert werden, kann ein Administrator vertrauenswürdige Repositories, Buckets und Dienste über die `autoMode.environment`-Einstellung hinzufügen: siehe [Auto-Modus konfigurieren](/de/auto-mode-config).

Grenzen, die Sie im Gespräch angeben

Der Klassifizierer behandelt Grenzen, die Sie im Gespräch angeben, als Blocksignal. Wenn Sie Claude sagen "nicht pushen" oder "warten Sie, bis ich überprüfe, bevor Sie bereitstellen", blockiert der Klassifizierer übereinstimmende Aktionen, auch wenn die Standardregeln sie zulassen würden. Eine Grenze bleibt in Kraft, bis Sie sie in einer späteren Nachricht aufheben. Claudes eigenes Urteil, dass eine Bedingung erfüllt wurde, hebt sie nicht auf. Grenzen werden nicht als Regeln gespeichert. Der Klassifizierer liest sie bei jeder Prüfung aus dem Transkript erneut, daher kann eine Grenze verloren gehen, wenn [Kontext-Komprimierung](/de/costs#reduce-token-usage) die Nachricht entfernt, die sie angegeben hat. Für eine harte Garantie fügen Sie stattdessen eine [Deny-Regel](/de/permissions#permission-rule-syntax) hinzu.

Wenn Auto-Modus zurückfällt

Jede abgelehnte Aktion zeigt eine Benachrichtigung und wird in `/permissions` unter der Registerkarte "Kürzlich abgelehnt" angezeigt, wo Sie `r` drücken können, um sie mit manueller Genehmigung erneut zu versuchen. Wenn der Klassifizierer eine Aktion 3-mal hintereinander oder 20-mal insgesamt blockiert, pausiert der Auto-Modus und Claude Code setzt das Aufforderungen fort. Das Genehmigen der aufgeforderten Aktion setzt den Auto-Modus fort. Diese Schwellwerte sind nicht konfigurierbar. Jede zugelassene Aktion setzt den aufeinanderfolgenden Zähler zurück, während der Gesamtzähler für die Sitzung bestehen bleibt und nur zurückgesetzt wird, wenn sein eigenes Limit einen Fallback auslöst. Im [nicht-interaktiven Modus](/de/headless) mit dem `-p`-Flag bricht die Sitzung ab, da es keinen Benutzer gibt, der aufgefordert werden kann. Wiederholte Blockierungen bedeuten normalerweise, dass dem Klassifizierer der Kontext über Ihre Infrastruktur fehlt. Verwenden Sie `/feedback`, um falsch positive Ergebnisse zu melden, oder lassen Sie einen Administrator [vertrauenswürdige Infrastruktur konfigurieren](/de/auto-mode-config). Jede Aktion durchläuft eine feste Entscheidungsreihenfolge. Der erste übereinstimmende Schritt gewinnt: 1. Aktionen, die Ihren [Allow- oder Deny-Regeln](/de/permissions#manage-permissions) entsprechen, werden sofort gelöst, außer Schreibvorgänge zu [geschützten Pfaden](#protected-paths), die zum Klassifizierer geleitet werden, auch wenn eine Allow-Regel passt 2. Schreibgeschützte Aktionen und Dateibearbeitungen in Ihrem Arbeitsverzeichnis werden automatisch genehmigt, außer Schreibvorgänge zu [geschützten Pfaden](#protected-paths) 3. Alles andere geht an den Klassifizierer 4. Wenn der Klassifizierer blockiert, erhält Claude den Grund und versucht eine Alternative Beim Eintritt in den Auto-Modus werden breite Allow-Regeln, die willkürliche Code-Ausführung gewähren, gelöscht: * Blanko `Bash(*)` * Wildcard-Interpreter wie `Bash(python*)` * Paketmanager-Ausführungsbefehle * `Agent`-Allow-Regeln Enge Regeln wie `Bash(npm test)` werden übernommen. Gelöschte Regeln werden wiederhergestellt, wenn Sie den Auto-Modus verlassen. Der Klassifizierer sieht Benutzernachrichten, Tool-Aufrufe und Ihren CLAUDE.md-Inhalt. Tool-Ergebnisse werden entfernt, daher kann feindselige Inhalte in einer Datei oder Webseite ihn nicht direkt manipulieren. Eine separate serverseitige Sonde scannt eingehende Tool-Ergebnisse und kennzeichnet verdächtige Inhalte, bevor Claude sie liest. Weitere Informationen darüber, wie diese Schichten zusammenarbeiten, finden Sie in der [Auto-Modus-Ankündigung](https://claude.com/blog/auto-mode) und dem [Engineering Deep Dive](https://www.anthropic.com/engineering/claude-code-auto-mode). Der Klassifizierer überprüft [Subagenten](/de/sub-agents)-Arbeit an drei Punkten: 1. Bevor ein Subagent startet, wird die delegierte Aufgabenbeschreibung bewertet, daher wird eine gefährlich aussehende Aufgabe beim Erzeugen blockiert. 2. Während der Subagent läuft, durchläuft jede seiner Aktionen den Klassifizierer mit den gleichen Regeln wie die übergeordnete Sitzung, und jeder `permissionMode` im Frontmatter des Subagenten wird ignoriert. 3. Wenn der Subagent fertig ist, überprüft der Klassifizierer seine vollständige Aktionshistorie; wenn diese Rückgabeprüfung ein Problem kennzeichnet, wird eine Sicherheitswarnung den Ergebnissen des Subagenten vorangestellt. Schritt 1 erfordert Claude Code v2.1.178 oder später. Frühere Versionen wendeten den Klassifizierer in den Schritten 2 und 3 an, bewerteten aber die Aufgabenbeschreibung nicht, bevor der Subagent gestartet wurde. Der Klassifizierer läuft auf einem serverkonfigurierten Modell, das unabhängig von Ihrer `/model`-Auswahl ist, daher ändert das Wechseln von Modellen die Klassifizierer-Verfügbarkeit nicht. Klassifizierer-Aufrufe zählen zu Ihrer Token-Nutzung. Jede Prüfung sendet einen Teil des Transkripts plus die ausstehende Aktion, was einen Roundtrip vor der Ausführung hinzufügt. Lesevorgänge und Arbeitsverzeichnis-Bearbeitungen außerhalb geschützter Pfade überspringen den Klassifizierer, daher kommt der Overhead hauptsächlich von Shell-Befehlen und Netzwerkoperationen.

Nur vorab genehmigte Tools mit dontAsk-Modus zulassen

Der `dontAsk`-Modus lehnt automatisch jeden Tool-Aufruf ab, der sonst auffordern würde. Nur Aktionen, die Ihren `permissions.allow`-Regeln und [schreibgeschützten Bash-Befehlen](/de/permissions#read-only-commands) entsprechen, können ausgeführt werden; explizite [`ask`-Regeln](/de/permissions#manage-permissions) werden abgelehnt, anstatt aufzufordern. Dies macht den Modus vollständig nicht-interaktiv für CI-Pipelines oder eingeschränkte Umgebungen, in denen Sie genau vordefinieren, was Claude tun darf. Cloud-Sitzungen auf [Claude Code im Web](/de/claude-code-on-the-web) ignorieren `defaultMode: "dontAsk"`; siehe [bypassPermissions](#skip-all-checks-with-bypasspermissions-mode) für Details. Legen Sie ihn beim Start mit dem Flag fest: ```bash theme={null} claude --permission-mode dontAsk ```

Alle Prüfungen mit bypassPermissions-Modus überspringen

Der `bypassPermissions`-Modus deaktiviert Berechtigungsaufforderungen und Sicherheitsprüfungen, damit Tool-Aufrufe sofort ausgeführt werden. Ab v2.1.126 umfasst dies auch Schreibvorgänge zu [geschützten Pfaden](#protected-paths), die frühere Versionen noch aufforderten. Explizite [Ask-Regeln](/de/permissions#manage-permissions) erzwingen weiterhin eine Aufforderung in diesem Modus, und Löschvorgänge, die auf das Dateisystem-Root oder das Home-Verzeichnis abzielen, wie `rm -rf /` und `rm -rf ~`, fordern weiterhin auf als Schutzschalter gegen Modellfehler. Verwenden Sie diesen Modus nur in isolierten Umgebungen wie Containern, VMs oder Dev Containern ohne Internetzugang, wo Claude Code Ihr Host-System nicht beschädigen kann. Sie können nicht in `bypassPermissions` aus einer Sitzung eintreten, die ohne eines der aktivierenden Flags gestartet wurde; starten Sie neu mit einem, um es zu aktivieren: ```bash theme={null} claude --permission-mode bypassPermissions ``` Das `--dangerously-skip-permissions`-Flag ist gleichbedeutend. Unter 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 Prüfung wird automatisch in einer erkannten Sandbox übersprungen. Um autonom in einem Container zu laufen, verwenden Sie die [Dev-Container](/de/devcontainer)-Konfiguration, die Claude Code als Nicht-Root-Benutzer ausführt. [Claude Code im Web](/de/claude-code-on-the-web) berücksichtigt `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 Modus, der in der Modus-Dropdown angezeigt wird. Siehe [Berechtigungsmodi wechseln](#switch-permission-modes) für die Modi, die Cloud-Sitzungen anbieten. `bypassPermissions` bietet keinen Schutz vor Prompt-Injection oder unbeabsichtigten Aktionen. Verwenden Sie für Hintergrund-Sicherheitsprüfungen mit deutlich weniger Aufforderungen stattdessen [Auto-Modus](#eliminate-prompts-with-auto-mode). Administratoren können diesen Modus blockieren, indem sie `permissions.disableBypassPermissionsMode` auf `"disable"` in [verwalteten Einstellungen](/de/permissions#managed-settings) setzen.

Geschützte Pfade

Schreibvorgänge zu einer kleinen Menge von Pfaden werden niemals automatisch genehmigt, in jedem Modus außer `bypassPermissions`. Dies verhindert versehentliche Beschädigung des Repository-Status und Claudes eigener Konfiguration. | Modus | Schreibvorgänge zu geschützten Pfaden | | :------------------------------- | :------------------------------------ | | `default`, `acceptEdits`, `plan` | Abgefragt | | `auto` | An den Klassifizierer weitergeleitet | | `dontAsk` | Abgelehnt | | `bypassPermissions` | Erlaubt | [`permissions.allow`](/de/permissions#manage-permissions) Regeln in Einstellungsdateien genehmigen Schreibvorgänge zu geschützten Pfaden nicht vorab. 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 Aufforderung für einen `.claude/`-Schreibvorgang **Ja, und Claude erlauben, seine eigenen Einstellungen für diese Sitzung zu bearbeiten**, was spätere `.claude/`-Schreibvorgänge in dieser Sitzung ohne erneute Aufforderung genehmigt. Geschützte Verzeichnisse: * `.git` * `.config/git` * `.vscode` * `.idea` * `.husky` * `.cargo` * `.devcontainer` * `.yarn` * `.mvn` * `.claude`, außer für `.claude/worktrees`, wo Claude seine eigenen Git-Worktrees speichert 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`

Siehe auch

* [Berechtigungen](/de/permissions): Allow-, Ask- und Deny-Regeln; verwaltete Richtlinien * [Auto-Modus konfigurieren](/de/auto-mode-config): Teilen Sie dem Klassifizierer mit, welche Infrastruktur Ihre Organisation vertraut * [Hooks](/de/hooks): benutzerdefinierte Berechtigungslogik über `PreToolUse`- und `PermissionRequest`-Hooks * [Ultraplan](/de/ultraplan): Führen Sie den Planungsmodus in einer Claude Code im Web-Sitzung mit browsergestützter Überprüfung aus * [Sicherheit](/de/security): Sicherheitsvorkehrungen und Best Practices * [Sandboxing](/de/sandboxing): Dateisystem- und Netzwerkisolation für Bash-Befehle * [Nicht-interaktiver Modus](/de/headless): Führen Sie Claude Code mit dem `-p`-Flag aus