---
title: Deine Managed-Agents-Bereitstellung absichern
url: https://platform.claude.com/docs/de/managed-agents/secure-deployment
description: Die Einstellungen, die begrenzen, was deine Agenten erreichen und tun können, die wichtigsten zuerst.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Dieser Leitfaden listet die Einstellungen auf, die begrenzen, was ein Agent auf Claude Managed Agents erreichen und tun kann, die wichtigsten zuerst. Jeder Abschnitt verlinkt auf die Seite, die die jeweilige Einstellung vollständig behandelt.
| Abschnitt | Einstellung oder Entscheidung | Empfohlen |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Wählen, wo der Agent läuft](https://platform.claude.com/docs/de/managed-agents/secure-deployment#choose-where-the-agent-runs) | Cloud- oder selbst gehostete Sandbox | Cloud, es sei denn, Tools müssen auf Infrastruktur laufen, die du kontrollierst |
| [Das Netzwerk begrenzen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#limit-the-network) | `networking.type` der Umgebung | `limited`, nur mit den Hosts, die der Agent benötigt |
| [Anmeldedaten in Vaults aufbewahren](https://platform.claude.com/docs/de/managed-agents/secure-deployment#keep-credentials-in-vaults) | `injection_location` und `networking` bei jedem Umgebungsvariablen-Credential | Nur Request-Header und `limited`-Networking nur mit den Hosts, für die der Schlüssel bestimmt ist |
| [Websuche und Web-Fetch einschränken](https://platform.claude.com/docs/de/managed-agents/secure-deployment#restrict-web-search-and-web-fetch) | `allowed_domains` bei jedem Web-Tool | Eine Allowlist bei jedem Tool. Liste bei `web_fetch` nur die Websites auf, die der Agent benötigt. Liste bei `web_search` die Websites auf, von denen du Ergebnisse möchtest |
| [Riskante Aktionen genehmigen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#approve-risky-actions) | `permission_policy` bei jedem Tool | `auto` bei `bash`, `write`, `edit`, `web_fetch` und MCP-Tools, die nur Daten lesen. Stattdessen `always_ask` bei einem Tool, wenn du seine Änderungen außerhalb der Sandbox nicht rückgängig machen kannst oder wenn weitergeleiteter Endbenutzertext allein es nicht ausführen lassen soll |
| [Dem Agenten den kleinsten Tool-Satz geben](https://platform.claude.com/docs/de/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) | `default_config.enabled` beim Agent-Toolset | `false`, dann aktiviere die Tools, die der Agent benötigt |
| [Nicht vertrauenswürdige Eingaben von mächtigen Tools fernhalten](https://platform.claude.com/docs/de/managed-agents/secure-deployment#keep-untrusted-input-away-from-powerful-tools) | Welche Tools und Anmeldedaten ein Agent besitzt, wenn er nicht vertrauenswürdige Eingaben liest | Kein Agent, der nicht vertrauenswürdige Eingaben liest, hat ein Tool auf `always_allow`, das Dateien schreibt, Befehle ausführt oder Datensätze ändert |
| [Limits und eine Möglichkeit zum Stoppen festlegen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#set-limits-and-a-way-to-stop) | `budget` bei jeder Session und jedem Deployment | Eine Obergrenze, die darauf abgestimmt ist, was eine Ausführung voraussichtlich kostet |
| [Optional einen Offline-Reviewer jedes Transkript lesen lassen](https://platform.claude.com/docs/de/managed-agents/secure-deployment-monitoring#optionally-have-an-offline-reviewer-read-every-transcript) | Ein von dir ausgeführter Offline-Review-Job, der die Events jeder Session liest | Optional. Eine Prüfung jeder Session, die in den Leerlauf gegangen ist oder beendet wurde, nach Zeitplan |
| [Sessions überwachen und Aufbewahrung überprüfen](https://platform.claude.com/docs/de/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention) | Webhooks und Löschen von Sessions | Eine Benachrichtigung, wenn eine Session in den Leerlauf geht, ihr Budget erreicht oder beendet wird, und eine Prüfung, warum sie in den Leerlauf gegangen ist. Speichere die Events, die du behalten möchtest, in deinen eigenen Logs, und lösche Sessions, die du nicht mehr benötigst |
[Sicherheitsrisiken und Sandbox-Grenzen](https://platform.claude.com/docs/de/managed-agents/secure-deployment-risks) erklärt, warum diese Einstellungen wichtig sind und wovor sie nicht schützen. Informationen zum Prüfen und Überwachen von Sessions findest du unter [Agent-Sessions überprüfen und überwachen](https://platform.claude.com/docs/de/managed-agents/secure-deployment-monitoring).
## Wählen, wo der Agent läuft
Wo die Tools des Agenten laufen, entscheidet darüber, wer die „sandbox“ (isolierte Ausführungsumgebung) absichert: Anthropic bei einer Cloud-Umgebung oder du bei einer selbst gehosteten Sandbox. Wie du zwischen beiden wählst und was jeweils an Anthropic gelangt, erfährst du unter [Eine Agent-Umgebung auswählen](https://platform.claude.com/docs/de/managed-agents/choosing-an-environment).
Wenn du eine [selbst gehostete Sandbox](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes) verwendest, beachte diese vier Punkte:
* **Netzwerk:** [Das Netzwerk begrenzen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#limit-the-network) gilt für Cloud-Umgebungen. Lege für eine selbst gehostete Sandbox die entsprechenden Limits für ihren Datenverkehr in deiner eigenen Firewall fest. Deine Firewall begrenzt nicht die MCP-Server, die ein Agent deklariert, also prüfe diese sowie alle, die deine Anwendung für eine Session festlegt.
* **Web-Tools:** Die Web-Tools laufen auf den Servern von Anthropic, daher begrenzt deine Firewall sie nicht. Begrenze sie mit ihren Domainlisten. Siehe [Websuche und Web-Fetch einschränken](https://platform.claude.com/docs/de/managed-agents/secure-deployment#restrict-web-search-and-web-fetch).
* **Anmeldedaten:** Umgebungsvariablen-Credentials werden bei selbst gehosteten Sandboxes noch nicht unterstützt.
* **Isolation und Härtung:** Du bist für beides verantwortlich. Siehe das [Sicherheitsmodell](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-security).
Keine der beiden Optionen ändert die Compliance-Abdeckung von Managed Agents oder wie lange der Session-Verlauf aufbewahrt wird. Siehe [Sessions überwachen und Aufbewahrung überprüfen](https://platform.claude.com/docs/de/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention).
## Das Netzwerk begrenzen
Setze `networking.type` auf `limited` und liste in `allowed_hosts` nur die Hosts auf, die der Agent benötigt. Eine Anfrage zum Erstellen einer Umgebung, die `networking` weglässt, erhält möglicherweise `unrestricted`, also setze `networking` in jeder Erstellungsanfrage. Siehe [Risiken von uneingeschränktem Networking](https://platform.claude.com/docs/de/managed-agents/environments#risks-of-unrestricted-networking).
Dateien, Memory Stores und GitHub-Repositories, die du anhängst, bleiben für den Agenten unabhängig von `allowed_hosts` verfügbar.
Die Beispiele auf dieser Seite verwenden einen Support-Agenten. Er liest das Ticket eines Kunden, schlägt die Bestellung nach, liest dein Hilfe-Center und entwirft eine Antwort. Deine Anwendung führt die Bestellabfrage aus, die keinen Host benötigt, daher erlaubt diese Umgebung einen Host, das Hilfe-Center, für `web_fetch`:
```bash cURL
curl -fsS https://api.anthropic.com/v1/environments \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "support-agent",
"config": {
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"]
}
}
}'
```
```bash CLI
ant apply environment.yaml
```
```yaml
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
name: support-agent
config:
type: cloud
networking:
type: limited
allowed_hosts:
- help.example.com
```
```python Python
environment = client.beta.environments.create(
name="support-agent",
config={
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"],
},
},
)
```
```typescript TypeScript
const environment = await client.beta.environments.create({
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
});
```
```csharp C#
using Anthropic.Models.Beta.Environments;
var environment = await client.Beta.Environments.Create(new()
{
Name = "support-agent",
Config = new BetaCloudConfigParams
{
Networking = new BetaLimitedNetworkParams
{
AllowedHosts = ["help.example.com"],
},
},
});
```
```go Go
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
Name: "support-agent",
Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
OfCloud: &anthropic.BetaCloudConfigParams{
Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
OfLimited: &anthropic.BetaLimitedNetworkParams{
AllowedHosts: []string{"help.example.com"},
},
},
},
},
})
if err != nil {
panic(err)
}
_ = environment
```
```java Java
import com.anthropic.models.beta.environments.*;
import java.util.List;
var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
.name("support-agent")
.config(BetaCloudConfigParams.builder()
.networking(BetaLimitedNetworkParams.builder()
.allowedHosts(List.of("help.example.com"))
.build())
.build())
.build());
```
```php PHP
$environment = $client->beta->environments->create(
name: 'support-agent',
config: [
'type' => 'cloud',
'networking' => [
'type' => 'limited',
'allowed_hosts' => ['help.example.com'],
],
],
);
```
```ruby Ruby
environment = client.beta.environments.create(
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
)
```
Eine `limited`-Umgebung hat drei Networking-Einstellungen:
| Einstellung | Was sie für Code in der Sandbox öffnet | Empfohlen |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowed_hosts` | Die Hosts, die du auflistest, für jede Anfrage | Nur die Hosts, die der Agent benötigt, einschließlich des Hosts jedes MCP-Servers, den du betreibst oder dem du vertraust |
| `allow_package_managers` | Die [Paketmanager-Hosts](https://platform.claude.com/docs/de/managed-agents/environments#package-manager-hosts). Sie umfassen jedes Repository und jeden Pfad auf `github.com`, `gitlab.com` und `bitbucket.org`, wo jeder Inhalte veröffentlichen kann und wo Code in der Sandbox Dateien hochladen kann | `false`, es sei denn, die `packages`-Einstellung der Umgebung listet Pakete auf, was `true` erfordert. Wenn der Agent während der Ausführung Pakete installiert, liste stattdessen nur die benötigten Registry-Hosts in `allowed_hosts` auf |
| `allow_mcp_servers` | Keinen Host. Managed Agents verbindet sich von den Servern von Anthropic aus mit MCP-Servern | `false`, wobei der Host jedes MCP-Servers, den du betreibst oder dem du vertraust, in `allowed_hosts` aufgelistet ist |
Die Einstellungen `allow_package_managers` und `allow_mcp_servers` fügen keine Hosts für Websuche und Web-Fetch hinzu.
Lass `allow_mcp_servers` deaktiviert, was der Standard ist, und liste den Host jedes MCP-Servers, den du betreibst oder dem du vertraust, in `allowed_hosts` auf. Jeder Host, den du auflistest, ist auch für Code in der Sandbox offen. Bei deaktiviertem `allow_mcp_servers` lehnt eine Prüfung bei der Session-Erstellung die Anfrage ab, wenn der Host eines MCP-Servers nicht aufgelistet ist. Siehe [Authentifizierung bei der Session-Erstellung bereitstellen](https://platform.claude.com/docs/de/managed-agents/mcp-connector#provide-authentication-at-session-creation). Dieselbe Prüfung läuft, wenn ein Session-Update `mcp_servers` ändert.
Netzwerkzugriff wird pro Host gewährt, nicht pro Operation. Die Sandbox kann jede Anfrage an einen erlaubten Host senden, einschließlich Uploads wie `git push` und das Veröffentlichen von Paketen. Sie kann auch alle Anmeldedaten verwenden, die der Befehl bereitstellt, selbst solche, die jemand in Text versteckt hat, den der Agent liest.
Wenn du Hosts für `allowed_hosts` auswählst, befolge diese zwei Regeln:
* Liste nur Hosts auf, die du betreibst oder denen du vertraust.
* Vermeide `*.`-Wildcards und Shared-Hosting-Domains, auf denen jeder Inhalte veröffentlichen kann.
Wenn der Agent `bash` behält, lege die [Berechtigungsrichtlinie](https://platform.claude.com/docs/de/managed-agents/permission-policies) des `bash`-Tools so fest, wie es [Riskante Aktionen genehmigen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#approve-risky-actions) beschreibt.
Nachdem du eine Umgebung stärker eingeschränkt hast, starte neue Sessions und stoppe die bereits laufenden. Eine bereits laufende Session kann die alten Limits behalten, bis sie endet. Siehe [Limits und eine Möglichkeit zum Stoppen festlegen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#set-limits-and-a-way-to-stop).
Alle Networking-Einstellungen findest du unter [Einrichtung der Cloud-Umgebung](https://platform.claude.com/docs/de/managed-agents/environments#networking).
## Anmeldedaten in Vaults aufbewahren
Speichere jedes Secret in einem „vault“ (Tresor). Lege für jedes Umgebungsvariablen-Credential den Injektionsort auf ausschließlich Request-Header fest und liste nur die Hosts auf, für die das Secret bestimmt ist. Code in der Sandbox sieht einen Platzhalter statt des Secrets. Managed Agents setzt das echte Secret nur in ausgehende HTTPS-Anfragen an die Hosts ein, die das Credential erlaubt. So bleibt das Secret außerhalb der direkten Reichweite des Modells, es sei denn, ein Dienst sendet es zurück, etwa ein Endpunkt, der Request-Header zurückgibt. Wenn das `networking` des Credentials `unrestricted` ist, setzt Managed Agents das echte Secret in Anfragen an jeden Host ein, den die Umgebung die Sandbox erreichen lässt. Um einen Vault zu verwenden, übergib seine ID in `vault_ids`, wenn du die Session oder das Deployment erstellst.
| Einstellung | Setze sie auf | Warum | Was sie nicht tut |
| -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injection_location` | `{"header": true, "body": false}`, nachdem du geprüft hast, dass der Dienst den Schlüssel aus einem Header liest | Request-Bodys werden oft aus Inhalten erstellt, die der Agent liest, daher ist ein Schlüssel in einem Body stärker exponiert. Benenne beide Felder: Eine Erstellungsanfrage, die das Objekt weglässt, aktiviert beide Orte, und ein Update ändert nur die Felder, die du sendest | Code kann den Schlüssel weiterhin auf jedem Host verwenden, den das Credential erlaubt. Ein Dienst, der den Schlüssel im Body erwartet, erhält den Platzhalter und lehnt die Anfrage ab |
| `networking` beim Credential | `limited`, mit genau den Hosts, für die der Schlüssel bestimmt ist | Antworten erreichen die Sandbox ungeschwärzt, also vermeide Wildcards, Shared-Hosting-Domains und Hosts, die Request-Header zurückgeben | Sie öffnet den Host nicht. Die Umgebung muss ihn ebenfalls erlauben |
| Die Berechtigungen des Schlüssels beim Dienst, der den Schlüssel ausgestellt hat | Nur die Berechtigungen, die der Agent benötigt | Der Agent kann alles tun, was der Schlüssel erlaubt | Nicht zutreffend |
| Das GitHub-Token eines eingebundenen Repositorys | Ein [fein granuliertes Token](https://platform.claude.com/docs/de/managed-agents/github#token-permissions) mit den minimalen Berechtigungen | Code in der Sandbox kann damit während der gesamten Session aus dem eingebundenen Repository abrufen und dorthin pushen. Gewähre Schreibzugriff nur, wenn der Agent pushen muss | Nicht zutreffend |
Der Support-Agent benötigt kein Vault-Credential, da deine Anwendung den API-Key für deine Bestell-API hält. Wenn dein Agent ein Vault-Credential hält, findest du die Anfrage in jeder Sprache unter [Ein Credential hinzufügen](https://platform.claude.com/docs/de/managed-agents/vaults#add-a-credential).
Halte Schlüssel aus System-Prompts, Agentendefinitionen und Nachrichten heraus. Gib dem Agenten keinen Claude-API-Key. Selbst wenn sich ein Claude-API-Key in einem Vault befindet, kann Code in der Sandbox ihn verwenden, um die Claude API direkt aufzurufen. Er kann alles tun, was dieser Schlüssel erlaubt, etwa Sessions starten oder löschen oder Websuche und Web-Fetch verwenden. Die Tool-Einstellungen, Genehmigungen und das Budget des Agenten gelten für diese Aufrufe nicht. In einer `limited`-Umgebung kann Code diese Aufrufe nur tätigen, wenn `allowed_hosts` die Sandbox `api.anthropic.com` erreichen lässt.
Rufe Tokens selbst ab und speichere sie im Vault, denn ein Token, das Code in der Sandbox mit einem gespeicherten Secret abruft, kommt ungeschwärzt zurück.
Bewahre Vaults für Workloads mit unterschiedlichen Vertrauensstufen in separaten [Workspaces](https://platform.claude.com/docs/de/manage-claude/workspaces) auf, da jeder API-Key mit Zugriff auf einen Workspace dessen Vaults referenzieren kann. Verwende API-Keys, die auf einen Workspace beschränkt sind.
Informationen zu MCP-Credentials und Rotation findest du unter [Mit Vaults authentifizieren](https://platform.claude.com/docs/de/managed-agents/vaults).
## Websuche und Web-Fetch einschränken
Setze `allowed_domains` bei `web_fetch` auf die Websites, die der Agent benötigt. Jede URL, die der Agent abruft, kann Daten an die Website übertragen, auf die sie verweist, daher ist diese Liste eine Sicherheitskontrolle. Setze bei `web_search` `allowed_domains` auf die Websites, von denen du Ergebnisse möchtest, sodass Ergebnisse nur von Websites stammen, deren Genauigkeit du vertraust. Die Liste verhindert nicht, dass die Suchanfrage den Suchanbieter erreicht. Suchergebnisse enthalten Text von Seiten, daher begrenzt die Liste auch, von welchen Websites Text den Agenten erreicht. Setze `allowed_domains` bei beiden Tools für jeden Umgebungstyp.
Eine `blocked_domains`-Liste blockiert die Hosts, die du auflistest, und deren Subdomains, und keinen anderen Host. Derselbe Inhalt kann den Agenten weiterhin über Webarchive, Caches, Mirrors oder verwandte Domains erreichen, die du nicht aufgelistet hast. Verlasse dich für die Sicherheit nicht auf `blocked_domains`. Verwende `allowed_domains` und benenne die Hosts, denen du vertraust.
In einer `limited`-Umgebung begrenzt die `allowed_hosts`-Liste aus [Das Netzwerk begrenzen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#limit-the-network) auch die Web-Tools. Eine `unrestricted`-Umgebung oder eine selbst gehostete Sandbox begrenzt die Web-Tools nicht.
| In einer `limited`-Umgebung | Ergebnis |
| ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Ein `allowed_domains`-Eintrag bei einem aktivierten Web-Tool liegt außerhalb von `allowed_hosts` | Das Erstellen einer Session schlägt mit einem 400-Fehler fehl, ebenso ein Session-Update, das einen solchen Eintrag hinzufügt. Eine Session, die ein Deployment nach seinem Zeitplan oder durch eine manuelle Ausführung startet, wird trotzdem erstellt. Das Tool gibt dann nichts von Hosts außerhalb von `allowed_hosts` zurück |
| Ein Web-Tool hat keine eigene Liste | Das Tool gibt Seiten und Ergebnisse nur von Hosts in `allowed_hosts` zurück. Setze zusätzlich `allowed_domains` beim Tool |
| `allowed_hosts` hat keine Einträge | Keines der Web-Tools gibt eine Seite oder ein Suchergebnis zurück |
| Du fügst `allowed_hosts` einen Host für ein Web-Tool hinzu | Der Host ist auch für Code in der Sandbox offen |
Die beiden Listen gleichen Hosts unterschiedlich ab:
| Liste | Eintrag | Passt auf | Passt nicht auf |
| ---------------------------- | --------------- | -------------------------------- | ----------------- |
| `allowed_hosts` (Umgebung) | `example.com` | `example.com` | `www.example.com` |
| `allowed_hosts` (Umgebung) | `*.example.com` | Jede Subdomain | `example.com` |
| `allowed_domains` (Web-Tool) | `example.com` | `example.com` und jede Subdomain | Andere Domains |
Wenn der Agent eine Website und alle ihre Subdomains benötigt, liste sowohl `example.com` als auch `*.example.com` in `allowed_hosts` auf, und liste andernfalls exakte Hosts auf. Wenn ein Tool `example.com` auflistet und `allowed_hosts` nur `*.example.com` auflistet, wird die Session erstellt. Die Prüfung bei der Session-Erstellung zählt `example.com` als innerhalb von `*.example.com`, aber das Tool gibt nichts von `example.com` selbst zurück. Wie die beiden Listen abgleichen, erfährst du unter [Domainlisten für einen Agenten festlegen](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions#set-domain-lists-on-an-agent).
Das `web_fetch`-Tool öffnet außerdem nur URLs, die bereits in der Session aufgetaucht sind:
| Wo die URL auftaucht | `web_fetch` kann sie öffnen |
| -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| Der Text einer Benutzernachricht, einschließlich Endbenutzertext, den du weiterleitest | Ja |
| Die Beschreibung eines `user.define_outcome`-Events | Ja |
| Die Adresse eines Websuchergebnisses | Ja |
| Der Text einer Seite, die `web_fetch` zuvor zurückgegeben hat (kein PDF), in dem die vollständige URL angezeigt wird | Ja |
| Der Text des Ergebnisses eines benutzerdefinierten Tools, wenn Claude das Tool direkt aufgerufen hat | Ja, es sei denn, das Ergebnis ist mit `is_error: true` markiert |
| Der System-Prompt | Nein |
| Die Konfiguration des Agenten, einschließlich `allowed_domains`-Einträgen | Nein |
| Claudes eigene Ausgabe | Nein |
| Ausgabe von `bash` und den anderen Sandbox-Tools | Nein |
| Ein MCP-Tool-Ergebnis | Nein |
| Eine an eine Benutzernachricht angehängte Datei | Nein |
In einer Multiagenten-Session öffnet `web_fetch` eine URL von einem anderen Agenten nur, wenn sie diesen Agenten über eine mit Ja markierte Quelle erreicht hat. Das Ergebnis eines benutzerdefinierten Tools aus einem direkten Aufruf zählt als mit Ja markierte Quelle. Das gilt auch, wenn Claude dessen Text geschrieben hat, zum Beispiel wenn das Tool seine Eingabe wiederholt. Eine URL kann auch dann zählen, wenn sie ohne `https://` geschrieben ist, etwa `example.com/docs`. Das `web_fetch`-Tool kann einen Link, der Wörter statt seiner URL anzeigt, wie „Support kontaktieren“, nicht immer öffnen. Wenn der Agent eine URL abrufen muss, die nicht in der Session aufgetaucht ist, sende sie in einer Benutzernachricht.
Diese Regel verringert die Wahrscheinlichkeit, dass eingeschleuster Text eine URL erstellt, die private Daten überträgt. Endbenutzertext, Suchergebnisse, abgerufene Seiten und Ergebnisse benutzerdefinierter Tools können weiterhin URLs hinzufügen, also lass `allowed_domains` gesetzt. Die Messages API wendet eine ähnliche Regel mit einer anderen Liste von Quellen an. Siehe [URL-Validierung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#url-validation).
Eine Domainliste bei `web_fetch` begrenzt das `bash`-Tool nicht. [Das Netzwerk begrenzen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#limit-the-network) ebenfalls. Siehe [Regeln für Domainlisten](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions#domain-list-rules).
## Riskante Aktionen genehmigen
Setze `auto` bei `bash`, `write`, `edit` und `web_fetch` sowie bei MCP-Tools, die nur Daten lesen. Verwende stattdessen `always_ask` bei einem Tool, wenn du seine Änderungen außerhalb der Sandbox nicht rückgängig machen kannst. Verwende es auch bei einem Tool, das nicht allein deshalb ausgeführt werden soll, weil von dir weitergeleiteter Endbenutzertext danach verlangt. Eine [Berechtigungsrichtlinie](https://platform.claude.com/docs/de/managed-agents/permission-policies) bestimmt, ob ein Tool-Aufruf ausgeführt wird, auf deine Genehmigung wartet oder vom Server bewertet wird.
| Tool | Empfohlene Richtlinie | Warum |
| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `read`, `glob`, `grep` | `always_allow` | Sie lesen Dateien in der Sandbox und ändern nichts |
| `bash`, `write`, `edit` | `auto`. Verwende `always_ask` bei einem Tool, wenn du seine Änderungen außerhalb der Sandbox nicht rückgängig machen kannst. Verwende `always_ask` bei `bash`, wenn du Endbenutzertext weiterleitest | Der Standard des Agent-Toolsets ist `always_allow`, was jeden Aufruf ohne Genehmigung ausführt |
| `web_fetch` | `auto` | Eine URL, die der Agent abruft, kann Daten an die Website übertragen, auf die sie verweist |
| `web_search` | `always_ask`, wenn der Agent Daten verarbeitet, die du nicht in einer Suchanfrage gesendet haben möchtest. Andernfalls `always_allow` | `allowed_domains` begrenzt, von welchen Websites Ergebnisse stammen, nicht, was die Anfrage enthält |
| MCP-Tools, die nur Daten lesen | `auto`, für jedes Tool in den `configs` des Toolsets festgelegt | Der Toolset-Standard bleibt `always_ask`, sodass ein Tool, das der MCP-Server später hinzufügt, weiterhin auf Genehmigung wartet |
| MCP-Tools, die Daten ändern | `always_ask` | Dies ist der Standard des MCP-Toolsets. Behalte ihn bei |
| Benutzerdefinierte Tools | Dein Code entscheidet, ob jeder Aufruf ausgeführt wird | Berechtigungsrichtlinien gelten nicht |
Das Toolset in [Dem Agenten den kleinsten Tool-Satz geben](https://platform.claude.com/docs/de/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) wendet diese Richtlinien an.
Die [`auto`-Richtlinie](https://platform.claude.com/docs/de/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto) lässt den Server einen Aufruf ausführen, ablehnen oder für eine Genehmigung pausieren. Eine Person kann nicht jeden Aufruf in einer langen Ausführung genehmigen, daher prüft stattdessen der Server jeden einzelnen. Kombiniere `auto` mit eingeschränktem Networking, einem Schlüssel mit eng gefassten Berechtigungen, einem Budget und einer Benachrichtigung bei Sessions im Leerlauf. `auto` ist kein menschlicher Kontrollpunkt. Wenn also eine Person die Aufrufe eines Tools prüfen muss, bevor sie ausgeführt werden, konfiguriere `always_ask` bei diesem Tool.
`auto` behandelt Text in `user.message`-Events und die Beschreibung in einem `user.define_outcome`-Event als deine Anweisung, einschließlich Endbenutzertext, den du weiterleitest.
Eine pausierte Session wartet unbegrenzt, daher benötigt eine unbeaufsichtigte Session einen Client, der pausierte Aufrufe beantwortet oder die Session unterbricht.
Prüfe jeden pausierten Aufruf, bevor du ihn erlaubst. Ein Client, der jeden Aufruf erlaubt, ohne ihn einer Person zu zeigen, ist dasselbe wie `always_allow`. Siehe [Auf Bestätigungsanfragen antworten](https://platform.claude.com/docs/de/managed-agents/permission-policies#respond-to-confirmation-requests) und [Sehen, wie jeder Aufruf bewertet wurde](https://platform.claude.com/docs/de/managed-agents/permission-policies#see-how-each-call-was-evaluated).
## Dem Agenten den kleinsten Tool-Satz geben
Setze `default_config.enabled` auf `false` und [aktiviere nur die Tools, die der Agent benötigt](https://platform.claude.com/docs/de/managed-agents/tools#enabling-only-specific-tools). Das Agent-Toolset aktiviert standardmäßig alle acht integrierten Tools.
| Tool | Was es tut |
| ------------------------- | -------------------------------------------------------------------------------- |
| `bash` | Führt jeden Befehl aus, einschließlich Anfragen an erlaubte Hosts |
| `write`, `edit` | Ändern Dateien in der Sandbox |
| `read`, `glob`, `grep` | Lesen Dateien in der Sandbox |
| `web_fetch`, `web_search` | Geben Seiten und Suchergebnisse aus dem Web über die Server von Anthropic zurück |
Der Support-Agent benötigt drei integrierte Tools: `read` und `write` für seinen Entwurf und `web_fetch` für das Hilfe-Center. Er schlägt Bestellungen über ein [benutzerdefiniertes Tool](https://platform.claude.com/docs/de/managed-agents/tools#custom-tools), `lookup_order`, nach, das deine Anwendung ausführt. Deine Anwendung hält den API-Key für deine Bestell-API, daher benötigt der Agent weder `bash` noch Anmeldedaten.
Das folgende Beispiel begrenzt `web_fetch` mit `allowed_domains` auf `help.example.com`. Es setzt `auto` bei `write` und `web_fetch`, wie es [Riskante Aktionen genehmigen](https://platform.claude.com/docs/de/managed-agents/secure-deployment#approve-risky-actions) empfiehlt. Wenn das Ticket eines Kunden den Agenten dazu bringt, diese Tools zu verwenden, kann der Agent nur Dateien in der Sandbox ändern oder Seiten des Hilfe-Centers öffnen. Deshalb benötigt keines der beiden Tools `always_ask`. Das Beispiel setzt außerdem `always_ask` in `default_config`, sodass ein Tool, das du später ohne eigene Richtlinie aktivierst, `always_ask` verwendet:
```bash cURL
tools='[
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": false,
"permission_policy": {"type": "always_ask"}
},
"configs": [
{"name": "read", "enabled": true, "permission_policy": {"type": "always_allow"}},
{"name": "write", "enabled": true, "permission_policy": {"type": "auto"}},
{
"name": "web_fetch",
"enabled": true,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"}
}
]
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string", "description": "The order ID from the ticket"}
},
"required": ["order_id"]
}
}
]'
```
```bash CLI
ant apply agent.md
```
```markdown
---
name: Support Agent
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
default_config:
enabled: false
permission_policy:
type: always_ask
configs:
- name: read
enabled: true
permission_policy:
type: always_allow
- name: write
enabled: true
permission_policy:
type: auto
- name: web_fetch
enabled: true
allowed_domains: [help.example.com]
permission_policy:
type: auto
- type: custom
name: lookup_order
description: Look up one order by its ID. Returns the status, the items, and the delivery date.
input_schema:
type: object
properties:
order_id:
type: string
description: The order ID from the ticket
required:
- order_id
---
```
```python Python
tools = [
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": False,
"permission_policy": {"type": "always_ask"},
},
"configs": [
{
"name": "read",
"enabled": True,
"permission_policy": {"type": "always_allow"},
},
{
"name": "write",
"enabled": True,
"permission_policy": {"type": "auto"},
},
{
"name": "web_fetch",
"enabled": True,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"},
},
],
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "The order ID from the ticket",
},
},
"required": ["order_id"],
},
},
]
```
```typescript TypeScript
const tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: { type: "always_ask" }
},
configs: [
{
name: "read",
enabled: true,
permission_policy: { type: "always_allow" }
},
{
name: "write",
enabled: true,
permission_policy: { type: "auto" }
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: { type: "auto" }
}
]
},
{
type: "custom",
name: "lookup_order",
description:
"Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {
order_id: { type: "string", description: "The order ID from the ticket" }
},
required: ["order_id"]
}
}
] satisfies Anthropic.Beta.AgentCreateParams["tools"];
```
```csharp C#
using System.Text.Json;
using Anthropic.Models.Beta.Agents;
using Tool = Anthropic.Models.Beta.Agents.Tool;
Tool[] tools =
[
new BetaManagedAgentsAgentToolset20260401Params
{
Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
DefaultConfig = new()
{
Enabled = false,
PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" },
},
Configs =
[
new BetaManagedAgentsReadToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy { Type = "always_allow" },
},
new BetaManagedAgentsWriteToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
new BetaManagedAgentsWebFetchToolConfigParams
{
Enabled = true,
AllowedDomains = ["help.example.com"],
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
],
},
new BetaManagedAgentsCustomToolParams
{
Type = "custom",
Name = "lookup_order",
Description = "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema = new()
{
Properties = new Dictionary
{
["order_id"] = JsonSerializer.SerializeToElement(
new { type = "string", description = "The order ID from the ticket" }
),
},
Required = ["order_id"],
},
},
];
```
```go Go
tools := []anthropic.BetaAgentNewParamsToolUnion{{
OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
Enabled: anthropic.Bool(false),
PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
},
},
},
Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
{OfRead: &anthropic.BetaManagedAgentsReadToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsReadToolConfigParamsPermissionPolicyUnion{
OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
},
},
}},
{OfWrite: &anthropic.BetaManagedAgentsWriteToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWriteToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
{OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
AllowedDomains: []string{"help.example.com"},
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWebFetchToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
},
},
}, {
OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
Type: anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
Name: "lookup_order",
Description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema: anthropic.BetaManagedAgentsCustomToolInputSchemaParam{
Properties: map[string]any{
"order_id": map[string]any{
"type": "string",
"description": "The order ID from the ticket",
},
},
Required: []string{"order_id"},
},
},
}}
_ = tools
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.agents.*;
import java.util.List;
import java.util.Map;
var tools = List.of(
AgentCreateParams.Tool.ofAgentToolset20260401(
BetaManagedAgentsAgentToolset20260401Params.builder()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.defaultConfig(
BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
.enabled(false)
.permissionPolicy(
BetaManagedAgentsAlwaysAskPolicy.builder()
.type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsReadToolConfigParams.builder()
.enabled(true)
.permissionPolicy(
BetaManagedAgentsAlwaysAllowPolicy.builder()
.type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsWriteToolConfigParams.builder()
.enabled(true)
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.addConfig(
BetaManagedAgentsWebFetchToolConfigParams.builder()
.enabled(true)
.allowedDomains(List.of("help.example.com"))
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.build()
),
AgentCreateParams.Tool.ofCustom(
BetaManagedAgentsCustomToolParams.builder()
.type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
.name("lookup_order")
.description("Look up one order by its ID. Returns the status, the items, and the delivery date.")
.inputSchema(
BetaManagedAgentsCustomToolInputSchema.builder()
.properties(
BetaManagedAgentsCustomToolInputSchema.Properties.builder()
.putAdditionalProperty("order_id", JsonValue.from(Map.of(
"type", "string",
"description", "The order ID from the ticket")))
.build()
)
.addRequired("order_id")
.build()
)
.build()
)
);
```
```php PHP
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAutoPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolInputSchema;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolParams;
use Anthropic\Beta\Agents\BetaManagedAgentsReadToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWriteToolConfigParams;
$tools = [
BetaManagedAgentsAgentToolset20260401Params::with(
type: 'agent_toolset_20260401',
defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
enabled: false,
permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'),
),
configs: [
BetaManagedAgentsReadToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(type: 'always_allow'),
),
BetaManagedAgentsWriteToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
BetaManagedAgentsWebFetchToolConfigParams::with(
allowedDomains: ['help.example.com'],
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
],
),
BetaManagedAgentsCustomToolParams::with(
type: 'custom',
name: 'lookup_order',
description: 'Look up one order by its ID. Returns the status, the items, and the delivery date.',
inputSchema: BetaManagedAgentsCustomToolInputSchema::with(
properties: ['order_id' => ['type' => 'string', 'description' => 'The order ID from the ticket']],
required: ['order_id'],
),
),
];
```
```ruby Ruby
tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: {type: "always_ask"}
},
configs: [
{
name: "read",
enabled: true,
permission_policy: {type: "always_allow"}
},
{
name: "write",
enabled: true,
permission_policy: {type: "auto"}
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: {type: "auto"}
}
]
},
{
type: "custom",
name: "lookup_order",
description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {order_id: {type: "string", description: "The order ID from the ticket"}},
required: ["order_id"]
}
}
]
```
Ein [Agent-Update](https://platform.claude.com/docs/de/managed-agents/agent-setup#update-semantics) ersetzt das gesamte `tools`-Array, also sende jeden Eintrag, den du behalten möchtest.
Ein Agent-Update erreicht nur neue Sessions, also prüfe auch Deployments, Agenten, die diesen Agenten auflisten, und bestehende Sessions:
* Ein Deployment fixiert eine Agentenversion, also richte jedes Deployment auf die neue aus.
* Ein Agent, der diesen in [`subagents.predefined_agents`](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#list-the-subagents) oder `workflows.predefined_agents` auflistet, behält die Version, die er fixiert hat, also aktualisiere auch diesen Agenten.
* Um eine bereits bestehende Session stärker einzuschränken, [aktualisiere die Tools dieser Session](https://platform.claude.com/docs/de/managed-agents/session-operations#updating-the-agent-configuration). Die Session muss `idle` sein, und das Update ersetzt das gesamte `tools`-Array. In einer Multiagenten-Session gelten neue `allowed_domains`- und `blocked_domains`-Listen bei den Web-Tools des Agenten, den die Session ausführt, auch für jeden anderen Agenten. Sie gelten ab dem nächsten Turn jedes Agenten. Die aktivierten Tools und Berechtigungsrichtlinien dieser Agenten ändern sich nicht. Um diese zu ändern, aktualisiere jeden Agenten und starte dann eine neue Session.
Begrenze auch MCP-Server und benutzerdefinierte Tools auf das, was der Agent benötigt:
* **MCP-Server:** Ein MCP-Toolset aktiviert standardmäßig jedes Tool, das der Server bereitstellt. Setze `default_config.enabled` auf `false` und aktiviere benannte Tools, sodass Tools, die ein Server später hinzufügt, deaktiviert bleiben. Entferne Server, die der Agent nicht verwendet. Siehe [MCP-Connector](https://platform.claude.com/docs/de/managed-agents/mcp-connector#configure-which-mcp-tools-are-available).
* **Benutzerdefinierte Tools:** Deine Anwendung führt sie aus, und Berechtigungsrichtlinien gelten nicht. Validiere die Eingabe jedes Aufrufs in deiner Anwendung und begrenze, worauf das Tool zugreifen kann.
## Nicht vertrauenswürdige Eingaben von mächtigen Tools fernhalten
Prüfe, welche Tools und Anmeldedaten ein Agent besitzt, wann immer er nicht vertrauenswürdige Eingaben liest, also Text, den jemand außerhalb deines Teams schreiben kann. Dieser Abschnitt verwendet zwei Begriffe:
* **Nicht vertrauenswürdige Eingaben:** Webseiten, Suchergebnisse, Support-Tickets, E-Mails, Repository-Dateien, Uploads, MCP-Server-Ergebnisse und Endbenutzernachrichten, die du weiterleitest.
* **Mächtige Tools:** `bash`, `write`, `edit`, `web_fetch`, `web_search`, MCP-Tools und benutzerdefinierte Tools, die Daten schreiben oder senden, sowie jedes Tool, das Anmeldedaten verwendet.
Text in nicht vertrauenswürdigen Eingaben kann den Agenten anweisen, ein mächtiges Tool zu verwenden, das er besitzt. Der Support-Agent liest Tickets, daher erreicht er deine Bestell-API nur über das benutzerdefinierte Tool `lookup_order`. Deine Anwendung prüft, dass die Bestellung zum Absender des Tickets gehört.
| Eingabe, die der Agent liest | Fähigkeit, die er ebenfalls hat | Tu Folgendes |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tickets, E-Mails oder Uploads | `bash` mit Anmeldedaten | Ersetze `bash` durch ein benutzerdefiniertes Tool, das eine Sache tut. Wenn der Agent `bash` behalten muss, genehmige jeden Aufruf mit `always_ask` |
| Webseiten oder Suchergebnisse | Dateien schreiben oder Datensätze ändern | Deaktiviere die Web-Tools oder begrenze sie auf Websites, die du betreibst oder denen du vertraust |
| MCP-Ergebnisse oder Repository-Dateien | MCP-Tools, die schreiben | Belasse das MCP-Toolset auf `always_ask` und aktiviere nur die Tools, die der Agent benötigt |
| Ein eingebundenes GitHub-Repository | Jedes Tool | Binde nur Repositories ein, denen du vertraust. Ein Agent mit `read` lädt Skills aus dem `.claude/skills`-Verzeichnis des Repositorys als Agent-Anweisungen, ohne Prüfschritt. Siehe [Skills aus einem GitHub-Repository laden](https://platform.claude.com/docs/de/managed-agents/skills#load-skills-from-a-github-repository) |
| Jede nicht vertrauenswürdige Eingabe | Schreiben in einen [Memory Store](https://platform.claude.com/docs/de/managed-agents/memory#attach-a-memory-store-to-a-session) | Hänge den Store als `read_only` an, es sei denn, der Agent muss schreiben. Der Standard ist `read_write`, und spätere Sessions lesen gespeicherten Text als vertrauenswürdige Memory |
In einer Cloud-Umgebung kann das Lesen einer Datei mit `read` auch `CLAUDE.md`- und `AGENTS.md`-Dateien als Anweisungen laden. Sie werden aus dem Verzeichnis der Datei und ihren übergeordneten Verzeichnissen geladen, bis hinauf zum Arbeitsverzeichnis der Sandbox. Dateien, die sie mit `@` und einem Pfad referenzieren, etwa `@docs/setup.md`, werden ebenfalls geladen, bis zu fünf Referenzebenen tief. Eine Referenz kann auf eine beliebige Stelle in der Sandbox verweisen, zum Beispiel `@/etc/hosts`. Keine Einstellung schaltet dies ab, außer das Deaktivieren von `read`, also behandle ein Repository, Paket oder Archiv, das jemand außerhalb deines Teams schreiben kann, als nicht vertrauenswürdige Eingabe.
Wenn ein Agent nicht vertrauenswürdige Eingaben lesen und zugleich handeln muss, empfiehlt dieser Leitfaden eines von drei Designs:
* **Trenne Lesen vom Handeln.** In einer Multiagenten-Session gibt ein [Lead-Agent](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#list-the-subagents) Aufgaben an einen Fetcher, der das Web liest, und einen Writer, der Dateien oder Datensätze ändert.
* **Gib dem Agenten ein eng gefasstes benutzerdefiniertes Tool.** Deine Anwendung führt das Tool aus, prüft seine Eingabe und hält die Anmeldedaten. Der Support-Agent verwendet dieses Design, nicht die Trennung. Siehe [Tool-Aufrufe beantworten, die die Session pausieren](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session).
* **Beziehe eine Person ein.** Verwende `always_ask` beim mächtigen Tool, sodass eine Person jeden Aufruf genehmigt.
Die Trennung verwendet drei Agenten:
| Agent | Liest | Besitzt | Gibt weiter |
| ------------------------------------------ | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| Lead (der Agent, den die Session ausführt) | Deine Nachricht und was die anderen Agenten zurücksenden | Keine integrierten Tools. Seine `subagents.predefined_agents`-Liste benennt den Fetcher und den Writer | Eine Aufgabe an jeden Agenten |
| Fetcher | Webseiten und Suchergebnisse | Nur `web_fetch` und `web_search`, jeweils mit `allowed_domains` | Kurze Ergebnisse in einem Format, das du in seinem System-Prompt anforderst |
| Writer | Die Aufgabe vom Lead | Die Tools, die Dateien schreiben, Befehle ausführen oder Datensätze ändern, auf `auto` oder `always_ask`. Keine Web-Tools | Sein Ergebnis |
Die Ergebnisse des Fetchers werden aus nicht vertrauenswürdigen Seiten erstellt, und der Lead kann ihren Text an den Writer weitergeben. Belasse `auto` oder `always_ask` bei den Tools des Writers. Der Fetcher kann weiterhin einen Teil dessen, was er liest, an die Websites auf seiner `web_fetch`-Liste und in seinen Anfragen an den Suchanbieter senden.
Agenten in einer Multiagenten-Session [teilen sich die Sandbox](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#how-it-works), ihre Dateien und die Vault-Credentials, daher trennt diese Aufteilung nur ihre Tools und Konversationen. Für eine stärkere Trennung verwende zwei Sessions mit separaten Umgebungen und Vaults. Lass deine Anwendung nur feste Felder, etwa eine Bestell-ID, zwischen den beiden Sessions weitergeben.
## Limits und eine Möglichkeit zum Stoppen festlegen
Lege beim Erstellen jeder Session ein Budget fest und entscheide im Voraus, wie du einen Agenten stoppst.
| Kontrolle | Was sie tut |
| --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Session-Budget | Eine Obergrenze für Ausgaben zu öffentlichen Listenpreisen. Bei Erreichen der Obergrenze pausieren die Session und jeder [Thread](https://platform.claude.com/docs/de/managed-agents/session-threads). Laufende Anfragen können abgeschlossen werden und ihre Tool-Aufrufe werden weiterhin ausgeführt, sodass die Ausgaben die Obergrenze überschreiten können. Siehe [Wenn eine Session ihr Budget erreicht](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget) |
| Deployment-Budget | Dieselbe Obergrenze, angewendet auf jede Session, die ein Deployment startet |
| [`user.interrupt`-Event](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#interrupt-the-agent) | Stoppt die Modellantwort sofort. Ein laufender Tool-Aufruf kann zuerst abgeschlossen werden. Die Session wechselt zu `idle`, es sei denn, ein Workflow-Run hält sie auf `running`, und wird bei deiner nächsten Nachricht fortgesetzt. Ein Interrupt beendet keinen Workflow-Run |
| Eine Session archivieren oder löschen | Archivieren behält den Verlauf und blockiert neue Events. Löschen entfernt den Datensatz, die Events und die Sandbox |
| Ein Deployment pausieren oder archivieren | Pausieren stoppt neue geplante Ausführungen, erlaubt aber weiterhin manuelle Ausführungen. Archivieren beendet den Zeitplan dauerhaft. Bereits laufende Sessions laufen weiter |
| Einen Vault oder ein Credential archivieren oder löschen | Entfernt das Secret ohne Neustart aus laufenden Sessions. Rechne mit einer Verzögerung. Die Sessions laufen weiter, also unterbrich sie ebenfalls. Ein Token, das der Agent bereits mit dem Secret abgerufen hat, bleibt in der Sandbox |
Um einen laufenden Agenten zu stoppen, befolge diese Schritte:
1. Sende `user.interrupt` für sich allein.
2. Pausiere bei einem geplanten Agenten zusätzlich das Deployment, damit keine neue geplante Ausführung startet. Um den Zeitplan dauerhaft zu beenden, archiviere das Deployment.
3. Wenn ein Schlüssel möglicherweise offengelegt wurde, rotiere ihn bei dem Dienst, der ihn ausgestellt hat.
4. Wenn der Agent offene Workflow-Runs hat, sende zusätzlich eine `user.message`, die ihn auffordert, diese zu stoppen, da ein Interrupt keinen Run beendet. Welche Tool-Aufrufe du zuerst abbrechen musst, erfährst du unter [Eine Session mit offenen Runs unterbrechen](https://platform.claude.com/docs/de/managed-agents/workflow-runs#interrupt-a-session-with-runs-open).
5. Warte, bis die Session zu `idle` wechselt. Eine laufende Session kann nicht archiviert oder gelöscht werden.
6. Archiviere die Session, um ihren Verlauf zu behalten. Lösche sie, wenn du den Verlauf nicht mehr benötigst.
Ein Interrupt macht nicht rückgängig, was der Agent bereits getan oder gesendet hat. Das Archivieren eines Agenten stoppt seine laufenden Sessions nicht.
Das `max_list_cost.amount` eines Budgets ist eine ganze Zahl von US-Cent, geschrieben als String, sodass `"125"` 1,25 $ bedeutet. Siehe [Ein Budget bei der Session-Erstellung festlegen](https://platform.claude.com/docs/de/managed-agents/budgets#set-a-budget-at-session-creation).
Du kannst einer Session, die ohne Budget erstellt wurde, kein Budget hinzufügen. Um eine Obergrenze zu ändern oder zu entfernen, siehe [Eine Session an ihrem Budget fortsetzen](https://platform.claude.com/docs/de/managed-agents/budgets#resume-a-session-at-its-budget). Nachdem du die Obergrenze einer Session entfernt hast, kannst du keine neue festlegen.
Ein Budget begrenzt die Ausgaben, aber es begrenzt nicht, was der Agent vor Erreichen der Obergrenze tut. Um Workloads mit unterschiedlichen Vertrauensstufen voneinander zu trennen, verwende separate [Workspaces](https://platform.claude.com/docs/de/manage-claude/workspaces). Gib jedem Workload einen API-Key, der auf einen Workspace beschränkt ist, denn ein Schlüssel, der mehrere Workspaces erreichen kann, kann in jedem von ihnen handeln.
Siehe [Session-Budgets](https://platform.claude.com/docs/de/managed-agents/budgets), [Session-Operationen](https://platform.claude.com/docs/de/managed-agents/session-operations#archiving-a-session) und [Geplante Deployments](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments#managing-deployment-lifecycle).
## Nächste Schritte
Networking-Modi, erlaubte Hosts und Paketmanager.
Genehmigungsrichtlinien und Bestätigungsanfragen.
Credential-Typen, Injektionsorte und Rotation.
Obergrenzen, Fortsetzen bei einem Budget und Budgets für Deployments.