---
title: Tools
url: https://platform.claude.com/docs/de/managed-agents/tools
description: Konfiguriere die Tools, die deinem Agenten zur Verfügung stehen.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: Nicht für ZDR berechtigt, außer bei selbst gehosteten Managed Agents. Sitzungen sind zustandsbehaftete Ressourcen; Transkripte bleiben erhalten, bis du sie löschst.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
---

Claude Managed Agents bietet eine Reihe integrierter Tools, die Claude innerhalb einer [Session](https://platform.claude.com/docs/de/managed-agents/sessions) autonom verwenden kann. Du steuerst, welche Tools verfügbar sind, indem du sie in der Agentenkonfiguration angibst.

Claude Managed Agents unterstützt außerdem benutzerdefinierte Tools. Deine Anwendung führt diese Tools separat aus und gibt die Ergebnisse an Claude zurück, das sie verwendet, um die Aufgabe fortzusetzen. Um dem Agenten Tools von einem MCP-Server bereitzustellen, verwende stattdessen den [MCP-Connector](https://platform.claude.com/docs/de/managed-agents/mcp-connector).

## Verfügbare Tools

Das Agent-Toolset umfasst die folgenden Tools. Alle sind standardmäßig aktiviert, wenn du das Toolset in die Agentenkonfiguration aufnimmst.

| Tool | Name | Beschreibung |
| ----- | ----- | ----- |
| Bash | `bash` | Bash-Befehle in einer Shell-Session ausführen |
| Read | `read` | Eine Datei aus dem Sandbox-Dateisystem lesen |
| Write | `write` | Eine Datei in das Sandbox-Dateisystem schreiben |
| Edit | `edit` | Zeichenkettenersetzung in einer Datei durchführen |
| Glob | `glob` | Schnellen Dateimusterabgleich mit Glob-Mustern durchführen |
| Grep | `grep` | Text mit Regex-Mustern durchsuchen |
| Web-Fetch | `web_fetch` | Inhalte von einer URL abrufen |
| Websuche | `web_search` | Das Web nach Informationen durchsuchen |

Wenn eine Tool-Ausgabe 100.000 Zeichen (etwa 25.000 Token) überschreitet, wird sie automatisch in eine Datei in der [Sandbox](https://platform.claude.com/docs/de/managed-agents/environments) geschrieben. Das Modell erhält eine gekürzte Vorschau mit dem Dateipfad und kann den vollständigen Inhalt von dort lesen.

## Das Toolset konfigurieren

Aktiviere das vollständige Toolset mit `agent_toolset_20260401`, wenn du einen Agenten erstellst. Verwende das Array `configs` (csharp, go: `Configs`), um bestimmte Tools zu deaktivieren oder ihre Einstellungen zu überschreiben. Jeder Eintrag wird durch seinen `name` (csharp, go: `Name`) identifiziert, der einen Wert aus der Spalte „Name“ in [Verfügbare Tools](https://platform.claude.com/docs/de/managed-agents/tools#available-tools) annimmt. Ein Eintrag akzeptiert außerdem ein optionales Feld `type` (csharp, go: `Type`) mit demselben Wert.

Jeder Konfigurationseintrag kann außerdem eine `permission_policy` (java, php: `permissionPolicy`; csharp, go: `PermissionPolicy`) festlegen. Die Richtlinie steuert, ob die Aufrufe des Tools ohne Bestätigung ausgeführt werden, eine Bestätigung erfordern oder an den Server gehen, der jeden Aufruf auswertet. Unter [Berechtigungsrichtlinien](https://platform.claude.com/docs/de/managed-agents/permission-policies) findest du die verfügbaren Richtlinientypen.

Das folgende Beispiel aktiviert das Toolset und deaktiviert `web_fetch`:

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Coding Assistant",
      "model": "claude-opus-5-5",
      "tools": [
        {
          "type": "agent_toolset_20260401",
          "configs": [
            {"name": "web_fetch", "enabled": false}
          ]
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Coding Assistant
      model: claude-opus-5-5
      tools:
        - type: agent_toolset_20260401
          configs:
            - name: web_fetch
              enabled: false
      ---
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  agent = client.beta.agents.create(
      name="Coding Assistant",
      model="claude-opus-5-5",
      tools=[
          {
              "type": "agent_toolset_20260401",
              "configs": [
                  {"name": "web_fetch", "enabled": False},
              ],
          },
      ],
  )
  ```

  ```typescript TypeScript
  const agent = await client.beta.agents.create({
    name: "Coding Assistant",
    model: "claude-opus-5-5",
    tools: [
      {
        type: "agent_toolset_20260401",
        configs: [{ name: "web_fetch", enabled: false }]
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Coding Assistant",
      Model = BetaManagedAgentsModel.ClaudeOpus5_5,
      Tools =
      [
          new BetaManagedAgentsAgentToolset20260401Params
          {
              Configs =
              [
                  new BetaManagedAgentsWebFetchToolConfigParams { Enabled = false },
              ],
          },
      ],
  });
  ```

  ```go Go
  agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
  	Name: "Coding Assistant",
  	Model: anthropic.BetaManagedAgentsModelConfigParams{
  		ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  	},
  	Tools: []anthropic.BetaAgentNewParamsToolUnion{{
  		OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  			Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{{
  				OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
  					Enabled: anthropic.Bool(false),
  				},
  			}},
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.agents.*;

  var agent = client.beta().agents().create(AgentCreateParams.builder()
      .name("Coding Assistant")
      .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
      .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
          .addConfig(BetaManagedAgentsWebFetchToolConfigParams.builder()
              .enabled(false)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
  use Anthropic\Beta\Agents\BetaManagedAgentsModel;
  use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;

  $agent = $client->beta->agents->create(
      name: 'Coding Assistant',
      model: BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
      tools: [
          BetaManagedAgentsAgentToolset20260401Params::with(
              configs: [
                  BetaManagedAgentsWebFetchToolConfigParams::with(enabled: false),
              ],
          ),
      ],
  );
  ```

  ```ruby Ruby
  agent = client.beta.agents.create(
    name: "Coding Assistant",
    model: Anthropic::Beta::BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
    tools: [
      {
        type: :agent_toolset_20260401,
        configs: [
          {name: :web_fetch, enabled: false}
        ]
      }
    ]
  )
  ```
</CodeGroup>

### Bestimmte Tools deaktivieren

Um ein Tool zu deaktivieren, setze `enabled: false` in seinem `configs`-Eintrag:

```json
{
  "type": "agent_toolset_20260401",
  "configs": [
    { "name": "web_fetch", "enabled": false },
    { "name": "web_search", "enabled": false }
  ]
}
```

### Nur bestimmte Tools aktivieren

Das Objekt `default_config` legt die Grundeinstellung für jedes Tool im Set fest, und Einträge in `configs` pro Tool überschreiben sie. Um mit allem deaktiviert zu beginnen und nur das zu aktivieren, was du brauchst, setze `default_config.enabled` auf `false`:

```json
{
  "type": "agent_toolset_20260401",
  "default_config": { "enabled": false },
  "configs": [
    { "name": "bash", "enabled": true },
    { "name": "read", "enabled": true },
    { "name": "write", "enabled": true }
  ]
}
```

### Websuche und Web-Fetch einschränken

Die Einträge `web_search` und `web_fetch` akzeptieren außerdem Domainlisten, eine Obergrenze für abgerufene Inhalte und einen Suchstandort. Siehe [Domains für Websuche und Web-Fetch einschränken](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions).

### Typen von Konfigurationseinträgen in den SDKs

Die SDKs typisieren jeden `configs` (csharp, go: `Configs`)-Eintrag nach Tool. Der Typ ist eine Union mit einem Member für jedes integrierte Tool, unterschieden durch `type` (csharp, go: `Type`).

In Go, Java, C# und PHP erstellst du Einträge aus typisierten Werten statt aus einfachen Dictionaries oder Hashes. In diesen SDKs ist der Elementtyp von `configs` (csharp, go: `Configs`) die Union selbst, erstelle also jeden Eintrag aus seinem toolspezifischen Member-Typ.

Du kannst `type` (csharp, go: `Type`) beim Erstellen eines Eintrags weglassen, da der Server ihn aus `name` (csharp, go: `Name`) ableitet. Antworten enthalten ihn immer. Diese Typisierung ändert nicht das JSON, zu dem ein Eintrag serialisiert wird. Eine Anfrage, deren Einträge nur `name`, `enabled` und `permission_policy` festlegen, ist mit oder ohne `type` gültig.

## Benutzerdefinierte Tools

Benutzerdefinierte Tools entsprechen den [benutzerdefinierten Client-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/how-tool-use-works#user-defined-tools-client-executed) in der Messages API. Du legst fest, welche Operationen verfügbar sind und was sie zurückgeben, und Claude entscheidet, wann und wie sie aufgerufen werden.

Claude führt ein benutzerdefiniertes Tool nicht selbst aus. Es gibt eine strukturierte Anfrage aus, dein Code führt die Operation aus, und du gibst das Ergebnis an die Session zurück.

Das folgende Beispiel erstellt einen Agenten mit einem benutzerdefinierten Tool, `get_weather`, und ohne integrierte Tools:

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsSL https://api.anthropic.com/v1/agents \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "Weather Agent",
      "model": "claude-opus-5-5",
      "tools": [
        {
          "type": "custom",
          "name": "get_weather",
          "description": "Get current weather for a location",
          "input_schema": {
            "type": "object",
            "properties": {
              "location": {"type": "string", "description": "City name"}
            },
            "required": ["location"]
          }
        }
      ]
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply agent.md
    ```

    <File filename="agent.md">
      ```markdown
      ---
      name: Weather Agent
      model: claude-opus-5-5
      tools:
        - type: custom
          name: get_weather
          description: Get current weather for a location
          input_schema:
            type: object
            properties:
              location:
                type: string
                description: City name
            required:
              - location
      ---
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  agent = client.beta.agents.create(
      name="Weather Agent",
      model="claude-opus-5-5",
      tools=[
          {
              "type": "custom",
              "name": "get_weather",
              "description": "Get current weather for a location",
              "input_schema": {
                  "type": "object",
                  "properties": {
                      "location": {"type": "string", "description": "City name"},
                  },
                  "required": ["location"],
              },
          },
      ],
  )
  ```

  ```typescript TypeScript
  const agent = await client.beta.agents.create({
    name: "Weather Agent",
    model: "claude-opus-5-5",
    tools: [
      {
        type: "custom",
        name: "get_weather",
        description: "Get current weather for a location",
        input_schema: {
          type: "object",
          properties: { location: { type: "string", description: "City name" } },
          required: ["location"]
        }
      }
    ]
  });
  ```

  ```csharp C#
  using System.Text.Json;
  using Anthropic.Models.Beta.Agents;

  var agent = await client.Beta.Agents.Create(new()
  {
      Name = "Weather Agent",
      Model = BetaManagedAgentsModel.ClaudeOpus5_5,
      Tools =
      [
          new BetaManagedAgentsCustomToolParams
          {
              Name = "get_weather",
              Description = "Get current weather for a location",
              InputSchema = new()
              {
                  Properties = new Dictionary<string, JsonElement>
                  {
                      ["location"] = JsonSerializer.SerializeToElement(
                          new { type = "string", description = "City name" }
                      ),
                  },
                  Required = ["location"],
              },
          },
      ],
  });
  ```

  ```go Go
  agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
  	Name: "Weather Agent",
  	Model: anthropic.BetaManagedAgentsModelConfigParams{
  		ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  	},
  	Tools: []anthropic.BetaAgentNewParamsToolUnion{{
  		OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
  			Name:        "get_weather",
  			Description: "Get current weather for a location",
  			InputSchema: anthropic.BetaManagedAgentsCustomToolInputSchemaParam{
  				Properties: map[string]any{
  					"location": map[string]any{
  						"type":        "string",
  						"description": "City name",
  					},
  				},
  				Required: []string{"location"},
  			},
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  import com.anthropic.core.JsonValue;
  import com.anthropic.models.beta.agents.*;
  import java.util.Map;

  var agent = client.beta().agents().create(AgentCreateParams.builder()
      .name("Weather Agent")
      .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
      .addTool(BetaManagedAgentsCustomToolParams.builder()
          .name("get_weather")
          .description("Get current weather for a location")
          .inputSchema(BetaManagedAgentsCustomToolInputSchema.builder()
              .properties(BetaManagedAgentsCustomToolInputSchema.Properties.builder()
                  .putAdditionalProperty("location", JsonValue.from(Map.of(
                      "type", "string",
                      "description", "City name")))
                  .build())
              .addRequired("location")
              .build())
          .build())
      .build());
  ```

  ```php PHP
  use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolInputSchema;
  use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolParams;
  use Anthropic\Beta\Agents\BetaManagedAgentsModel;

  $agent = $client->beta->agents->create(
      name: 'Weather Agent',
      model: BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
      tools: [
          BetaManagedAgentsCustomToolParams::with(
              name: 'get_weather',
              description: 'Get current weather for a location',
              inputSchema: BetaManagedAgentsCustomToolInputSchema::with(
                  properties: ['location' => ['type' => 'string', 'description' => 'City name']],
                  required: ['location'],
              ),
          ),
      ],
  );
  ```

  ```ruby Ruby
  agent = client.beta.agents.create(
    name: "Weather Agent",
    model: Anthropic::Beta::BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
    tools: [
      {
        type: :custom,
        name: "get_weather",
        description: "Get current weather for a location",
        input_schema: {
          type: :object,
          properties: {location: {type: "string", description: "City name"}},
          required: ["location"]
        }
      }
    ]
  )
  ```
</CodeGroup>

Neue Namen benutzerdefinierter Tools dürfen nicht mit `mcp__` oder `ant__` beginnen oder mit dem Namen eines integrierten Agenten-Tools übereinstimmen. Eine Anfrage, die gegen diese Regel verstößt, gibt einen 400-Fehler zurück. Ein bestehendes benutzerdefiniertes Tool kann jedoch mit `ant__` beginnen. Ein Agent mit einem solchen Tool akzeptiert ein Update nur, wenn das Update `tools` (csharp, go: `Tools`) ohne diesen Namen sendet. Benenne das Tool also in deinem nächsten Update um oder entferne es. Eine neue Session wird mit einem 400-Fehler abgelehnt, wenn sich ein solches Tool auf ihrem Agenten befindet (nach allen [Überschreibungen](https://platform.claude.com/docs/de/managed-agents/sessions#override-agent-configuration-for-a-session)), auf einem Agenten in der Liste `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) von `subagents` (csharp, go: `Subagents`) oder auf einem Agenten in der Liste `predefined_agents` (java, php: `predefinedAgents`; csharp, go: `PredefinedAgents`) von `workflows` (csharp, go: `Workflows`). Bereits bestehende Sessions sind nicht betroffen.

Der Agent ruft seine benutzerdefinierten Tools während einer Session auf. Wie du die Aufrufe empfängst und Ergebnisse zurückgibst, erfährst du unter [Tool-Aufrufe beantworten, die die Session pausieren](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#handling-custom-tool-calls).

Für Sessions, die in einer selbst gehosteten Sandbox laufen, kann der Environment-Worker [benutzerdefinierte Tools aus der Sandbox bereitstellen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-custom-tools). Dazu können Tools gehören, die einen MCP-Server innerhalb deines Netzwerks kapseln.

### Best Practices für Definitionen benutzerdefinierter Tools

* **Liefere äußerst detaillierte Beschreibungen.** Dies ist mit Abstand der wichtigste Faktor für die Tool-Leistung. Je mehr Kontext du Claude zu deinen Tools gibst, desto besser kann es bestimmen, wann und wie es sie verwenden soll. Strebe drei bis vier Sätze pro Tool-Beschreibung an, mehr, wenn das Tool komplex ist. Deine Beschreibungen sollten Folgendes abdecken:

  * Was das Tool tut
  * Wann es verwendet werden soll und wann nicht
  * Was jeder Parameter bedeutet und wie er das Verhalten des Tools beeinflusst
  * Alle wichtigen Vorbehalte oder Einschränkungen

* **Fasse zusammengehörige Operationen in weniger Tools zusammen.** Gruppiere Aktionen wie `create_pr`, `review_pr` und `merge_pr` in einem einzigen Tool mit einem `action`-Parameter. Weniger, dafür leistungsfähigere Tools verringern Mehrdeutigkeiten bei der Auswahl und machen deine Tool-Oberfläche für Claude leichter navigierbar.

* **Verwende aussagekräftige Namespaces in Tool-Namen.** Wenn sich deine Tools über mehrere Dienste oder Ressourcen erstrecken, stelle den Namen die Ressource voran (zum Beispiel `db_query` oder `storage_read`). So bleibt die Tool-Auswahl eindeutig, wenn deine Bibliothek wächst.

* **Gestalte Tool-Antworten so, dass sie nur aussagekräftige Informationen zurückgeben.** Gib semantische, stabile Bezeichner zurück (zum Beispiel Slugs oder UUIDs) statt undurchsichtiger interner Referenzen. Füge nur die Felder hinzu, die Claude benötigt, um seinen nächsten Schritt zu bestimmen. Aufgeblähte Antworten verschwenden Kontext und erschweren es Claude, das Wesentliche zu extrahieren.

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Domains für Websuche und Web-Fetch einschränken" icon="shield" href="https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions">
    Steuere, welche Websites die Web-Tools erreichen können, begrenze abgerufene Inhalte und lokalisiere Suchergebnisse.
  </Card>

  <Card title="MCP-Connector" icon="link" href="https://platform.claude.com/docs/de/managed-agents/mcp-connector">
    Verbinde MCP-Server mit deinen Agenten, um auf externe Tools und Datenquellen zuzugreifen.
  </Card>

  <Card title="Berechtigungsrichtlinien" icon="lock" href="https://platform.claude.com/docs/de/managed-agents/permission-policies">
    Steuere, wann Agenten- und MCP-Tools ausgeführt werden.
  </Card>

  <Card title="Session-Event-Stream" icon="lightning" href="https://platform.claude.com/docs/de/managed-agents/events-and-streaming">
    Sende Events, streame Antworten und unterbrich oder lenke deine Session um, während sie läuft.
  </Card>
</CardGroup>

## Verfügbarkeit

Agent-Toolset ist auf allen Modellen in der Beta.

### API-Unterstützung

#### [Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview)

* Verfügbarkeit: Verfügbar

| Status | Cloud-Plattformen |
| ----- | ----- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) |

### Erforderliche Beta-Header

[Übersicht über Beta-Header](https://platform.claude.com/docs/de/api/beta-headers)

Mit Beta-Headern kannst du auf experimentelle Funktionen und neue Modellfähigkeiten zugreifen, bevor sie Teil der Standard-API werden.

* `managed-agents-2026-04-01`

### Datenverarbeitung

[Übersicht über die Datenverarbeitung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#feature-eligibility)

| Element | Zero Data Retention | HIPAA |
| ----- | ----- | ----- |
| Status | Nicht berechtigt | Nicht berechtigt |
| Details | Nicht für ZDR berechtigt, außer bei selbst gehosteten Managed Agents. Sitzungen sind zustandsbehaftete Ressourcen; Transkripte bleiben erhalten, bis du sie löschst. [Mehr erfahren](https://platform.claude.com/docs/de/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Nicht für HIPAA berechtigt. Gilt für alle Unterfunktionen von Managed Agents. |

Zutreffende Endpunkte:

* `/v1/agents`
* `/v1/sessions`
* `/v1/environments`
