> ## 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.
# Werkzeugreferenz
> Vollständige Referenz für die Werkzeuge, die Claude Code verwenden kann, einschließlich Berechtigungsanforderungen und Verhalten pro Werkzeug.
Claude Code hat Zugriff auf eine Reihe von integrierten Werkzeugen, die ihm helfen, Ihre Codebasis zu verstehen und zu ändern. Die Werkzeugnamen sind die genauen Zeichenketten, die Sie in [Berechtigungsregeln](/de/permissions#tool-specific-permission-rules), [Subagent-Werkzeuglisten](/de/sub-agents) und [Hook-Matchern](/de/hooks) verwenden. Um ein Werkzeug vollständig zu deaktivieren, fügen Sie seinen Namen zum `deny`-Array in Ihren [Berechtigungseinstellungen](/de/permissions#tool-specific-permission-rules) hinzu.
Um benutzerdefinierte Werkzeuge hinzuzufügen, verbinden Sie einen [MCP-Server](/de/mcp). Um Claude mit wiederverwendbaren Prompt-basierten Workflows zu erweitern, schreiben Sie einen [Skill](/de/skills), der über das vorhandene `Skill`-Werkzeug ausgeführt wird, anstatt einen neuen Werkzeugeintrag hinzuzufügen.
| Werkzeug | Beschreibung | Berechtigung erforderlich |
| :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------ |
| `Agent` | Erzeugt einen [Subagenten](/de/sub-agents) mit eigenem Kontextfenster zur Bewältigung einer Aufgabe. Siehe [Agent-Werkzeugverhalten](#agent-tool-behavior) | Nein |
| `Artifact` | Veröffentlicht eine HTML- oder Markdown-Datei als [Artefakt](/de/artifacts): eine private, interaktive Seite auf claude.ai, die Sie in Ihrer Organisation freigeben können. {/* plan-availability: feature=artifacts plans=team,enterprise providers=anthropic */}Erfordert einen Team- oder Enterprise-Plan und `/login`-Authentifizierung; siehe [Verfügbarkeit](/de/artifacts#availability) | Ja |
| `AskUserQuestion` | Stellt Multiple-Choice-Fragen, um Anforderungen zu sammeln oder Mehrdeutigkeiten zu klären | Nein |
| `Bash` | Führt Shell-Befehle in Ihrer Umgebung aus. Siehe [Bash-Werkzeugverhalten](#bash-tool-behavior) | Ja |
| `CronCreate` | Plant eine wiederkehrende oder einmalige Eingabeaufforderung innerhalb der aktuellen Sitzung. Aufgaben sind sitzungsbezogen und werden bei `--resume` oder `--continue` wiederhergestellt, wenn sie nicht abgelaufen sind. Siehe [geplante Aufgaben](/de/scheduled-tasks) | Nein |
| `CronDelete` | Bricht eine geplante Aufgabe nach ID ab | Nein |
| `CronList` | Listet alle geplanten Aufgaben in der Sitzung auf | Nein |
| `Edit` | Nimmt gezielte Änderungen an bestimmten Dateien vor. Siehe [Edit-Werkzeugverhalten](#edit-tool-behavior) | Ja |
| `EnterPlanMode` | Wechselt in Plan Mode, um einen Ansatz vor dem Codieren zu entwerfen | Nein |
| `EnterWorktree` | Erstellt einen isolierten [Git Worktree](/de/worktrees) und wechselt hinein. Übergeben Sie einen `path`, um stattdessen in einen vorhandenen Worktree des aktuellen Repositorys zu wechseln, anstatt einen neuen zu erstellen. Aus einer Worktree-Sitzung oder von einem Subagenten mit einem angehefteten Arbeitsverzeichnis wie [`isolation: worktree`](/de/sub-agents#supported-frontmatter-fields) ist nur die `path`-Form verfügbar und das Ziel muss unter `.claude/worktrees/` liegen | Nein |
| `ExitPlanMode` | Präsentiert einen Plan zur Genehmigung und beendet Plan Mode | Ja |
| `ExitWorktree` | Beendet eine Worktree-Sitzung und kehrt zum ursprünglichen Verzeichnis zurück. Nicht für Subagenten verfügbar, die bereits in ihrem eigenen Arbeitsverzeichnis ausgeführt werden, z. B. mit [`isolation: worktree`](/de/sub-agents#supported-frontmatter-fields) | Nein |
| `Glob` | Findet Dateien basierend auf Musterabgleich. Siehe [Glob-Werkzeugverhalten](#glob-tool-behavior) | Nein |
| `Grep` | Sucht nach Mustern in Dateiinhalten. Siehe [Grep-Werkzeugverhalten](#grep-tool-behavior) | Nein |
| `ListMcpResourcesTool` | Listet Ressourcen auf, die von verbundenen [MCP-Servern](/de/mcp) bereitgestellt werden | Nein |
| `LSP` | Code-Intelligenz über Sprachserver: Sprung zu Definitionen, Suche nach Referenzen, Meldung von Typfehlern und Warnungen. Siehe [LSP-Werkzeugverhalten](#lsp-tool-behavior) | Nein |
| `Monitor` | Führt einen Befehl im Hintergrund aus und gibt jede Ausgabezeile an Claude zurück, damit er auf Protokolleinträge, Dateiänderungen oder abgerufene Status während des Gesprächs reagieren kann. Kann auch einen WebSocket öffnen und jede eingehende Nachricht als Ereignis behandeln. Siehe [Monitor-Werkzeug](#monitor-tool) | Ja |
| `NotebookEdit` | Ändert Jupyter-Notebook-Zellen. Siehe [NotebookEdit-Werkzeugverhalten](#notebookedit-tool-behavior) | Ja |
| `PowerShell` | Führt PowerShell-Befehle nativ aus. Siehe [PowerShell-Werkzeug](#powershell-tool) für Verfügbarkeit | Ja |
| `PushNotification` | Sendet eine Desktop-Benachrichtigung und eine Telefon-Push-Benachrichtigung, wenn [Remote Control](/de/remote-control) verbunden ist, damit eine langfristige Aufgabe oder [geplante Aufgabe](/de/scheduled-tasks) Sie erreichen kann, wenn Sie weg sind. {/* plan-availability: feature=push-notifications providers=anthropic */}Push-Zustellung läuft über von Anthropic gehostete Infrastruktur, auf die von Amazon Bedrock, Google Vertex AI oder Microsoft Foundry nicht zugegriffen werden kann | Nein |
| `Read` | Liest den Inhalt von Dateien. Siehe [Read-Werkzeugverhalten](#read-tool-behavior) | Nein |
| `ReadMcpResourceTool` | Liest eine bestimmte MCP-Ressource nach URI | Nein |
| `RemoteTrigger` | Erstellt, aktualisiert, führt aus und listet [Routinen](/de/routines) auf claude.ai auf. Unterstützt den `/schedule`-Befehl. {/* plan-availability: feature=routines plans=pro,max,team,enterprise providers=anthropic */}Routinen befinden sich auf claude.ai und erfordern einen Pro-, Max-, Team- oder Enterprise-Plan, daher ist dieses Werkzeug nicht über Amazon Bedrock, Google Vertex AI oder Microsoft Foundry zugänglich | Nein |
| `ReportFindings` | Meldet Code-Review-Ergebnisse als strukturierte Liste mit einer Datei, Zusammenfassung und Fehlerfall pro Ergebnis, damit Claude Code sie rendern kann, anstatt sie als Text auszudrucken. Claude ruft es auf, wenn aktive Code-Review-Anweisungen dies vorsehen. {/* min-version: 2.1.196 */}Erfordert Claude Code v2.1.196 oder später | Nein |
| `ScheduleWakeup` | Plant die nächste Iteration eines [selbstgesteuerten `/loop`](/de/scheduled-tasks#let-claude-choose-the-interval) neu. Claude ruft dies am Ende jeder Iteration auf, um auszuwählen, wann die nächste ausgeführt wird, zwischen einer Minute und einer Stunde später; Sie rufen es nicht direkt auf. Das ausstehende Wakeup wird in `session_crons` in [Stop-Hook-Eingabe](/de/hooks#stop-input) angezeigt. {/* plan-availability: feature=loop-dynamic providers=anthropic */}Nicht verfügbar auf Amazon Bedrock, Google Vertex AI oder Microsoft Foundry, wo ein `/loop`-Prompt ohne Intervall stattdessen nach einem festen Zeitplan ausgeführt wird | Nein |
| `SendMessage` | Sendet eine Nachricht an einen [Agent-Team](/de/agent-teams)-Mitarbeiter oder [setzt einen Subagenten](/de/sub-agents#resume-subagents) nach seiner Agent-ID fort. Gestoppte Subagenten werden automatisch im Hintergrund fortgesetzt. Strukturierte Team-Protokoll-Nachrichten erfordern Agent-Teams | Nein |
| `SendUserFile` | Sendet Dateien aus der Sitzung an Sie mit einer optionalen Beschriftung, damit ein generierter Bericht, Diagramm, Screenshot oder erstelltes Artefakt Ihr Gerät erreicht, anstatt nur im Transkript erwähnt zu werden. {/* min-version: 2.1.196 */}Ab v2.1.196 steuert die optionale `display`-Eingabe die Präsentation: `render` öffnet die Datei inline im Client, `attach` zeigt nur eine Download-Karte an, und wenn nicht gesetzt, entscheidet der Client nach Dateityp. Verfügbar, wenn ein [Remote Control](/de/remote-control)-Client verbunden ist oder die Sitzung in einer verwalteten Cloud-Umgebung wie [Claude Code im Web](/de/claude-code-on-the-web) ausgeführt wird. Die Zustellung läuft über von Anthropic gehostete Infrastruktur, daher ist das Werkzeug nicht auf Amazon Bedrock, Google Vertex AI oder Microsoft Foundry verfügbar | Nein |
| `ShareOnboardingGuide` | {/* plan-availability: feature=onboarding-guide-share plans=pro,max,team,enterprise providers=anthropic */}Lädt `ONBOARDING.md` hoch und gibt einen Freigabelink zurück, den Mitarbeiter in Claude Code öffnen können. Wird nach dem Schreiben des Leitfadens von `/team-onboarding` aufgerufen. Verfügbar für claude.ai-Abonnenten mit Pro-, Max-, Team- und Enterprise-Plänen | Ja |
| `Skill` | Führt einen [Skill](/de/skills#control-who-invokes-a-skill) innerhalb des Hauptgesprächs aus | Ja |
| `TaskCreate` | Erstellt eine neue Aufgabe in der Aufgabenliste | Nein |
| `TaskGet` | Ruft vollständige Details für eine bestimmte Aufgabe ab | Nein |
| `TaskList` | Listet alle Aufgaben mit ihrem aktuellen Status auf | Nein |
| `TaskOutput` | (Veraltet) Ruft Ausgabe von einer Hintergrundaufgabe ab. Bevorzugen Sie `Read` auf dem Ausgabedateipfad der Aufgabe | Nein |
| `TaskStop` | Beendet eine laufende Hintergrundaufgabe nach ID | Nein |
| `TaskUpdate` | Aktualisiert Aufgabenstatus, Abhängigkeiten, Details oder löscht Aufgaben | Nein |
| `TodoWrite` | {/* min-version: 2.1.142 */}Verwaltet die Sitzungs-Aufgabenliste. Standardmäßig ab v2.1.142 deaktiviert zugunsten von `TaskCreate`, `TaskGet`, `TaskList` und `TaskUpdate`. Setzen Sie `CLAUDE_CODE_ENABLE_TASKS=0`, um es erneut zu aktivieren | Nein |
| `ToolSearch` | Sucht nach verschobenen Werkzeugen und lädt sie, wenn [Tool-Suche](/de/mcp#scale-with-mcp-tool-search) aktiviert ist | Nein |
| `WaitForMcpServers` | {/* min-version: 2.1.142 */}Wartet auf einen oder mehrere [MCP-Server](/de/mcp), die noch im Hintergrund verbunden werden, damit eine Anfrage ihre Werkzeuge verwenden kann, ohne die Sitzung neu zu starten. Claude ruft es auf, wenn ein benötigter Server noch nicht verbunden ist. Wird nur angezeigt, wenn [Tool-Suche](/de/mcp#scale-with-mcp-tool-search) deaktiviert ist, da `ToolSearch` das Warten handhabt, wenn es aktiviert ist | Nein |
| `WebFetch` | Ruft Inhalte von einer angegebenen URL ab. Siehe [WebFetch-Werkzeugverhalten](#webfetch-tool-behavior) | Ja |
| `WebSearch` | Führt Web-Suchen durch. Siehe [WebSearch-Werkzeugverhalten](#websearch-tool-behavior) | Ja |
| `Workflow` | Führt einen [dynamischen Workflow](/de/workflows) aus: ein Skript, das viele Subagenten im Hintergrund orchestriert und ein konsolidiertes Ergebnis zurückgibt | Ja |
| `Write` | Erstellt oder überschreibt Dateien. Siehe [Write-Werkzeugverhalten](#write-tool-behavior) | Ja |
Größtenteils entscheidet Claude, wann diese Werkzeuge verwendet werden sollen, und Sie müssen sie nicht selbst benennen, wenn Sie mit Claude interagieren. Sie verweisen direkt auf Werkzeugnamen, wenn Sie Berechtigungen und andere Konfigurationen definieren:
* in [`permissions.allow` und `permissions.deny`](/de/settings#available-settings) in den Einstellungen und der `/permissions`-Schnittstelle
* in den [CLI-Flags](/de/cli-reference) `--allowedTools` und `--disallowedTools`
* in den Optionen [`allowedTools` und `disallowedTools`](/de/agent-sdk/permissions#allow-and-deny-rules) des Agent SDK
* in einem [Subagenten-`tools` oder `disallowedTools`](/de/sub-agents#supported-frontmatter-fields)-Frontmatter
* in einem [Skill-`allowed-tools`](/de/skills#frontmatter-reference)-Frontmatter
* in der [`if`-Bedingung](/de/hooks-guide#filter-by-tool-name-and-arguments-with-the-if-field) eines Hooks
Alle diese akzeptieren das gleiche Regelformat, `ToolName(specifier)`. Der Specifier hängt vom Werkzeug ab, und mehrere Werkzeuge teilen ein Format:
| Regelformat | Gilt für | Details |
| :----------------------------- | :------------------------ | :------------------------------------------------------------------------ |
| `Bash(npm run *)` | Bash, Monitor | [Befehlsmuster-Matching](/de/permissions#bash) |
| `PowerShell(Get-ChildItem *)` | PowerShell | [Befehlsmuster-Matching](/de/permissions#powershell) |
| `Read(~/secrets/**)` | Read, Grep, Glob, LSP | [Pfadmuster-Matching](/de/permissions#read-and-edit) |
| `Edit(/src/**)` | Edit, Write, NotebookEdit | [Pfadmuster-Matching](/de/permissions#read-and-edit) |
| `Skill(deploy *)` | Skill | [Skill-Namen-Matching](/de/skills#restrict-claude%E2%80%99s-skill-access) |
| `Agent(Explore)` | Agent | [Subagenten-Typ-Matching](/de/permissions#agent-subagents) |
| `WebFetch(domain:example.com)` | WebFetch | [Domain-Matching](/de/permissions#webfetch) |
| `WebSearch` | WebSearch | Kein Specifier; Werkzeug als Ganzes zulassen oder ablehnen |
Werkzeuge, die hier nicht aufgelistet sind, wie `ExitPlanMode` oder `ShareOnboardingGuide`, akzeptieren nur den bloßen Werkzeugnamen ohne Specifier.
Eine `Edit(...)`-Zulassungsregel gewährt auch Lesezugriff auf denselben Pfad, daher benötigen Sie keine entsprechende `Read(...)`-Regel.
Hook-`matcher`-Felder verwenden bloße Werkzeugnamen, nicht das geklammerte Regelformat. Siehe [Matcher-Muster](/de/hooks#matcher-patterns) für die Matching-Regeln. Für die Feldnamen, die jedes Werkzeug an `tool_input` in Hooks übergibt, siehe die [PreToolUse-Eingabereferenz](/de/hooks#pretooluse-input).
Das Agent-Werkzeug erzeugt einen Subagenten in einem separaten Kontextfenster. Der Subagent arbeitet seine Aufgabe autonom durch und gibt dann ein einzelnes Textergebnis an das übergeordnete Gespräch zurück. Das übergeordnete Gespräch sieht nicht die Zwischenwerkzeugaufrufe oder Ausgaben des Subagenten, sondern nur dieses Endergebnis. Um zu begrenzen, wie viele Durchläufe ein Subagent ausführt, setzen Sie `maxTurns` in der [Subagenten-Definition](/de/sub-agents#supported-frontmatter-fields).
Das gleiche Agent-Werkzeug startet auch [verzweigte Subagenten](/de/sub-agents#fork-the-current-conversation), wenn der Fork-Modus aktiviert ist. Ein Fork erbt das vollständige übergeordnete Gespräch, anstatt neu zu beginnen, läuft immer im Hintergrund und zeigt dennoch Berechtigungsaufforderungen in Ihrem Terminal. Der Rest dieses Abschnitts beschreibt benannte Subagenten.
Welche Werkzeuge ein benannter Subagent verwenden kann, hängt von den Feldern `tools` und `disallowedTools` in der [Subagenten-Definition](/de/sub-agents) ab:
* **Keines der Felder gesetzt**: Der Subagent erbt jedes Werkzeug, das dem übergeordneten Agenten zur Verfügung steht.
* **Nur `tools`**: Der Subagent erhält nur die aufgelisteten Werkzeuge.
* **Nur `disallowedTools`**: Der Subagent erhält jedes übergeordnete Werkzeug außer den aufgelisteten.
* **Beide gesetzt**: `disallowedTools` hat Vorrang. Ein Werkzeug, das in beiden aufgelistet ist, wird entfernt.
Das Starten des Subagenten fordert nicht selbst zur Berechtigung auf. Die eigenen Werkzeugaufrufe des Subagenten werden während der Ausführung gegen Ihre Berechtigungsregeln überprüft:
* **Vordergrund-Subagenten** zeigen die gleichen Berechtigungsaufforderungen, die Sie im Hauptgespräch sehen würden, in dem Moment, in dem jeder Werkzeugaufruf stattfindet.
* **Hintergrund-Subagenten** {/* min-version: 2.1.186 */}zeigen Berechtigungsaufforderungen in Ihrer Hauptsitzung ab v2.1.186. Die Aufforderung nennt, welcher Subagent fragt, und das Drücken von Esc lehnt diesen einen Werkzeugaufruf ab, ohne den Subagenten zu stoppen. Vor v2.1.186 lehnten Hintergrund-Subagenten automatisch jeden Werkzeugaufruf ab, der sonst eine Aufforderung auslösen würde, und setzten fort ohne dieses Werkzeug.
Um zu begrenzen, was ein Subagent in erster Linie erreichen kann, verengen Sie sein `tools`-Feld, lassen Sie Bash von der Liste weg oder setzen Sie Ablehnungsregeln in Ihren Einstellungen, wie in [Subagenten-Funktionen steuern](/de/sub-agents#control-subagent-capabilities) beschrieben. Weitere Informationen zur Wahl zwischen Vordergrund und Hintergrund finden Sie unter [Subagenten im Vordergrund oder Hintergrund ausführen](/de/sub-agents#run-subagents-in-foreground-or-background).
Das Bash-Werkzeug führt jeden Befehl in einem separaten Prozess mit folgendem Persistenzverhalten aus:
* Wenn Claude `cd` in der Hauptsitzung ausführt, wird das neue Arbeitsverzeichnis zu späteren Bash-Befehlen übertragen, solange es sich im Projektverzeichnis oder einem [zusätzlichen Arbeitsverzeichnis](/de/permissions#working-directories) befindet, das Sie mit `--add-dir`, `/add-dir` oder `additionalDirectories` in den Einstellungen hinzugefügt haben. Subagent-Sitzungen übertragen niemals Arbeitsverzeichnisänderungen.
* Wenn `cd` außerhalb dieser Verzeichnisse landet, setzt Claude Code auf das Projektverzeichnis zurück und fügt `Shell cwd was reset to ` zum Werkzeugergebnis hinzu.
* Um diese Übertragung zu deaktivieren, damit jeder Bash-Befehl im Projektverzeichnis startet, setzen Sie `CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1`.
* Umgebungsvariablen bleiben nicht erhalten. Ein `export` in einem Befehl ist im nächsten nicht verfügbar.
* Aliase und Shell-Funktionen, die in Ihrer Shell-Startdatei definiert sind, sind verfügbar. Beim Sitzungsstart sourced Claude Code `~/.zshrc`, `~/.bashrc` oder `~/.profile` je nach Ihrer Shell, erfasst die resultierenden Aliase, Funktionen und Shell-Optionen und wendet sie auf jeden Bash-Befehl an.
Aktivieren Sie Ihre virtualenv- oder Conda-Umgebung, bevor Sie Claude Code starten. Um Umgebungsvariablen über Bash-Befehle hinweg persistent zu machen, setzen Sie [`CLAUDE_ENV_FILE`](/de/env-vars) auf ein Shell-Skript, bevor Sie Claude Code starten, oder verwenden Sie einen [SessionStart-Hook](/de/hooks#persist-environment-variables), um ihn dynamisch zu füllen.
Zwei Grenzen begrenzen jeden Befehl:
* **Timeout**: Standardmäßig zwei Minuten. Claude kann bis zu 10 Minuten pro Befehl mit dem `timeout`-Parameter anfordern. Überschreiben Sie den Standard und die Obergrenze mit [`BASH_DEFAULT_TIMEOUT_MS` und `BASH_MAX_TIMEOUT_MS`](/de/env-vars).
* **Ausgabelänge**: Standardmäßig 30.000 Zeichen. Wenn ein Befehl mehr als das produziert, speichert Claude Code die vollständige Ausgabe in einer Datei im Sitzungsverzeichnis und gibt Claude den Dateipfad plus eine kurze Vorschau vom Anfang. Claude liest oder durchsucht diese Datei, wenn er den Rest benötigt. Erhöhen Sie das Limit mit [`BASH_MAX_OUTPUT_LENGTH`](/de/env-vars), bis zu einer harten Obergrenze von 150.000 Zeichen.
Für langfristige Prozesse wie Dev-Server oder Watch-Builds kann Claude `run_in_background: true` setzen, um den Befehl als Hintergrundaufgabe zu starten und weiter zu arbeiten, während er läuft. Listen Sie Hintergrundaufgaben auf und beenden Sie sie mit `/tasks`.
Das Edit-Werkzeug führt exakte Zeichenkettenersetzung durch. Es nimmt einen `old_string` und einen `new_string` und ersetzt den ersten mit dem zweiten. Es verwendet keine Regex oder Fuzzy-Matching.
Drei Überprüfungen müssen bestanden werden, damit eine Bearbeitung angewendet wird:
* **Lesen vor Bearbeitung**: Claude muss die Datei im aktuellen Gespräch gelesen haben, und die Datei darf sich auf der Festplatte nicht geändert haben, seit sie gelesen wurde. Diese Überprüfung läuft zuerst, vor jedem Zeichenkettenabgleich.
* **Abgleich**: `old_string` muss in der Datei genau wie geschrieben vorkommen. Ein einzelnes Zeichen Unterschied in Leerzeichen oder Einrückung reicht aus, um zu verfehlen.
* **Eindeutigkeit**: `old_string` muss genau einmal vorkommen. Wenn es mehr als einmal vorkommt, liefert Claude entweder eine längere Zeichenkette mit ausreichend umgebendem Kontext, um ein Vorkommen festzulegen, oder setzt `replace_all: true`, um alle zu ersetzen.
Das Anzeigen einer Datei mit Bash erfüllt auch die Anforderung zum Lesen vor Bearbeitung, wenn der Befehl `cat`, `head`, `tail`, `sed -n 'X,Yp'`, `grep`, `egrep` oder `fgrep` auf einer einzelnen Datei ohne Pipes oder Umleitungen ist. Gepipte Ausgabe und andere Bash-Befehle zählen nicht, und Claude muss in diesen Fällen Read vor der Bearbeitung verwenden.
Dies betrifft nur die Bearbeitungsberechtigung, nicht die Berechtigungen. [Read- und Edit-Ablehnungsregeln](/de/permissions#tool-specific-permission-rules) gelten auch für Dateibefehle, die Claude Code in Bash erkennt, wie `cat`, `head`, `tail`, `sed` und `grep`, aber nicht für beliebige Unterprozesse, die Dateien indirekt lesen oder schreiben, wie ein Python- oder Node-Skript, das Dateien selbst öffnet. Der Satz von Befehlen, die für Ablehnungsregeln erkannt werden, ist nicht derselbe wie die obige Liste zum Lesen vor Bearbeitung: Beispielsweise zählen `egrep` und `fgrep` für Lesen vor Bearbeitung, werden aber nicht gegen Read-Ablehnungsregeln überprüft. Für OS-Ebenen-Durchsetzung, die jeden Prozess abdeckt, [aktivieren Sie die Sandbox](/de/sandboxing).
Das Glob-Werkzeug findet Dateien nach Namensmuster. Es unterstützt Standard-Glob-Syntax einschließlich `**` für rekursives Verzeichnis-Matching:
* `**/*.js` passt alle `.js`-Dateien in beliebiger Tiefe
* `src/**/*.ts` passt alle `.ts`-Dateien unter `src/`
* `*.{json,yaml}` passt `.json`- und `.yaml`-Dateien im aktuellen Verzeichnis
Ergebnisse werden nach Änderungszeit sortiert und auf 100 Dateien begrenzt. Wenn die Obergrenze erreicht wird, sieht Claude ein Kürzungsflag im Ergebnis und kann das Muster verengen.
Glob respektiert `.gitignore` standardmäßig nicht, daher findet es gitignorierte Dateien neben verfolgten. Dies unterscheidet sich von [Grep](#grep-tool-behavior), das gitignorierte Dateien überspringt. Um Glob `.gitignore` respektieren zu lassen, setzen Sie `CLAUDE_CODE_GLOB_NO_IGNORE=false`, bevor Sie Claude Code starten.
Das Grep-Werkzeug durchsucht Dateiinhalte nach Mustern. Während [Glob](#glob-tool-behavior) Dateien nach Namen findet, findet Grep Zeilen in ihnen.
Grep basiert auf [ripgrep](https://github.com/BurntSushi/ripgrep) und verwendet ripgreps Regex-Syntax, nicht POSIX-Grep. Muster, die Regex-Metazeichen enthalten, müssen maskiert werden. Zum Beispiel erfordert das Finden von `interface{}` in Go-Code das Muster `interface\{\}`.
Drei Ausgabemodi steuern, was zurückkommt:
* `files_with_matches`: nur Dateipfade, kein Zeileninhalt. Dies ist die Standardeinstellung.
* `content`: übereinstimmende Zeilen mit Datei und Zeilennummer.
* `count`: Übereinstimmungsanzahl pro Datei.
Claude kann Ergebnisse nach Datei mit dem `glob`-Parameter wie `**/*.tsx` oder nach Sprache mit dem `type`-Parameter wie `py` oder `rust` eingrenzen. Standardmäßig passen Muster innerhalb einer einzelnen Zeile. Claude kann `multiline: true` setzen, um über Zeilengrenzen hinweg zu passen.
Grep respektiert `.gitignore`, daher werden gitignorierte Dateien übersprungen. Um eine gitignorierte Datei zu durchsuchen, übergibt Claude ihren Pfad direkt.
Das LSP-Werkzeug gibt Claude Code-Intelligenz von einem laufenden Sprachserver. Nach jeder Dateiänderung meldet es automatisch Typfehler und Warnungen, damit Claude Probleme ohne einen separaten Build-Schritt beheben kann. Claude kann es auch direkt aufrufen, um Code zu navigieren:
* Sprung zu einer Symbol-Definition
* Suche nach allen Referenzen zu einem Symbol
* Typinformationen an einer Position abrufen
* Symbole in einer Datei auflisten
* Suche nach einem Symbol nach Name im gesamten Workspace
* Implementierungen einer Schnittstelle finden
* Aufrufen-Hierarchien verfolgen
Das Werkzeug ist inaktiv, bis Sie ein [Code-Intelligence-Plugin](/de/discover-plugins#code-intelligence) für Ihre Sprache installieren. Das Plugin bündelt die Sprachserver-Konfiguration, und Sie installieren die Server-Binärdatei separat.
Das Monitor-Werkzeug erfordert Claude Code v2.1.98 oder später.
Das Monitor-Werkzeug ermöglicht es Claude, etwas im Hintergrund zu beobachten und zu reagieren, wenn es sich ändert, ohne das Gespräch zu unterbrechen. Bitten Sie Claude:
* Eine Protokolldatei zu verfolgen und Fehler zu kennzeichnen, wenn sie erscheinen
* Eine PR oder CI-Job abzufragen und zu melden, wenn sich ihr Status ändert
* Ein Verzeichnis auf Dateiänderungen zu überwachen
* Ausgabe von einem beliebigen langfristigen Skript zu verfolgen, auf das Sie es hinweisen
* Eine Verbindung zu einem WebSocket-Feed herzustellen und jede Nachricht zu melden, wenn sie ankommt
Für die meisten Überwachungen schreibt Claude ein kleines Skript, führt es im Hintergrund aus und empfängt jede Ausgabezeile, wenn sie ankommt. Für einen Server, der bereits Ereignisse pusht, kann Claude stattdessen eine [WebSocket](#websocket-source) öffnen, anstatt ein Skript auszuführen.
Sie arbeiten weiter in der gleichen Sitzung und Claude interveniert, wenn ein Ereignis eintritt. Beenden Sie eine Überwachung, indem Sie Claude auffordern, sie zu stornieren, oder indem Sie die Sitzung beenden.
Wenn Monitor einen Befehl ausführt, verwendet es die gleichen [Berechtigungsregeln wie Bash](/de/permissions#tool-specific-permission-rules), daher gelten `allow`- und `deny`-Muster, die Sie für Bash festgelegt haben, auch hier. Die [WebSocket-Quelle](#websocket-source) hat ihre eigene Genehmigungsaufforderung.
Das Werkzeug ist nicht auf Amazon Bedrock, Google Vertex AI oder Microsoft Foundry verfügbar. Es ist auch nicht verfügbar, wenn `DISABLE_TELEMETRY` oder `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` gesetzt ist.
Plugins können Monitore deklarieren, die automatisch starten, wenn das Plugin aktiv ist, anstatt Claude zu bitten, sie zu starten. Siehe [Plugin-Monitore](/de/plugins-reference#monitors).
WebSocket-Quelle
Die WebSocket-Quelle erfordert Claude Code v2.1.195 oder später.
Wenn ein Server bereits Ereignisse über eine WebSocket pusht, kann Claude sich direkt damit verbinden, anstatt ein Abfrageskript zu schreiben. Jede Art von Socket-Aktivität wird entweder zu einem Ereignis oder beendet die Überwachung:
* **Textnachrichten**: jede wird zu einem Ereignis, auch wenn die Nachricht mehrere Zeilen umfasst.
* **Binärnachrichten**: werden nicht weitergeleitet. Claude empfängt stattdessen eine Platzhalterzeile wie `[binary frame, 512 bytes]`.
* **Nachrichten größer als 1 MiB**: die Überwachung endet, daher abonnieren Sie einen gefilterten Feed, falls vorhanden.
* **Socket-Schließung**: die Überwachung endet und Claude empfängt den Schließungscode.
Eine WebSocket-Überwachung nimmt eine `ws`-Eingabe anstelle von `command` und ein einzelner Monitor-Aufruf kann die beiden nicht kombinieren. Die `ws`-Eingabe hat zwei Felder:
| Feld | Erforderlich | Beschreibung |
| :---------- | :----------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url` | Ja | Der Endpunkt zum Verbinden. Muss eine `ws://`- oder `wss://`-URL ohne eingebettete Anmeldedaten oder Leerzeichen sein, nur ASCII-Zeichen verwenden |
| `protocols` | Nein | WebSocket-Subprotokollnamen, die während des Handshake angeboten werden. Jeder Eintrag muss ein gültiges Subprotokoll-Token sein, und die Liste darf keine Duplikate enthalten |
Die Eingaben `timeout_ms` und `persistent` verhalten sich gleich wie bei einem Befehl: die Überwachung endet bei der Frist, es sei denn, `persistent` ist gesetzt, und `TaskStop` bricht sie früh ab.
Das Öffnen einer WebSocket fordert zur Genehmigung auf, und die Aufforderung bietet keine Option, zukünftige Aufforderungen für denselben Host zu überspringen.
Claude Code lehnt URLs ab, die auf eine private, Link-Local- oder Cloud-Metadaten-Adresse verweisen, einschließlich Hostnamen, die zu einer aufgelöst werden. Es lehnt auch Hosts in `sandbox.network.deniedDomains` ab, und wenn [`allowManagedDomainsOnly`](/de/settings#sandbox-settings) in verwalteten Einstellungen gesetzt ist, jeden Host außerhalb der verwalteten Zulassungsliste.
NotebookEdit ändert ein Jupyter-Notebook eine Zelle nach der anderen, indem es Zellen nach ihrer `cell_id` anvisiert. Es führt keine Zeichenkettenersetzung über das Notebook durch wie [Edit](#edit-tool-behavior) auf einfachen Dateien.
Drei Bearbeitungsmodi steuern, was mit der Zielzelle geschieht:
* `replace`: Überschreiben Sie die Quelle der Zelle. Dies ist die Standardeinstellung.
* `insert`: Fügen Sie eine neue Zelle nach der Zielzelle hinzu. Ohne `cell_id` geht die neue Zelle an den Anfang des Notebooks. Erfordert `cell_type` auf `code` oder `markdown` gesetzt.
* `delete`: Entfernen Sie die Zielzelle.
Berechtigungsregeln verwenden das `Edit(...)`-Pfadformat. Eine Regel wie `Edit(notebooks/**)` deckt NotebookEdit-Aufrufe auf Dateien in diesem Verzeichnis ab.
Das PowerShell-Werkzeug ermöglicht es Claude, PowerShell-Befehle nativ auszuführen. Unter Windows bedeutet dies, dass Befehle in PowerShell ausgeführt werden, anstatt sie über Git Bash zu leiten. Unter Windows ohne Git Bash ist das Werkzeug automatisch aktiviert. Unter Windows mit installiertem Git Bash wird das Werkzeug schrittweise eingeführt. Unter Linux, macOS und WSL ist das Werkzeug optional.
Setzen Sie `CLAUDE_CODE_USE_POWERSHELL_TOOL=1` in Ihrer Umgebung oder in `settings.json`:
```json theme={null}
{
"env": {
"CLAUDE_CODE_USE_POWERSHELL_TOOL": "1"
}
}
```
Unter Windows setzen Sie die Variable auf `0`, um sich von der Einführung abzumelden. Unter Linux, macOS und WSL erfordert das Werkzeug PowerShell 7 oder später: Installieren Sie `pwsh` und stellen Sie sicher, dass es sich auf Ihrem `PATH` befindet.
Unter Windows erkennt Claude Code `pwsh.exe` für PowerShell 7+ automatisch mit einem Fallback auf `powershell.exe` für PowerShell 5.1. Wenn das Werkzeug aktiviert ist, behandelt Claude PowerShell als die primäre Shell. Das Bash-Werkzeug bleibt für POSIX-Skripte verfügbar, wenn Git Bash installiert ist.
Claude Code startet PowerShell mit `-ExecutionPolicy Bypass` nur im Prozessbereich, sodass `.ps1`-Skripte und Modulimporte auf Standard-Windows-Installationen funktionieren, ohne die Richtlinie des Computers zu ändern. Der Prozessbereich-Bypass überschreibt nicht die Gruppenrichtlinie `MachinePolicy` oder `UserPolicy`, daher gelten Unternehmens-Lockdowns weiterhin. Um stattdessen die effektive Ausführungsrichtlinie des Computers zu respektieren, setzen Sie `CLAUDE_CODE_POWERSHELL_RESPECT_EXECUTION_POLICY=1`.
Shell-Auswahl in Einstellungen, Hooks und Skills
Drei zusätzliche Einstellungen steuern, wo PowerShell verwendet wird:
* `"defaultShell": "powershell"` in [`settings.json`](/de/settings#available-settings): leitet interaktive `!`-Befehle durch PowerShell. Erfordert, dass das PowerShell-Werkzeug aktiviert ist.
* `"shell": "powershell"` auf einzelnen [Command-Hooks](/de/hooks#command-hook-fields): führt diesen Hook in PowerShell aus. Hooks starten PowerShell direkt, daher funktioniert dies unabhängig von `CLAUDE_CODE_USE_POWERSHELL_TOOL`.
* `shell: powershell` in [Skill-Frontmatter](/de/skills#frontmatter-reference): führt `` !`command` ``-Blöcke in PowerShell aus. Erfordert, dass das PowerShell-Werkzeug aktiviert ist.
Das gleiche Verhalten zum Zurücksetzen des Arbeitsverzeichnisses in der Hauptsitzung, das im Abschnitt zum Bash-Werkzeug beschrieben ist, gilt für PowerShell-Befehle, einschließlich der Umgebungsvariable `CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR`.
{/* min-version: 2.1.196 */}Ab v2.1.196 entspricht das PowerShell-Werkzeug der Behandlung von Such- und Diff-Exit-Codes durch das Bash-Werkzeug. Exit-Code 1 von `grep`, `egrep`, `fgrep` und `git grep` bedeutet keine Übereinstimmungen, und Exit-Code 1 von `git diff` bedeutet, dass Unterschiede vorhanden sind, daher werden diese Ergebnisse Claude nicht als Befehlsfehler gemeldet.
Vorschau-Einschränkungen
Das PowerShell-Werkzeug hat während der Vorschau die folgenden bekannten Einschränkungen:
* PowerShell-Profile werden nicht geladen
* Unter Windows wird Sandboxing nicht unterstützt
Das Read-Werkzeug nimmt einen Dateipfad und gibt den Inhalt mit Zeilennummern zurück. Claude wird angewiesen, immer absolute Pfade zu übergeben.
Standardmäßig gibt Read die Datei vom Anfang zurück. Wenn ein Ganz-Datei-Lesevorgang das Token-Limit überschreitet, gibt Read die erste Seite mit einer `PARTIAL view`-Benachrichtigung zurück, die Claude mitteilt, wie viel der Datei er erhalten hat und wie er mit `offset` und `limit` mehr lesen kann. Ein Lesevorgang, der einen expliziten `offset` oder `limit` übergibt und immer noch das Token-Limit überschreitet, gibt einen Fehler zurück.
Read verarbeitet mehrere Dateitypen über einfachen Text hinaus:
* **Bilder**: PNG, JPG und andere Bildformate werden als visueller Inhalt zurückgegeben, den Claude sehen kann, nicht als Rohbytes. Claude Code ändert die Größe großer Bilder und komprimiert sie neu, um sie in die Bildgrößenlimits des Modells zu passen, bevor sie gesendet werden, daher kann Claude eine herunterskalierte Version eines großen Screenshots sehen. {/* min-version: 2.1.196 */}Ab v2.1.196 wird ein Bild, das nach dieser Größenänderung immer noch größer als 500 KB ist, als JPEG mit reduzierter Qualität neu codiert, wobei seine Pixeldimensionen unverändert bleiben. Wenn Claude feines Pixel-Level-Detail in einem großen Bild vermisst, bitten Sie es, die Region von Interesse zuerst zuzuschneiden, zum Beispiel mit ImageMagick über Bash.
* **PDFs**: Claude liest kurze `.pdf`-Dateien ganz. Für PDFs länger als 10 Seiten liest es in Bereichen mit einem `pages`-Parameter wie `"1-5"` bis zu 20 Seiten auf einmal.
* **Jupyter-Notebooks**: `.ipynb`-Dateien geben alle Zellen mit ihren Ausgaben zurück, einschließlich Code, Markdown und Visualisierungen.
Read liest nur Dateien, keine Verzeichnisse. Claude verwendet `ls` über das Bash-Werkzeug, um Verzeichnisinhalte aufzulisten.
WebFetch nimmt eine URL und eine Eingabeaufforderung, die beschreibt, was extrahiert werden soll. Es ruft die Seite ab, konvertiert die Antwort in Markdown, wenn der Server HTML zurückgibt, und führt die Eingabeaufforderung gegen den Inhalt mit einem kleinen, schnellen Modell aus. Für die meisten Abrufe erhält Claude die Antwort dieses Modells, nicht die Rohseite. Der Konvertierungsschritt ist nicht konfigurierbar.
Dies macht WebFetch absichtlich verlustbehaftet. Die Extraktions-Eingabeaufforderung bestimmt, was Claude erreicht, daher kann ein Ergebnis, das besagt, dass eine Seite etwas nicht erwähnt, nur bedeuten, dass die Eingabeaufforderung nicht danach gefragt hat. Bitten Sie Claude, erneut mit einer spezifischeren Eingabeaufforderung abzurufen, oder verwenden Sie `curl` über Bash für die unverarbeitete Seite.
Einige Verhaltensweisen prägen die Antwort, die Claude erhält:
* HTTP-URLs werden automatisch auf HTTPS aktualisiert.
* Große Seiten werden auf ein festes Zeichenlimit gekürzt, bevor sie verarbeitet werden.
* Antworten werden 15 Minuten lang zwischengespeichert, daher geben wiederholte Abrufe derselben URL schnell zurück.
* Wenn eine URL zu einem anderen Host umleitet, gibt WebFetch ein Textergebnis zurück, das die ursprüngliche URL und das Umleitungsziel benennt, anstatt es zu folgen. Claude ruft dann die neue URL mit einem zweiten WebFetch-Aufruf ab.
In den Standard- und `acceptEdits`-Berechtigungsmodi fordert WebFetch das erste Mal auf, wenn es eine neue Domain erreicht, mit Ausnahme einer integrierten Gruppe von vorab genehmigten Dokumentationsdomains, die ohne Aufforderung abgerufen werden. Um eine andere Domain im Voraus ohne Aufforderung zuzulassen, fügen Sie eine Berechtigungsregel wie `WebFetch(domain:example.com)` hinzu. Die `auto`- und `bypassPermissions`-[Berechtigungsmodi](/de/permissions#permission-modes) überspringen die Aufforderung vollständig.
Eine explizite `WebFetch(domain:...)`-Regel in `deny`, `ask` oder `allow` hat Vorrang vor der vorab genehmigten Gruppe, sodass Sie eine vorab genehmigte Domain blockieren oder eine Aufforderung dafür verlangen können.
WebFetch setzt einen `User-Agent`-Header, der mit `Claude-User` beginnt, und einen `Accept`-Header, der Markdown gegenüber HTML bevorzugt, damit Server, die Content-Negotiation unterstützen, Markdown direkt zurückgeben können. [Sandbox](/de/sandboxing)-Netzwerkregeln werden separat konfiguriert, daher benötigt eine Domain, die ein Sandbox-Prozess erreichen soll, immer noch eine explizite Sandbox-Berechtigungsregel.
WebSearch führt eine Abfrage gegen Anthropics [Web-Suche](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool)-Backend aus und gibt Ergebnistitel und URLs zurück. Es ruft die Ergebnisseiten nicht ab. Um eine Seite zu lesen, die Claude in Suchergebnissen findet, folgt es mit [WebFetch](#webfetch-tool-behavior) auf.
Das Werkzeug kann bis zu acht Backend-Suchen pro Aufruf durchführen und die Suche intern verfeinern, bevor Ergebnisse zurückgegeben werden. Claude kann Ergebnisse mit `allowed_domains` eingrenzen, um nur bestimmte Hosts einzuschließen, oder `blocked_domains`, um sie auszuschließen. Die beiden Listen können nicht in einem einzelnen Aufruf kombiniert werden.
Das Such-Backend ist nicht konfigurierbar. Um mit einem anderen Anbieter zu suchen, fügen Sie einen [MCP-Server](/de/mcp) hinzu, der ein Such-Werkzeug bereitstellt.
WebSearch-Berechtigungsregeln nehmen keinen Specifier. Ein bloßer `WebSearch`-Eintrag in `allow` oder `deny` ist die einzige Form.
WebSearch ist auf der Claude API und Microsoft Foundry verfügbar. Auf Google Cloud Vertex AI funktioniert es mit Claude 4-Modellen, einschließlich Opus, Sonnet und Haiku. Amazon Bedrock stellt das serverseitige Web-Such-Werkzeug nicht bereit.
Das Write-Werkzeug erstellt eine neue Datei oder überschreibt eine vorhandene mit dem vollständigen bereitgestellten Inhalt. Es fügt nicht an oder führt zusammen.
Wenn der Zielpfad bereits existiert, muss Claude diese Datei mindestens einmal im aktuellen Gespräch gelesen haben, bevor er sie überschreibt. Ein Write zu einer ungelesenen vorhandenen Datei schlägt mit einem Fehler fehl. Diese Einschränkung gilt nicht für neue Dateien.
Das Anzeigen der Datei mit Bash erfüllt auch diese Anforderung unter den gleichen Regeln, die in [Edit-Werkzeugverhalten](#edit-tool-behavior) beschrieben sind.
Für teilweise Änderungen an einer vorhandenen Datei verwendet Claude Edit anstelle von Write.
Ihr genaues Werkzeugsatz hängt von Ihrem Anbieter, Ihrer Plattform und Ihren Einstellungen ab. Um zu überprüfen, was in einer laufenden Sitzung geladen ist, fragen Sie Claude direkt:
```text theme={null}
What tools do you have access to?
```
Claude gibt eine Zusammenfassung im Gesprächsstil. Für genaue MCP-Werkzeugnamen führen Sie `/mcp` aus.
Das [Advisor-Tool](/de/advisor) ist ein [Server-Tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool), das die API ausführt, anstatt ein Tool, das Claude Code implementiert. Es hat keinen Namen, auf den Sie in Berechtigungsregeln oder Hook-Matchern verweisen können.
Siehe auch
* [MCP-Server](/de/mcp): Fügen Sie benutzerdefinierte Werkzeuge durch Verbindung externer Server hinzu
* [Berechtigungen](/de/permissions): Berechtigungssystem, Regelsyntax und werkzeugspezifische Muster
* [Subagents](/de/sub-agents): Konfigurieren Sie Werkzeugzugriff für Subagents
* [Hooks](/de/hooks-guide): Führen Sie benutzerdefinierte Befehle vor oder nach der Werkzeugausführung aus