---
title: Einrichtung der Cloud-Umgebung
url: https://platform.claude.com/docs/de/managed-agents/environments
description: Passe Cloud-Sandboxes für deine Sessions an.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Environments (Umgebungen) definieren die Sandbox-Konfiguration, in der dein Agent läuft. Du erstellst eine Umgebung einmal und referenzierst dann ihre ID jedes Mal, wenn du eine Session startest. Mehrere Sessions können dieselbe Umgebung gemeinsam nutzen, aber jede Session erhält ihre eigene isolierte Sandbox (einen frischen Linux-Container).

Diese Seite behandelt Umgebungen vom Typ `type: cloud`. Um Sandboxes auf deiner eigenen Infrastruktur auszuführen, siehe [Selbst gehostete Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes). Um zwischen beiden zu wählen, siehe [Eine Agent-Umgebung auswählen](https://platform.claude.com/docs/de/managed-agents/choosing-an-environment).

## Eine Umgebung erstellen

<CodeGroup defaultLanguage="CLI">
  ```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" \
    --data '{
      "name": "python-dev",
      "config": {
        "type": "cloud",
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: python-dev
      config:
        type: cloud
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>

    [`ant apply`](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/apply) erstellt die Umgebung aus `environment.yaml`, gibt ihre ID aus und speichert sie in `claude-lock.json`. Committe `claude-lock.json`, damit der nächste Aufruf von `ant apply` diese Umgebung aktualisiert, anstatt zu versuchen, sie erneut zu erstellen.
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="python-dev",
      config={
          "type": "cloud",
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )

  print(f"Environment ID: {environment.id}")
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "python-dev",
    config: {
      type: "cloud",
      networking: { type: "limited", allow_package_managers: true }
    }
  });

  console.log(`Environment ID: ${environment.id}`);
  ```

  ```csharp C#
  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "python-dev",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });

  Console.WriteLine($"Environment ID: {environment.ID}");
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "python-dev",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("Environment ID: %s\n", environment.ID)
  ```

  ```java Java
  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("python-dev")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  IO.println("Environment ID: " + environment.id());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'python-dev',
      config: [
          'type' => 'cloud',
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  echo "Environment ID: {$environment->id}\n";
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "python-dev",
    config: {
      type: "cloud",
      networking: {type: "limited", allow_package_managers: true}
    }
  )

  puts "Environment ID: #{environment.id}"
  ```
</CodeGroup>

Verwende einen eindeutigen, aussagekräftigen `name` (csharp, go: `Name`), damit du Umgebungen auseinanderhalten kannst. Dieses Beispiel verwendet `limited` [Networking](https://platform.claude.com/docs/de/managed-agents/environments#networking) mit erlaubten Paketmanagern, sodass die Sandbox die Paket-Registries und Code-Hosts erreichen kann. Damit sie andere Hosts erreichen kann, füge diese zu `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) hinzu.

## Die Umgebung in einer Session verwenden

Übergib die Umgebungs-ID als String beim [Erstellen einer Session](https://platform.claude.com/docs/de/managed-agents/sessions).

<CodeGroup>
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/sessions \
    -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" \
    --data '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  ant beta:sessions create --agent "$AGENT_ID" --environment-id "$ENVIRONMENT_ID"
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
  )
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id
  });
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
  });
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .build());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
  );
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id
  )
  ```
</CodeGroup>

## Konfigurationsoptionen

### Pakete

Das Feld `packages` (csharp, go: `Packages`) installiert Pakete in der Sandbox vor, bevor der Agent startet. Pakete werden von ihren jeweiligen Paketmanagern installiert und über Sessions hinweg zwischengespeichert, die dieselbe Umgebung nutzen. Wenn mehrere Paketmanager angegeben sind, laufen sie in alphabetischer Reihenfolge (apt, cargo, gem, go, npm, pip). Optional kannst du bestimmte Versionen festlegen. Pakete ohne festgelegte Version installieren die neueste Version. Wenn die Umgebung `limited` [Networking](https://platform.claude.com/docs/de/managed-agents/environments#networking) verwendet, setze außerdem `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) in `networking` (csharp, go: `Networking`) auf `true`; andernfalls wird die Anfrage mit einem 400-Fehler abgelehnt.

