---
title: Funktionsübersicht
url: https://platform.claude.com/docs/de/build-with-claude/overview
description: Entdecke die erweiterten Funktionen und Fähigkeiten von Claude.
---

Informationen zur Eignung jeder Funktion im Rahmen von „zero data retention“ (Null-Datenspeicherung), oder ZDR, sowie zur HIPAA-Bereitschaft findest du unter [API und Datenspeicherung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#feature-eligibility).

Für Administration und Governance siehe die [Admin API](https://platform.claude.com/docs/de/manage-claude/admin-api), die [Usage and Cost Analytics API](https://platform.claude.com/docs/de/manage-claude/usage-cost-analytics-api) und die [Compliance API](https://platform.claude.com/docs/de/manage-claude/compliance-api).

## Plattformfunktionen

Funktionen der Claude Platform, die über ihre APIs hinweg funktionieren. Auf der Seite jeder Funktion steht, wo du sie verwenden kannst.

<Tip>
  Du kannst programmatisch ermitteln, welche Fähigkeiten ein Modell unterstützt. Die [Models API](https://platform.claude.com/docs/de/api/models/list) gibt für jedes verfügbare Modell `max_input_tokens`, `max_tokens` und ein `capabilities`-Objekt zurück.
</Tip>

| Funktion                                                                                                                                                             | Beschreibung                                                                                                                                                                                                                             |
| :------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Advisor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool)                                                                           | Ermöglicht einem schnelleren Executor-Modell, während der Generierung ein leistungsfähigeres Advisor-Modell für einen Plan oder eine Kurskorrektur zu konsultieren.                                                                      |
| [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview)                                                                           | Wiederverwendbare Pakete aus Anweisungen, Metadaten und optionalen Skripten, die Claude automatisch verwendet, wenn sie für eine Aufgabe relevant sind.                                                                                  |
| ↳ [Benutzerdefinierte Skills](https://platform.claude.com/docs/de/build-with-claude/skills-guide#managing-custom-skills)                                             | Skills, die du schreibst und in deinen Workspace hochlädst.                                                                                                                                                                              |
| ↳ [Vorgefertigte Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview#pre-built-agent-skills)                                    | Vorgefertigte Skills von Anthropic für PowerPoint-, Excel-, Word- und PDF-Dateien.                                                                                                                                                       |
| [Batch-Verarbeitung](https://platform.claude.com/docs/de/build-with-claude/batch-processing)                                                                         | Verarbeitet viele Messages-API-Anfragen asynchron in einem Batch, zum halben Standardpreis.                                                                                                                                              |
| [Browser- und Computer-Use-Toolsets im SDK](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk)                                           | Klassen in den Python- und TypeScript-SDKs, die das Browser-Use-Tool oder das Computer-Use-Tool mit einem Browser oder Desktop verbinden, den du bereitstellst.                                                                          |
| [Browser-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool)                                                                   | Ermöglicht Claude, in deiner eigenen Browser-Umgebung auf Webseiten zu navigieren, sie zu lesen und mit ihnen zu interagieren.                                                                                                           |
| [Quellenangaben](https://platform.claude.com/docs/de/build-with-claude/citations)                                                                                    | Die Antworten von Claude zu deinen Dokumenten zitieren die genauen Passagen, die jede Aussage stützen.                                                                                                                                   |
| [Klassifikator-Ablehnungen](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback)                                                             | Sicherheitsklassifikatoren können bei manchen Modellen eine Anfrage ablehnen; die Ablehnung kommt als normale Antwort zurück, nicht als Fehler.                                                                                          |
| ↳ [Clientseitiger Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#client-side-fallback)                                        | Eine Middleware in den Anthropic SDKs, die eine abgelehnte Anfrage auf den von dir aufgeführten Fallback-Modellen wiederholt.                                                                                                            |
| ↳ [Fallback-Gutschrift](https://platform.claude.com/docs/de/build-with-claude/fallback-credit)                                                                       | Rechnet einen Wiederholungsversuch einer abgelehnten Anfrage auf einem anderen Modell so ab, als hätte die Unterhaltung von Anfang an auf diesem Modell stattgefunden, sodass du den Prompt-Cache-Schreibvorgang nicht doppelt bezahlst. |
| ↳ [Serverseitiger Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback)                                        | Die API wiederholt eine abgelehnte Anfrage innerhalb desselben Aufrufs auf einem Fallback-Modell und gibt eine Antwort zurück.                                                                                                           |
| [Computer-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool)                                                                 | Gibt Claude per Screenshots, Maus und Tastatur die Kontrolle über eine Desktop-Umgebung.                                                                                                                                                 |
| [Benutzerdefinierte Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools)                                                               | Tools, die du mit Name, Beschreibung und Eingabeschema definierst. Claude fordert ihren Aufruf an; dein Code führt sie aus und gibt das Ergebnis zurück.                                                                                 |
| [Datenresidenz](https://platform.claude.com/docs/de/manage-claude/data-residency)                                                                                    | Einstellungen dafür, wo die Modellinferenz läuft (Inference-Geo) und wo Daten im Ruhezustand gespeichert werden (Workspace-Geo).                                                                                                         |
| [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)                                                                                               | Eine Einstellung, die steuert, wie viele Tokens Claude für eine Antwort aufwendet, und so Gründlichkeit gegen Token-Effizienz abwägt.                                                                                                    |
| ↳ [Effort pro Nachricht](https://platform.claude.com/docs/de/build-with-claude/effort-per-message)                                                                   | Ändern der Effort-Stufe für spätere Turns einer Unterhaltung mit einem `output_config` pro Nachricht, wodurch der Prompt-Cache erhalten bleibt.                                                                                          |
| [Fast Mode](https://platform.claude.com/docs/de/build-with-claude/fast-mode)                                                                                         | Bis zu 2,5-mal so viele Ausgabetokens pro Sekunde bei unterstützten Modellen, zu Premium-Preisen.                                                                                                                                        |
| [Files API](https://platform.claude.com/docs/de/build-with-claude/files)                                                                                             | Lade eine Datei einmal hoch und referenziere sie in späteren Anfragen per `file_id`, und lade Dateien herunter, die Skills oder das Code-Ausführungstool erstellen.                                                                      |
| [MCP-Connector](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector)                                                                                  | Verbinde Claude mit Remote-MCP-Servern, damit Claude deren Tools aufrufen kann, ohne einen eigenen MCP-Client zu betreiben.                                                                                                              |
| ↳ [Clientseitige MCP-Helfer](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector#client-side-mcp-helpers)                                             | SDK-Helfer, die zwischen MCP-Typen und Claude-API-Typen konvertieren, für den Fall, dass du deinen eigenen MCP-Client betreibst, etwa für lokale Server, Prompts oder Ressourcen.                                                        |
| [MCP-Tunnel](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/overview)                                                                              | Verbinde Claude über eine rein ausgehende Verbindung mit MCP-Servern in deinem privaten Netzwerk, ohne offene eingehende Ports.                                                                                                          |
| [System-Nachrichten mitten in der Unterhaltung](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages)                              | Eine Systemanweisung, die mitten in einer Unterhaltung hinzugefügt wird, ohne den System-Prompt auf oberster Ebene oder das zwischengespeicherte Präfix davor zu ändern.                                                                 |
| ↳ [Tool-Änderungen mitten in der Unterhaltung](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#mid-conversation-tool-changes) | Biete Tools mitten in einer Unterhaltung an oder ziehe sie zurück, ohne das Tools-Array zu ändern, sodass das zwischengespeicherte Präfix gültig bleibt.                                                                                 |
| ↳ [Turn-bezogene System-Nachrichten](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)             | Eine System-Nachricht mitten in der Unterhaltung, die nur bis zur nächsten Benutzernachricht gilt und danach im Verlauf bleibt, aber nichts rendert und keine Eingabetokens kostet.                                                      |
| [Mehrsprachige Unterstützung](https://platform.claude.com/docs/de/build-with-claude/multilingual-support)                                                            | Claude funktioniert in vielen Sprachen, mit starker Leistung im Vergleich zu Englisch.                                                                                                                                                   |
| [OpenTelemetry](https://platform.claude.com/docs/de/manage-claude/opentelemetry)                                                                                     | Erfasst deine Messages-API-Anfragen, Tool-Nutzungen und Managed-Agents-Sitzungen per Tracing mit OpenTelemetry-Spans aus dem Anthropic SDK und der Claude API.                                                                           |
| ↳ [API-Tracing](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api)                                                                                 | OpenTelemetry-Spans, die die Claude API für jede Modellanfrage und jede Tool-Nutzung, die sie ausführt, an deine Observability-Plattform sendet.                                                                                         |
| ↳ [SDK-Tracing](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk)                                                                                 | OpenTelemetry-Spans, die das Anthropic SDK in deiner Anwendung für jede gesendete Anfrage und jedes Tool ausgibt, das sein Tool-Runner ausführt.                                                                                         |
| [Parallele Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/parallel-tool-use)                                                            | Claude kann in einer Antwort mehrere Tools aufrufen.                                                                                                                                                                                     |
| [PDF-Unterstützung](https://platform.claude.com/docs/de/build-with-claude/pdf-support)                                                                               | Sende PDFs an Claude, damit Claude den Text, die Bilder, Diagramme und Tabellen darin lesen kann.                                                                                                                                        |
| [Programmatische Tool-Aufrufe](https://platform.claude.com/docs/de/agents-and-tools/tool-use/programmatic-tool-calling)                                              | Ermöglicht Claude, deine Tools aus Code im Container des Code-Ausführungstools aufzurufen, statt für jeden Aufruf einen eigenen Modell-Roundtrip zu benötigen.                                                                           |
| [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching)                                                                               | Verwendet ein zwischengespeichertes Prompt-Präfix aus einer kürzlichen Anfrage wieder, um Verarbeitungszeit und Kosten zu senken.                                                                                                        |
| ↳ [Dauer von 1 Stunde](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#1-hour-cache-duration)                                                   | Eine Prompt-Cache-Lebensdauer von 1 Stunde, zu einem höheren Cache-Schreibpreis als beim Standard von 5 Minuten.                                                                                                                         |
| ↳ [Dauer von 5 Minuten (Standard)](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#how-prompt-caching-works)                                    | Die Standard-Lebensdauer des Prompt-Caches. Jede Nutzung der zwischengespeicherten Inhalte erneuert sie ohne Zusatzkosten.                                                                                                               |
| ↳ [Automatisches Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#automatic-caching)                                                    | Prompt-Caching mit einem einzigen `cache_control`-Feld auf oberster Ebene: Der Cache-Breakpoint wird auf den letzten cachebaren Block gesetzt und rückt mit wachsender Unterhaltung nach vorn.                                           |
| ↳ [Cache-Diagnose](https://platform.claude.com/docs/de/build-with-claude/cache-diagnostics)                                                                          | Vergleicht eine Anfrage mit deiner vorherigen und meldet, wo sich das Prompt-Präfix geändert hat, um Cache-Misses zu erklären.                                                                                                           |
| ↳ [Explizite Cache-Breakpoints](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#explicit-cache-breakpoints)                                     | Prompt-Caching mit `cache_control` an einzelnen Content-Blöcken, um genau festzulegen, was zwischengespeichert wird.                                                                                                                     |
| [SDK-Middleware](https://platform.claude.com/docs/de/cli-sdks-libraries/middleware)                                                                                  | Ein Hook in den Anthropic SDKs, der deinen Code ausführt, bevor jede Anfrage gesendet wird und nachdem ihre Antwort empfangen wurde.                                                                                                     |
| [Suchergebnisse](https://platform.claude.com/docs/de/build-with-claude/search-results)                                                                               | Content-Blöcke mit deinen eigenen Suchergebnissen, mit Quelle und Titel, damit Claude sie genauso zitieren kann wie Ergebnisse des Web-Search-Tools.                                                                                     |
| [Service-Tiers](https://platform.claude.com/docs/de/api/service-tiers)                                                                                               | Ermöglicht einer Anfrage, die Priority-Tier-Kapazität deiner Organisation zu nutzen.                                                                                                                                                     |
| [Sitzungsbudgets](https://platform.claude.com/docs/de/managed-agents/budgets)                                                                                        | Ein festes Ausgabenlimit in US-Dollar für eine Sitzung, gemessen an öffentlichen Listenpreisen.                                                                                                                                          |
| [Streaming-Ablehnungen](https://platform.claude.com/docs/de/test-and-evaluate/strengthen-guardrails/handle-streaming-refusals)                                       | Eine gestreamte Antwort endet mit `stop_reason` `"refusal"`, wenn Streaming-Klassifikatoren sie wegen eines möglichen Richtlinienverstoßes stoppen.                                                                                      |
| [Strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs)                                                                   | Beschränkt die Antwort von Claude auf ein von dir vorgegebenes JSON Schema, sodass die Ausgabe gültig und parsebar ist.                                                                                                                  |
| [Task-Budgets](https://platform.claude.com/docs/de/build-with-claude/task-budgets)                                                                                   | Teilt Claude mit, wie viele Tokens für eine vollständige agentische Schleife zur Verfügung stehen, damit Claude die Arbeit planen und abschließen kann, bevor das Budget aufgebraucht ist.                                               |
| [Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking)                                                                                         | Claude arbeitet ein Problem in Thinking-Blöcken durch, bevor Claude die Antwort schreibt.                                                                                                                                                |
| ↳ [Adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost)                                                           | Nachdenkmodus, in dem Claude für jede Anfrage entscheidet, ob und wie viel nachgedacht wird.                                                                                                                                             |
| ↳ [Erweitertes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking)                                                                  | Manueller Nachdenkmodus, in dem du für jede Anfrage ein festes Token-Budget für das Nachdenken (`budget_tokens`) festlegst.                                                                                                              |
| ↳ [Bewahrtes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking)                                                                   | Claude verwendet Thinking-Blöcke aus früheren Turns nur, wenn das aktuelle Modell sie lesen kann und sich nichts davor (System-Prompt, Tools, frühere Nachrichten) geändert hat.                                                         |
| [Schwellenwert-Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold)                                                            | Automatische Komprimierung: Wenn eine Unterhaltung einen Token-Schwellenwert erreicht, fasst die API älteren Kontext innerhalb der Anfrage zusammen.                                                                                     |
| [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting)                                                                                | Zählt die Tokens in einer Nachricht, bevor du sie an Claude sendest.                                                                                                                                                                     |
| [Tool-Runner](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-runner)                                                                             | Ein SDK-Helfer, der die Tool-Nutzungs-Schleife für dich ausführt: Er führt deine Tools aus, wenn Claude sie aufruft, und sendet die Ergebnisse zurück.                                                                                   |
| [Tool-Search-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-search-tool)                                                                   | Ermöglicht Claude, deinen Tool-Katalog zu durchsuchen und nur die benötigten Tool-Definitionen zu laden.                                                                                                                                 |
| [Vision (Bilder)](https://platform.claude.com/docs/de/build-with-claude/vision)                                                                                      | Claude kann Bilder lesen und analysieren, die du sendest.                                                                                                                                                                                |
| [Web-Domain-Beschränkungen](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions)                                                               | Listen erlaubter oder blockierter Domains, die steuern, welche Websites das Web-Search-Tool und das Web-Fetch-Tool erreichen können.                                                                                                     |
| [Web-Fetch-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool)                                                                       | Ein Server-Tool, mit dem Claude den vollständigen Inhalt von Webseiten und PDF-Dokumenten unter angegebenen URLs abrufen kann.                                                                                                           |
| [Web-Search-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool)                                                                     | Ein Server-Tool, mit dem Claude das Web nach aktuellen Informationen durchsuchen kann.                                                                                                                                                   |

## Funktionen der Messages API

| Funktion                                                                                                                                | Beschreibung                                                                                                                                                                  |
| :-------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Apple Foundation Models](https://platform.claude.com/docs/de/cli-sdks-libraries/libraries/apple-foundation-models)                     | Ein Swift-Paket, das Claude als Sprachmodell im Foundation-Models-Framework von Apple verfügbar macht.                                                                        |
| [Bash-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/bash-tool)                                                    | Ermöglicht Claude, Shell-Befehle anzufordern, die in einer Bash-Sitzung ausgeführt werden, die ihren Zustand zwischen Befehlen beibehält.                                     |
| [Code-Ausführungstool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool)                               | Ermöglicht Claude, Python- und Bash-Code in einem Sandbox-Container auszuführen.                                                                                              |
| [Kontextbearbeitung](https://platform.claude.com/docs/de/build-with-claude/context-editing)                                             | Entfernt ausgewählte Inhalte, etwa alte Tool-Ergebnisse oder alte Thinking-Blöcke, aus dem Unterhaltungsverlauf, während er wächst.                                           |
| [Erzwungene Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools#forcing-tool-use)                  | Bringt Claude dazu, ein Tool oder ein bestimmtes Tool aufzurufen, statt direkt zu antworten.                                                                                  |
| [Memory-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/memory-tool)                                                | Ermöglicht Claude, Informationen über Unterhaltungen hinweg in einem Verzeichnis von Memory-Dateien zu speichern und zu lesen.                                                |
| ↳ [Memory-Tool-Helfer](https://platform.claude.com/docs/de/agents-and-tools/tool-use/memory-tool#implement-the-memory-handler)          | SDK-Helfer, die die Schnittstelle und die Tool-Nutzungs-Schleife des Memory-Tools übernehmen, sodass dein Code nur den Speicher bereitstellt.                                 |
| [Nachrichten-Streaming](https://platform.claude.com/docs/de/build-with-claude/streaming)                                                | Schrittweiser Empfang einer Messages-API-Antwort als Server-Sent Events, während sie generiert wird.                                                                          |
| ↳ [Feingranulares Tool-Streaming](https://platform.claude.com/docs/de/agents-and-tools/tool-use/fine-grained-tool-streaming)            | Streamt die Eingabe eines Tools an deinen Client, während Claude sie schreibt, ohne dass der Server das JSON zuerst puffert und prüft.                                        |
| [Nachrichten-Threads](https://platform.claude.com/docs/de/build-with-claude/message-threads)                                            | Verschaffe lang laufenden Agenten eine kürzere Zeit bis zum ersten Token, besonders in langen Unterhaltungen, indem du in jeder Anfrage nur die neuen Nachrichten sendest.    |
| [Komprimierung auf Anfrage](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand)                                 | Ersetzt die früheren Nachrichten einer Unterhaltung durch eine Zusammenfassung, die Claude schreibt, wenn deine Anwendung sie anfordert.                                      |
| ↳ [Hintergrund-Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-background)                              | Führt die On-Demand-Komprimierungsanfrage aus, während die Unterhaltung mit ihrem vollständigen Verlauf weiterläuft, und setzt die Zusammenfassung ein, sobald sie eintrifft. |
| ↳ [Komprimierung und bewahrtes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/compaction-thinking-blocks)            | Thinking-Blöcke in den Turns, die du nach einer On-Demand-Komprimierung behältst, können bei Modellen mit erhaltenem Nachdenken unter bestimmten Bedingungen gültig bleiben.  |
| ↳ [Komprimierung mit Erhalt der letzten Turns](https://platform.claude.com/docs/de/build-with-claude/compaction-keep-recent-turns)      | On-Demand-Komprimierung, die die älteren Turns zusammenfasst und die letzten Turns nach der Zusammenfassung wörtlich beibehält.                                               |
| ↳ [Komprimierungshelfer des Tool-Runners](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#compact-in-a-loop) | Eine Methode des SDK-Tool-Runners, die die Komprimierungsanfrage für dich sendet, sobald der aktuelle Turn und seine Tool-Aufrufe abgeschlossen sind.                         |
| [OpenAI-SDK-Kompatibilität](https://platform.claude.com/docs/de/cli-sdks-libraries/libraries/openai-sdk)                                | Eine Kompatibilitätsschicht, mit der du die Claude API mit dem OpenAI SDK aufrufen kannst, gedacht zum Testen und Vergleichen von Modellen.                                   |
| [Strikte Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/strict-tool-use)                                   | Sorgt dafür, dass die Tool-Eingaben von Claude immer dem JSON Schema des Tools entsprechen.                                                                                   |
| [Texteditor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/text-editor-tool)                                       | Ermöglicht Claude, Textdateien mit einem von Anthropic definierten Tool anzuzeigen, zu erstellen und zu bearbeiten.                                                           |
| [Typisierte Helfer für strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs#usage)          | SDK-Helfer, die das JSON Schema aus einem Typ in deinem Code erstellen und die Antwort von Claude in diesen Typ parsen.                                                       |

## Funktionen von Managed Agents

| Funktion                                                                                                                          | Beschreibung                                                                                                                                                                                 |
| :-------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Agent-Konfigurationen](https://platform.claude.com/docs/de/managed-agents/agent-setup)                                           | Eine wiederverwendbare, versionierte Konfiguration aus Modell, System-Prompt, Tools, MCP-Servern und Skills, die eine Sitzung ausführt.                                                      |
| [Agent-Toolset](https://platform.claude.com/docs/de/managed-agents/tools)                                                         | Eine Reihe integrierter Tools (bash, read, write, edit, glob, grep, Webabruf und Websuche), die der Agent in seiner Sandbox verwendet.                                                       |
| [Cloud-Sandboxes](https://platform.claude.com/docs/de/managed-agents/environments)                                                | Isolierte Linux-Container auf von Anthropic verwalteter Infrastruktur, in denen die Tools und der Code einer Sitzung ausgeführt werden.                                                      |
| [Agent-Builder in der Console](https://platform.claude.com/docs/de/managed-agents/onboarding)                                     | Eine visuelle Oberfläche in der Claude Console zum Erstellen, Konfigurieren und Testen von Agenten.                                                                                          |
| [Dreams](https://platform.claude.com/docs/de/managed-agents/dreams)                                                               | Ein Job, der einen Memory Store und frühere Sitzungstranskripte liest und einen neuen, neu organisierten Memory Store schreibt.                                                              |
| [Event-Deltas](https://platform.claude.com/docs/de/managed-agents/event-deltas)                                                   | Live-Vorschauen des Antworttexts des Agenten im Event-Stream der Sitzung, während das Modell ihn noch generiert.                                                                             |
| [GitHub-Zugriff](https://platform.claude.com/docs/de/managed-agents/github)                                                       | Zugriff auf GitHub aus einer Sitzung: in der Sandbox eingebundene Repositorys und der GitHub-MCP-Server für Pull Requests.                                                                   |
| [Memory Stores](https://platform.claude.com/docs/de/managed-agents/memory)                                                        | Sammlungen von Textdokumenten, die ein Agent liest und schreibt, sodass Informationen über Sitzungen hinweg erhalten bleiben.                                                                |
| [Multiagenten-Orchestrierung](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration)                        | Ermöglicht es dem Agenten einer Sitzung, Arbeit an andere Agenten zu übergeben, als Subagenten oder in Workflows, und ein Advisor-Modell zu konsultieren.                                    |
| ↳ [Dynamische Workflows](https://platform.claude.com/docs/de/managed-agents/workflow-runs)                                        | Programme, die ein Agent schreibt, um viele Agenten im Hintergrund auszuführen und ihre Ergebnisse zusammenzuführen.                                                                         |
| ↳ [Session-Threads](https://platform.claude.com/docs/de/managed-agents/session-threads)                                           | Der Thread, in dem jeder Agent einer Multiagenten-Sitzung arbeitet und den du auflisten, streamen, unterbrechen und archivieren kannst.                                                      |
| [Ergebnisse](https://platform.claude.com/docs/de/managed-agents/define-outcomes)                                                  | Ein Zielergebnis für eine Sitzung mit einer Bewertungsrubrik, anhand derer ein separater Grader die Arbeit des Agenten prüft, bis das Ziel erreicht ist.                                     |
| [Berechtigungsrichtlinien](https://platform.claude.com/docs/de/managed-agents/permission-policies)                                | Einstellungen, die steuern, ob die integrierten Tools und MCP-Tools des Agenten automatisch ausgeführt werden, auf deine Genehmigung warten oder bei jedem Aufruf vom Server geprüft werden. |
| [Geplante Deployments](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments)                                  | Führt einen Agenten nach einem Cron-Zeitplan aus, sodass der Agent selbstständig Sitzungen startet.                                                                                          |
| [Selbst gehostete Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/self-hosted)                          | Der gesamte Managed-Agents-Dienst auf deiner eigenen Infrastruktur: Du hostest die API, die Agent-Schleife, den Speicher und die Sandboxes.                                                  |
| [Selbst gehostete Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes)                            | Sandboxes auf deiner eigenen Infrastruktur, die die Tool-Aufrufe des Agenten ausführen, während Claude weiterhin bei Anthropic läuft.                                                        |
| ↳ [Memory Stores in selbst gehosteten Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory) | Memory Stores, die dein Worker in eine selbst gehostete Sandbox herunterlädt und zurück in den Store synchronisiert.                                                                         |
| ↳ [Vorgefertigte selbst gehostete Worker](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers)       | Worker in der `ant`-CLI und in den SDKs für Python, TypeScript und Go, die Sitzungen aus einer selbst gehosteten Umgebung übernehmen und deren Tool-Aufrufe ausführen.                       |
| [Sitzungsansicht](https://platform.claude.com/docs/de/managed-agents/session-observability)                                       | Eine Sitzungsansicht in der Claude Console und Nutzungssummen pro Sitzung, um zu sehen, was ein Agent getan und was er verbraucht hat.                                                       |
| [Vaults](https://platform.claude.com/docs/de/managed-agents/vaults)                                                               | Speicher für benutzerspezifische Anmeldedaten für Drittanbieterdienste, die du einmal registrierst und beim Erstellen einer Sitzung per ID referenzierst.                                    |
| [Webhooks](https://platform.claude.com/docs/de/managed-agents/webhooks)                                                           | Benachrichtigungen an deinen HTTPS-Endpunkt, wenn in deinen Managed-Agents-Ressourcen Ereignisse eintreten, etwa eine Änderung des Status einer Sitzung.                                     |