<CodeGroup defaultLanguage="CLI">
  ```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" \
    --data '{
      "name": "data-analysis",
      "config": {
        "type": "cloud",
        "packages": {
          "pip": ["pandas", "numpy", "scikit-learn"],
          "npm": ["express"]
        },
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: data-analysis
      config:
        type: cloud
        packages:
          pip:
            - pandas
            - numpy
            - scikit-learn
          npm:
            - express
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="data-analysis",
      config={
          "type": "cloud",
          "packages": {
              "pip": ["pandas", "numpy", "scikit-learn"],
              "npm": ["express"],
          },
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: ["pandas", "numpy", "scikit-learn"],
        npm: ["express"]
      },
      networking: { type: "limited", allow_package_managers: true }
    }
  });
  ```

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

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "data-analysis",
      Config = new BetaCloudConfigParams
      {
          Packages = new()
          {
              Pip = ["pandas", "numpy", "scikit-learn"],
              Npm = ["express"],
          },
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "data-analysis",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Packages: anthropic.BetaPackagesParams{
  				Pip: []string{"pandas", "numpy", "scikit-learn"},
  				Npm: []string{"express"},
  			},
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  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("data-analysis")
      .config(BetaCloudConfigParams.builder()
          .packages(BetaPackagesParams.builder()
              .pip(List.of("pandas", "numpy", "scikit-learn"))
              .npm(List.of("express"))
              .build())
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'data-analysis',
      config: [
          'type' => 'cloud',
          'packages' => [
              'pip' => ['pandas', 'numpy', 'scikit-learn'],
              'npm' => ['express'],
          ],
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: %w[pandas numpy scikit-learn],
        npm: %w[express]
      },
      networking: {type: "limited", allow_package_managers: true}
    }
  )
  ```
</CodeGroup>

Unterstützte Paketmanager:

| Feld    | Paketmanager           | Beispiel                                    |
| ------- | ---------------------- | ------------------------------------------- |
| `apt`   | Systempakete (apt-get) | `"graphviz"`                                |
| `cargo` | Rust (cargo)           | `"hyperfine@1.18.0"`                        |
| `gem`   | Ruby (gem)             | `"rails:7.1.0"`                             |
| `go`    | Go-Module              | `"golang.org/x/tools/cmd/goimports@latest"` |
| `npm`   | Node.js (npm)          | `"express@4.18.0"`                          |
| `pip`   | Python (pip)           | `"sqlalchemy==2.0.30"`                      |

### Networking

Das Feld `networking` (csharp, go: `Networking`) steuert den ausgehenden Netzwerkzugriff der Sandbox.

Bei `limited` Networking gilt `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) auch für die Tools `web_search` und `web_fetch`, die auf den Servern von Anthropic laufen. Ein `web_fetch`-Aufruf für eine URL auf einem Host, auf den `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) nicht zutrifft, gibt dem Agenten ein Fehlerergebnis zurück. `web_search` lässt Ergebnisse von Hosts weg, auf die `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) nicht zutrifft. `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) und `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) fügen für diese Tools keine Hosts hinzu. Wenn `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) keine Hosts auflistet, gibt kein `web_fetch`- oder `web_search`-Aufruf eine Seite oder ein Suchergebnis zurück. Ein Host, den du für diese Tools zu `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) hinzufügst, ist auch für die Sandbox offen. `unrestricted` Networking und selbst gehostete Umgebungen schränken diese Tools nicht ein. Um sie weiter einzuschränken, setze `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) oder `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) im Eintrag des Tools im Agent-Toolset. Siehe [Domains für Websuche und Web-Fetch einschränken](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions).

| Modus          | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `limited`      | Beschränkt den Netzwerkzugriff der Sandbox auf die Hosts in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Setze `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) und `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) auf `true`, um zusätzlichen Zugriff zu erlauben. Verwende diesen Modus, es sei denn, der Agent muss Websites erreichen, die du nicht im Voraus auflisten kannst. |
| `unrestricted` | Vollständiger ausgehender Netzwerkzugriff, mit Ausnahme einer allgemeinen Sicherheits-Blocklist. Bevor du ihn verwendest, lies [Risiken von uneingeschränktem Networking](https://platform.claude.com/docs/de/managed-agents/environments#risks-of-unrestricted-networking).                                                                                                                                                                                                                                                             |

<Note>
  Setze `networking` (csharp, go: `Networking`) in API-Anfragen explizit; eine Erstellungsanfrage, die es weglässt, erhält `unrestricted`. Das Formular der Claude Console zum Erstellen einer Umgebung startet mit ausgewähltem **Limited** und ohne weitere Freigaben.
</Note>

Das folgende Beispiel erstellt eine Umgebung mit `limited` Networking:

<CodeGroup defaultLanguage="CLI">
  ```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": "api-access",
      "config": {
        "type": "cloud",
        "networking": {
          "type": "limited",
          "allowed_hosts": ["api.example.com"],
          "allow_mcp_servers": true,
          "allow_package_managers": true
        }
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: api-access
      config:
        type: cloud
        networking:
          type: limited
          allowed_hosts:
            - api.example.com
          allow_mcp_servers: true
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="api-access",
      config={
          "type": "cloud",
          "networking": {
              "type": "limited",
              "allowed_hosts": ["api.example.com"],
              "allow_mcp_servers": True,
              "allow_package_managers": True,
          },
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: ["api.example.com"],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  });
  ```

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

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "api-access",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowedHosts = ["api.example.com"],
              AllowMcpServers = true,
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "api-access",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowedHosts:         []string{"api.example.com"},
  					AllowMCPServers:      anthropic.Bool(true),
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  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("api-access")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowedHosts(List.of("api.example.com"))
              .allowMcpServers(true)
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'api-access',
      config: [
          'type' => 'cloud',
          'networking' => [
              'type' => 'limited',
              'allowed_hosts' => ['api.example.com'],
              'allow_mcp_servers' => true,
              'allow_package_managers' => true,
          ],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: %w[api.example.com],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  )
  ```
</CodeGroup>

<Info>
  Verwende `limited` Networking mit einer expliziten `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)-Liste. Befolge das Prinzip der geringsten Rechte, indem du nur den minimalen Netzwerkzugriff gewährst, den dein Agent benötigt, und überprüfe deine erlaubten Domains regelmäßig.
</Info>

Mit `limited` Networking und ohne weitere gesetzte Felder sind keine Hosts erlaubt. Dateien, Memory Stores und GitHub-Repositories, die du an die Session anhängst, bleiben verfügbar. Wenn eine Anfrage aus der Sandbox auf Port 80 oder 443 abgelehnt wird, weil ihr Host nicht erlaubt ist, ist die Antwort ein 403, der den blockierten Host nennt.

Bei Verwendung von `limited` Networking:

* `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) gibt Domains an, die die Sandbox erreichen kann. Gib reine Hostnamen oder Wildcard-Muster (wie `*.example.com`) an. Füge kein URL-Schema, keinen Port und keinen Pfad hinzu. Ein reiner Hostname trifft genau auf diesen Host zu: `example.com` trifft nicht auf `www.example.com` zu. `*.example.com` trifft auf jede Subdomain von `example.com` zu, aber nicht auf `example.com` selbst.
* `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) erlaubt ausgehenden Zugriff auf MCP-Server-Endpunkte, die im Agenten konfiguriert sind, über die im Array `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) aufgeführten hinaus. Standardwert ist `false`. Solange es `false` ist, schlägt die Session-Erstellung mit einem 400-Fehler fehl, wenn der Agent einen MCP-Server deklariert, dessen Host nicht in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) enthalten ist. Dasselbe gilt für [einen Agenten, an den er delegieren kann](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration). Um das zu beheben, füge den Host zu `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) hinzu oder setze `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) auf `true`.
* `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) erlaubt ausgehenden Zugriff auf eine Reihe öffentlicher Paket-Registries und Code-Hosts über die im Array `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) aufgeführten hinaus. Die Liste findest du unter [Paketmanager-Hosts](https://platform.claude.com/docs/de/managed-agents/environments#package-manager-hosts). Standardwert ist `false`. Setze es auf `true`, wann immer die Umgebung `packages` (csharp, go: `Packages`) angibt; andernfalls wird die Anfrage mit einem 400-Fehler abgelehnt, selbst wenn die Registry-Hosts in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) aufgeführt sind.

#### Paketmanager-Hosts

Wenn `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) `true` ist, kann die Sandbox zusätzlich zu den Hosts in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) die folgenden Hosts erreichen. Anthropic pflegt diese Liste und kann sie ändern.

| Ökosystem    | Hosts                                                                                                                                                                                      |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Code-Hosting | `github.com`, `api.github.com`, `codeload.github.com`, `raw.githubusercontent.com`, `objects.githubusercontent.com`, `release-assets.githubusercontent.com`, `gitlab.com`, `bitbucket.org` |
| Node.js      | `registry.npmjs.org`, `registry.yarnpkg.com`, `nodejs.org`                                                                                                                                 |
| Python       | `pypi.org`, `files.pythonhosted.org`                                                                                                                                                       |
| Rust         | `crates.io`, `index.crates.io`, `static.crates.io`, `static.rust-lang.org`                                                                                                                 |
| Go           | `proxy.golang.org`, `sum.golang.org`                                                                                                                                                       |
| Java         | `repo1.maven.org`, `repo.maven.apache.org`, `services.gradle.org`, `plugins.gradle.org`, `plugins-artifacts.gradle.org`                                                                    |
| Ruby         | `rubygems.org`, `index.rubygems.org`                                                                                                                                                       |
| PHP          | `packagist.org`, `repo.packagist.org`                                                                                                                                                      |
| Ubuntu (apt) | `archive.ubuntu.com`, `security.ubuntu.com`, `ppa.launchpad.net`                                                                                                                           |
| Container    | `registry-1.docker.io`, `auth.docker.io`, `production.cloudflare.docker.com`, `download.docker.com`, `ghcr.io`                                                                             |

<Warning>
  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 Paketveröffentlichungen, mit allen Anmeldedaten, die der Befehl bereitstellt. Wenn der Agent nicht vertrauenswürdige Eingaben verarbeitet (Repository-Dateien, abgerufene Webinhalte oder Ausgaben von Drittanbieter-Tools), könnte eine erfolgreiche „prompt injection“ (Prompt-Injektion) einen erlaubten Host nutzen, um Dateien aus der Sandbox herauszukopieren. Um dieses Risiko zu verringern, setze die [Berechtigungsrichtlinie](https://platform.claude.com/docs/de/managed-agents/permission-policies) des `bash`-Tools auf `always_ask` oder `auto`. Wenn die Umgebung keine `packages` (csharp, go: `Packages`) angibt, kannst du stattdessen `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) auf `false` belassen und nur die Hosts, die dein Agent benötigt, in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) auflisten.
</Warning>

#### Risiken von uneingeschränktem Networking

Mit `unrestricted` Networking kann Code in der Sandbox Anfragen an jeden Host im Internet senden, mit Ausnahme von Hosts auf einer allgemeinen Sicherheits-Blocklist. Bevor du diesen Modus wählst, überlege, was der Agent mit diesem Zugriff tun kann:

* **Der Agent kann Dinge auf externen Websites ändern, nicht nur lesen:** Das `bash`-Tool kann jede beliebige Anfrage senden. Der Agent kann Daten posten, Formulare absenden, APIs aufrufen und Skripte ausführen, die Daten auf externen Websites ändern. Selbst eine Anfrage, die nur eine URL abruft, kann auf manchen Websites Daten ändern.
* **Standardmäßig hält nichts diese Anfragen an:** Die Standard-[Berechtigungsrichtlinie](https://platform.claude.com/docs/de/managed-agents/permission-policies) des Agent-Toolsets ist `always_allow`, sodass `bash`-Befehle ohne Genehmigung ausgeführt werden.
* **Alles in der Sandbox kann sie verlassen:** Dazu gehören Dateien, Tool-Ausgaben und alle Anmeldedaten oder Secrets, die du in die Sandbox legst.
* **Abgerufene Inhalte können den Agenten steuern:** Webseiten, API-Antworten und andere Inhalte, die der Agent liest, können Anweisungen enthalten (Prompt-Injektion), die ändern, was er als Nächstes tut.
* **Der Agent handelt in deinem Namen:** Seine Aktionen können gegen die Nutzungsbedingungen einer Website verstoßen oder dort Konten und Datensätze anlegen.
* **Modellverhalten ist keine Sicherheitskontrolle:** Der Agent kann auf externen Websites auf eine Weise handeln, um die du nicht gebeten hast, einschließlich eines erneuten Versuchs auf andere Weise, nachdem eine Website eine Anfrage blockiert hat. Verwende Netzwerkeinstellungen und Berechtigungsrichtlinien, um einzuschränken, was er tun kann.
* **Die Sicherheits-Blocklist ist keine Allowlist:** Sie schränkt nicht ein, welche anderen Websites der Agent erreicht oder was der Agent auf ihnen tut.

Um diese Risiken zu verringern, verwende `limited` Networking mit einer expliziten Liste von Hosts. Der folgende `networking`-Wert erlaubt `api.example.com` sowie die [Paketmanager-Hosts](https://platform.claude.com/docs/de/managed-agents/environments#package-manager-hosts) für einen Agenten, der Pakete installiert:

```json
{
  "type": "limited",
  "allowed_hosts": ["api.example.com"],
  "allow_package_managers": true
}
```

Ein Agent, der nur die Tools `web_search` und `web_fetch` verwendet, benötigt kein `unrestricted` Networking, wenn du die Websites auflisten kannst, die er braucht. Bei `limited` Networking gilt `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) auch für diese Tools (siehe [Networking](https://platform.claude.com/docs/de/managed-agents/environments#networking)), also liste diese Websites in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) auf. Wenn du sie zusätzlich in `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) von `web_search` auflistest, durchsucht es diese Websites. Ein Host, den du zu `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) hinzufügst, ist auch für die Sandbox offen. Um die Tools weiter einzuschränken, siehe [Domains für Websuche und Web-Fetch einschränken](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions).

Verwende `unrestricted` nur, wenn der Agent Websites erreichen muss, die du nicht im Voraus auflisten kannst. Halte in diesem Fall Secrets und sensible Dateien aus der Sandbox heraus und gib dem Agenten nur die Anmeldedaten, die die Aufgabe benötigt. Erwäge, die Berechtigungsrichtlinie des `bash`-Tools auf `always_ask` oder `auto` zu setzen, und [beobachte die Events der Session](https://platform.claude.com/docs/de/managed-agents/events-and-streaming).

## Lebenszyklus von Umgebungen

* Umgebungen bleiben bestehen, bis sie explizit archiviert oder gelöscht werden.
* Jede Session erhält ihre eigene Sandbox-Instanz, auch wenn mehrere Sessions dieselbe Umgebung referenzieren. Sessions teilen keinen Dateisystemzustand.
* Umgebungen sind nicht versioniert. Wenn du eine Umgebung häufig aktualisierst, führe deine eigenen Aufzeichnungen über die Änderungen, damit du nachvollziehen kannst, welche Konfiguration jede Session verwendet hat.

## Umgebungen verwalten

<CodeGroup>
  ```bash cURL
  # Liste Umgebungen auf
  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"

  # Rufe eine bestimmte Umgebung ab
  curl -fsS "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Archiviere eine Umgebung (schreibgeschützt, bestehende Sitzungen laufen weiter)
  curl -fsS -X POST "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Lösche eine Umgebung (nur wenn keine Sitzungen darauf verweisen)
  curl -fsS -X DELETE "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  # Environments auflisten
  ant beta:environments list

  # Ein bestimmtes Environment abrufen
  ant beta:environments retrieve --environment-id "$ENVIRONMENT_ID"

  # Ein Environment archivieren (schreibgeschützt, bestehende Sessions laufen weiter)
  ant beta:environments archive --environment-id "$ENVIRONMENT_ID"

  # Ein Environment löschen (nur wenn keine Session darauf verweist)
  ant beta:environments delete --environment-id "$ENVIRONMENT_ID"
  ```

  ```python Python
  # Liste Umgebungen auf
  environments = client.beta.environments.list()

  # Rufe eine bestimmte Umgebung ab
  env = client.beta.environments.retrieve(environment.id)

  # Archiviere eine Umgebung (schreibgeschützt, bestehende Sitzungen laufen weiter)
  client.beta.environments.archive(environment.id)

  # Lösche eine Umgebung (nur wenn keine Sitzungen darauf verweisen)
  client.beta.environments.delete(environment.id)
  ```

  ```typescript TypeScript
  // Liste Umgebungen auf
  const environments = await client.beta.environments.list();

  // Rufe eine bestimmte Umgebung ab
  const env = await client.beta.environments.retrieve(environment.id);

  // Archiviere eine Umgebung (schreibgeschützt, bestehende Sitzungen laufen weiter)
  await client.beta.environments.archive(environment.id);

  // Lösche eine Umgebung (nur wenn keine Sitzungen darauf verweisen)
  await client.beta.environments.delete(environment.id);
  ```

  ```csharp C#
  // Liste Umgebungen auf
  var environments = await client.Beta.Environments.List();

  // Rufe eine bestimmte Umgebung ab
  var env = await client.Beta.Environments.Retrieve(environment.ID);

  // Archiviere eine Umgebung (schreibgeschützt, bestehende Sitzungen laufen weiter)
  await client.Beta.Environments.Archive(environment.ID);

  // Lösche eine Umgebung (nur wenn keine Sitzungen darauf verweisen)
  await client.Beta.Environments.Delete(environment.ID);
  ```

  ```go Go
  // Umgebungen auflisten
  environments, err := client.Beta.Environments.List(ctx, anthropic.BetaEnvironmentListParams{})
  // ...

  // Eine bestimmte Umgebung abrufen
  env, err := client.Beta.Environments.Get(ctx, environment.ID, anthropic.BetaEnvironmentGetParams{})
  // ...

  // Eine Umgebung archivieren (schreibgeschützt, bestehende Sitzungen laufen weiter)
  _, err = client.Beta.Environments.Archive(ctx, environment.ID, anthropic.BetaEnvironmentArchiveParams{})
  // ...

  // Eine Umgebung löschen (nur wenn keine Sitzungen darauf verweisen)
  _, err = client.Beta.Environments.Delete(ctx, environment.ID, anthropic.BetaEnvironmentDeleteParams{})
  ```

  ```java Java
  // Liste Umgebungen auf
  var environments = client.beta().environments().list();
  // Rufe eine bestimmte Umgebung ab
  var env = client.beta().environments().retrieve(environment.id());
  // Archiviere eine Umgebung (schreibgeschützt, bestehende Sessions laufen weiter)
  client.beta().environments().archive(environment.id());
  // Lösche eine Umgebung (nur wenn keine Sessions darauf verweisen)
  client.beta().environments().delete(environment.id());
  ```

  ```php PHP
  // Umgebungen auflisten
  $environments = $client->beta->environments->list();
  // Eine bestimmte Umgebung abrufen
  $env = $client->beta->environments->retrieve($environment->id);
  // Eine Umgebung archivieren (schreibgeschützt, bestehende Sitzungen laufen weiter)
  $client->beta->environments->archive($environment->id);
  // Eine Umgebung löschen (nur wenn keine Sitzungen darauf verweisen)
  $client->beta->environments->delete($environment->id);
  ```

  ```ruby Ruby
  # Umgebungen auflisten
  environments = client.beta.environments.list

  # Eine bestimmte Umgebung abrufen
  env = client.beta.environments.retrieve(environment.id)

  # Eine Umgebung archivieren (schreibgeschützt, bestehende Sitzungen laufen weiter)
  client.beta.environments.archive(environment.id)

  # Eine Umgebung löschen (nur wenn keine Sitzungen darauf verweisen)
  client.beta.environments.delete(environment.id)
  ```
</CodeGroup>

## Vorinstallierte Laufzeitumgebungen

Cloud-Sandboxes enthalten standardmäßig gängige Sprach-Laufzeitumgebungen, Datenbanken und Kommandozeilen-Tools. Siehe [Cloud-Sandbox-Referenz](https://platform.claude.com/docs/de/managed-agents/cloud-sandboxes-reference) für die vollständige Liste.

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Cloud-Sandbox-Referenz" icon="book" href="https://platform.claude.com/docs/de/managed-agents/cloud-sandboxes-reference">
    Vorinstallierte Pakete, Datenbanken und Dienstprogramme, die in Cloud-Sandboxes verfügbar sind.
  </Card>

  <Card title="Eine Session starten" icon="play" href="https://platform.claude.com/docs/de/managed-agents/sessions">
    Erstelle eine Session, um deinen Agenten auszuführen und mit der Ausführung von Aufgaben zu beginnen.
  </Card>
</CardGroup>