---
title: Selbst gehostete Worker bereitstellen
url: https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers
description: Wähle, wie selbst gehostete Sandbox-Worker Arbeit beanspruchen und wo Sitzungen laufen, und führe dann einen dauerhaft aktiven Worker aus oder löse Worker über Webhooks aus.
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
---

Der [Schnellstart für selbst gehostete Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#quickstart) führt einen `ant`-CLI-Worker aus, der kontinuierlich pollt und jede Sitzung in einem Prozess ausführt. Diese Seite hilft dir, ein Bereitstellungsmuster zu wählen, und behandelt dann dauerhaft aktive und per Webhook ausgelöste Worker.

## Ein Bereitstellungsmuster wählen

Beim Bereitstellen von Workern musst du zwei Entscheidungen treffen: wie der Worker Arbeit beansprucht und wo jede Sitzung läuft.

**Wie der Worker Arbeit beansprucht:**

* **Dauerhaft aktiv:** Ein langlebiger Prozess pollt die Warteschlange kontinuierlich. Der Prozess sendet nur ausgehende HTTPS-Anfragen, sodass du keinen Endpunkt für Anthropic freigibst.
* **Per Webhook ausgelöst:** Ein Handler wird bei `session.status_run_started` aktiviert und beginnt mit dem Polling. Dadurch wird ein untätiger Poller vermieden, es ist jedoch ein [Webhook](https://platform.claude.com/docs/de/managed-agents/webhooks)-Endpunkt erforderlich, den Anthropic erreichen kann.

**Wo jede Sitzung läuft:**

* **Im Prozess:** Der Worker, der eine Sitzung beansprucht, führt auch deren Tool-Aufrufe aus, in einem gemeinsamen Arbeitsverzeichnis.
* **Sandbox pro Sitzung:** Ein Poller startet für jede beanspruchte Sitzung eine neue Sandbox. Wähle dies für stärkere Isolation: ein frisches Dateisystem, Ressourcenlimits oder Netzwerkkontrollen pro Sitzung. Siehe [Eine Sandbox pro Sitzung ausführen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-per-session), wo auch das Helm-Chart für Kubernetes behandelt wird.

Die CLI- und SDK-Worker unterstützen unterschiedliche Kombinationen:

| Fähigkeit | `ant` CLI | SDK (Python, TypeScript, Go) |
| ----- | ----- | ----- |
| Dauerhaft aktives Polling | Ja | Ja |
| Per Webhook ausgelöst | Nein | Ja |
| [Sandbox pro Sitzung](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-per-session) | Ja | Ja |
| [Memory Stores](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory) | Ja, mit Standard-Synchronisierungseinstellungen | Ja, mit konfigurierbarer Synchronisierung |
| [Benutzerdefinierte Tools](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-custom-tools) | Nein | Ja |

Siehe [Referenz für selbst gehostete Worker](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference) für jedes CLI-Flag und jede SDK-Option.

Für mehr Kontrolle rufe die [Environments-Work-Endpunkte](https://platform.claude.com/docs/de/api/beta/environments/work) direkt auf und implementiere deinen eigenen Worker. Dein Worker übernimmt dann die Aufgaben der SDK-Worker. Unter anderem bestätigt er jedes Arbeitselement, sendet Heartbeats und lädt die Skills des Agenten herunter. Er führt nur die Tool-Aufrufe aus, die die [„permission policy“ (Berechtigungsrichtlinie)](https://platform.claude.com/docs/de/managed-agents/permission-policies#see-how-each-call-was-evaluated) der Sitzung erlaubt. Er gibt jedes Ergebnis als `user.tool_result`- oder `user.custom_tool_result`-Event zurück. Am Ende stoppt er das Arbeitselement. Verwende den Quellcode des Workers im [Python-SDK](https://github.com/anthropics/anthropic-sdk-python/tree/main/src/anthropic/lib/environments), im [TypeScript-SDK](https://github.com/anthropics/anthropic-sdk-typescript/tree/main/src/lib/environments) oder im [Go-SDK](https://github.com/anthropics/anthropic-sdk-go/tree/main/lib/environments) als Referenz.

## Einen dauerhaft aktiven Worker ausführen

Diese Beispiele verwenden `/workspace` als Arbeitsverzeichnis des Workers. Das Verzeichnis muss existieren, bevor der Worker startet. Erstelle es auf einem neuen Host und gib dem Benutzer des Workers Schreibzugriff, wie im Schritt „Den Worker starten“ von [Deine erste Sitzung ausführen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#run-your-first-session).

Unter macOS kann `mkdir` das Verzeichnis `/workspace` nicht erstellen, weil das Root-Volume schreibgeschützt ist. Erstelle stattdessen `~/workspace`, wie es dieser Schritt zeigt. Verwende anstelle von `/workspace` den vollständigen Pfad, den `echo ~/workspace` ausgibt, da das SDK `~` nicht expandiert.

Starte einen Worker, der die Warteschlange kontinuierlich pollt. Er authentifiziert sich mit dem [Umgebungsschlüssel](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#run-your-first-session) aus dem Schnellstart:

<CodeGroup exclude="shell:cURL, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Ein Worker ist ein langlebiger Prozess, keine einzelne HTTP-Anfrage. Führe stattdessen den `ant`-CLI-Worker aus: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  ```bash CLI
  ant beta:worker poll --workdir /workspace
  ```

  ```python Python
  import asyncio
  import contextlib
  import os
  import signal
  from anthropic import AsyncAnthropic
  from anthropic.lib.environments import EnvironmentWorker


  async def main() -> None:
      environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
      environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"]
      async with AsyncAnthropic(auth_token=environment_key) as client:
          worker = EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
          )
          task = asyncio.create_task(worker.run())
          # Das Abbrechen des Tasks statt des Beendens des Prozesses lässt den Worker sein
          # laufendes Arbeitselement stoppen und geänderte Memory-Dateien hochladen, bevor er beendet wird.
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task


  asyncio.run(main())
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";
  import { EnvironmentWorker } from "@anthropic-ai/sdk/helpers/beta/environments";

  const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
  const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!;
  const client = new Anthropic({ authToken: environmentKey });
  const controller = new AbortController();
  // Ein Abbruch bei einem der beiden Signale lässt den Worker geänderte Memory-Dateien hochladen und seine
  // Store-Verzeichnisse entfernen, bevor der Prozess beendet wird.
  process.once("SIGINT", () => controller.abort());
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal
  }).run();
  ```

  <CodeGroupItem language="C#">
    Das C#-SDK hat keinen `EnvironmentWorker`. Führe stattdessen den `ant`-CLI-Worker aus: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  ```go Go
  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  	"github.com/anthropics/anthropic-sdk-go/v2/lib/environments"
  	"github.com/anthropics/anthropic-sdk-go/v2/option"
  )

  func main() {
  	environmentKey := os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("ANTHROPIC_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := anthropic.NewClient(option.WithAuthToken(environmentKey))

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }
  ```

  <CodeGroupItem language="Java">
    Das Java-SDK hat keinen `EnvironmentWorker`. Führe stattdessen den `ant`-CLI-Worker aus: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    Das PHP-SDK hat keinen `EnvironmentWorker`. Führe stattdessen den `ant`-CLI-Worker aus: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Das Ruby-SDK hat keinen `EnvironmentWorker`. Führe stattdessen den `ant`-CLI-Worker aus: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>
</CodeGroup>

## Worker über Webhooks auslösen

<Steps>
  <Step title="Sitzungs-Webhooks abonnieren">
    Definiere in der [Claude Console](https://platform.claude.com/settings/workspaces/default/webhooks) einen Webhook-Endpunkt, der auf `session.status_run_started`-Events hört. Siehe [Webhooks abonnieren](https://platform.claude.com/docs/de/managed-agents/webhooks) für Details.
  </Step>

  <Step title="Den Webhook-Signaturschlüssel exportieren">
    Exportiere zusammen mit der Environment-ID und dem Key aus [Deine erste Sitzung ausführen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#run-your-first-session) den Webhook-Signaturschlüssel auf deinem Handler-Host. Der Handler verwendet ihn, um eingehende Payloads zu verifizieren.

    ```bash
    export ANTHROPIC_WEBHOOK_SIGNING_KEY="whsec_..."
    ```
  </Step>

  <Step title="Den Webhook-Handler implementieren">
    Starte den Worker, wenn `session.status_run_started` ausgelöst wird. Der Handler leert die Warteschlange und übergibt jedes übernommene Arbeitselement an `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) (in den Python-, TypeScript- und Go-SDKs). Diese Methode lädt Skills herunter, führt Tool-Aufrufe aus, sendet Ergebnisse zurück und kehrt zurück.

    Die Beispiele verwenden `/workspace` als Arbeitsverzeichnis. Bevor du den Handler startest, erstelle dieses Verzeichnis auf dem Handler-Host. Stelle sicher, dass der Benutzer des Handlers in das Verzeichnis schreiben kann, wie im Schritt „Den Worker starten“ von [Deine erste Sitzung ausführen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#run-your-first-session).

    <CodeGroup exclude="shell, csharp, java, php, ruby">
      <CodeGroupItem language="cURL">
        Dieser Handler erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das Python-, TypeScript- oder Go-SDK, um ihn auszuführen.
      </CodeGroupItem>

      <CodeGroupItem language="CLI">
        Dieser Handler erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das Python-, TypeScript- oder Go-SDK, um ihn auszuführen.
      </CodeGroupItem>

      <CodeGroupItem>
        Um Webhook-Signaturen zu verifizieren, installiere das Webhooks-Extra: `pip install "anthropic[webhooks]"`.

        ```python Python
        import asyncio
        import os
        import anthropic
        import standardwebhooks  # installed by the anthropic[webhooks] extra

        environment_key = os.environ["ANTHROPIC_ENVIRONMENT_KEY"]
        environment_id = os.environ["ANTHROPIC_ENVIRONMENT_ID"]
        client = anthropic.AsyncAnthropic(
            auth_token=environment_key,
        )
        # Wird von shutdown() abgebrochen, damit ein laufendes Arbeitselement geänderte Memory-Dateien hochladen und
        # seine Store-Verzeichnisse entfernen kann, bevor der Prozess endet.
        inflight: set[asyncio.Task[None]] = set()


        # Rufe dies mit await im Shutdown-Hook des Hosts auf, etwa beim ASGI-Lifespan-Shutdown (der Code nach
        # `yield` in einem FastAPI-Lifespan), den uvicorn bei SIGTERM ausführt. uvicorn lässt offene Requests
        # abschließen, bevor dieser Hook läuft; setze daher --timeout-graceful-shutdown, um die Wartezeit zu begrenzen.
        async def shutdown() -> None:
            for task in inflight:
                task.cancel()
            await asyncio.gather(*inflight, return_exceptions=True)


        async def handle(raw: bytes, headers: dict[str, str]) -> tuple[dict[str, str], int]:
            try:
                event = client.beta.webhooks.unwrap(raw.decode(), headers=headers)
            except standardwebhooks.WebhookVerificationError:
                return {"error": "signature verification failed"}, 401
            if event.data.type != "session.status_run_started":
                return {"status": "ignored"}, 200
            task = asyncio.create_task(run_queued_work())
            inflight.add(task)
            task.add_done_callback(inflight.discard)
            try:
                # Abgeschirmt: Eine abgebrochene oder zeitüberschrittene Zustellung darf das Element nicht abbrechen; das tut shutdown().
                await asyncio.shield(task)
            except asyncio.CancelledError:
                return {"status": "shutting down"}, 503
            return {"status": "ok"}, 200


        async def run_queued_work() -> None:
            async for work in client.beta.environments.work.poller(
                environment_id=environment_id,
                environment_key=environment_key,
                block_ms=None,
                reclaim_older_than_ms=2000,
                drain=True,
                auto_stop=False,
            ):
                await client.beta.environments.work.worker(workdir="/workspace").handle_item(
                    work_id=work.id,
                    environment_id=environment_id,
                    session_id=work.data.id,
                    environment_key=environment_key,
                    # Über das Secret pro Sitzung kann der Worker die Memory-Stores der Sitzung einbinden.
                    work_secret=work.secret,
                )
        ```
      </CodeGroupItem>

      ```typescript TypeScript
      import Anthropic from "@anthropic-ai/sdk";

      const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
      const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!;
      const client = new Anthropic({
        authToken: environmentKey
      });
      // Rufe shutdown.abort() aus dem SIGTERM/SIGINT-Handler des Hosts auf, zusammen mit dem Schließen des Servers,
      // und warte dann vor dem Beenden auf laufende handle()-Aufrufe: Der Abort lässt ein laufendes Work-Item
      // zuerst geänderte Memory-Dateien hochladen und seine Store-Verzeichnisse entfernen.
      export const shutdown = new AbortController();

      export async function handle(req: Request): Promise<Response> {
        // Bestätige nie eine Zustellung, deren Arbeit hier nicht läuft; ein 503 lässt den Absender erneut versuchen.
        if (shutdown.signal.aborted) {
          return Response.json({ status: "shutting down" }, { status: 503 });
        }
        const body = await req.text();
        let event;
        try {
          event = client.beta.webhooks.unwrap(body, { headers: Object.fromEntries(req.headers) });
        } catch {
          return new Response("signature verification failed", { status: 401 });
        }
        if (event.data.type !== "session.status_run_started") {
          return Response.json({ status: "ignored" });
        }

        for await (const work of client.beta.environments.work.poller({
          environmentId,
          environmentKey,
          blockMs: null,
          reclaimOlderThanMs: 2000,
          drain: true,
          autoStop: false,
          signal: shutdown.signal
        })) {
          await client.beta.environments.work.worker({ workdir: "/workspace" }).handleItem({
            workId: work.id,
            environmentId,
            sessionId: work.data.id,
            environmentKey,
            // Das Secret pro Session ermöglicht es dem Worker, die Memory-Stores der Session einzubinden.
            workSecret: work.secret ?? undefined,
            signal: shutdown.signal
          });
        }
        // Poller und handleItem kehren bei Abort still zurück, sodass ein abgebrochener Drain hier landet.
        if (shutdown.signal.aborted) {
          return Response.json({ status: "shutting down" }, { status: 503 });
        }
        return Response.json({ status: "ok" });
      }
      ```

      <CodeGroupItem language="C#">
        Das C#-SDK hat keinen `EnvironmentWorker`. Um Arbeitselemente aus deinem eigenen Code zu verarbeiten, implementiere deinen eigenen Worker, wie unter [Ein Bereitstellungsmuster wählen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern) beschrieben.
      </CodeGroupItem>

      ```go Go
      package main

      import (
      	"context"
      	"encoding/json"
      	"errors"
      	"io"
      	"log/slog"
      	"net/http"
      	"os"
      	"os/signal"
      	"syscall"

      	"github.com/anthropics/anthropic-sdk-go/v2"
      	"github.com/anthropics/anthropic-sdk-go/v2/lib/environments"
      	"github.com/anthropics/anthropic-sdk-go/v2/option"
      	"github.com/anthropics/anthropic-sdk-go/v2/packages/param"
      )

      var (
      	environmentKey = os.Getenv("ANTHROPIC_ENVIRONMENT_KEY")
      	environmentID  = os.Getenv("ANTHROPIC_ENVIRONMENT_ID")
      	client         = anthropic.NewClient(
      		option.WithAuthToken(environmentKey),
      		option.WithWebhookKey(os.Getenv("ANTHROPIC_WEBHOOK_SIGNING_KEY")),
      	)
      	worker = environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
      		Workdir: "/workspace",
      	})
      	// Wird bei SIGINT oder SIGTERM abgebrochen (in main gesetzt), damit ein laufendes Arbeitselement
      	// geänderte Memory-Dateien hochladen und seine Store-Verzeichnisse vor dem Beenden entfernen kann.
      	shutdown context.Context
      )

      func handle(w http.ResponseWriter, r *http.Request) {
      	body, err := io.ReadAll(r.Body)
      	if err != nil {
      		http.Error(w, "bad request", http.StatusBadRequest)
      		return
      	}
      	event, err := client.Beta.Webhooks.Unwrap(body, r.Header)
      	if err != nil {
      		http.Error(w, "signature verification failed", http.StatusUnauthorized)
      		return
      	}
      	if event.Data.Type != "session.status_run_started" {
      		json.NewEncoder(w).Encode(map[string]string{"status": "ignored"})
      		return
      	}

      	// Das Go-SDK bietet keine RunOne-Komfortfunktion: Arbeite ausstehende Elemente
      	// mit WorkPoller ab und führe jedes mit HandleItem aus.
      	// Von r.Context() lösen: Die Sitzung kann den Zustellungs-Timeout des Webhooks überdauern.
      	// Der prozessweite Shutdown-Kontext beendet das Element bei SIGTERM trotzdem sauber.
      	ctx := shutdown
      	poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{
      		EnvironmentID:      environmentID,
      		EnvironmentKey:     environmentKey,
      		BlockMs:            param.Null[int64](),
      		ReclaimOlderThanMs: param.NewOpt[int64](2000),
      		Drain:              true,
      		AutoStop:           param.NewOpt(false),
      	})
      	defer poller.Close()
      	for poller.Next() {
      		item := poller.Current()
      		if err := worker.HandleItem(ctx, environments.HandleItemOptions{
      			WorkID:         item.ID,
      			EnvironmentID:  item.EnvironmentID,
      			SessionID:      item.Data.ID,
      			EnvironmentKey: environmentKey,
      			// Das sitzungsspezifische Secret erlaubt dem Worker, die Memory-Stores der Sitzung einzubinden.
      			WorkSecret: item.Secret,
      		}); err != nil {
      			slog.Error("handle work item", "work_id", item.ID, "err", err)
      			http.Error(w, "internal error", http.StatusInternalServerError)
      			return
      		}
      	}
      	if err := poller.Err(); err != nil {
      		slog.Error("poll work queue", "err", err)
      		http.Error(w, "internal error", http.StatusInternalServerError)
      		return
      	}
      	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
      }

      func main() {
      	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
      	defer stop()
      	shutdown = ctx

      	server := &http.Server{Addr: ":8080"}
      	http.HandleFunc("POST /webhook", handle)
      	go func() {
      		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
      			slog.Error("http server", "err", err)
      			os.Exit(1)
      		}
      	}()
      	// Bei einem Signal keine Zustellungen mehr annehmen und erst zurückkehren, wenn laufende
      	// Handler und damit der Memory-Abbau ihrer Arbeitselemente abgeschlossen sind.
      	<-ctx.Done()
      	if err := server.Shutdown(context.Background()); err != nil {
      		slog.Error("http shutdown", "err", err)
      	}
      }
      ```

      <CodeGroupItem language="Java">
        Das Java-SDK hat keinen `EnvironmentWorker`. Um Arbeitselemente aus deinem eigenen Code zu verarbeiten, implementiere deinen eigenen Worker, wie unter [Ein Bereitstellungsmuster wählen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern) beschrieben.
      </CodeGroupItem>

      <CodeGroupItem language="PHP">
        Das PHP-SDK hat keinen `EnvironmentWorker`. Um Arbeitselemente aus deinem eigenen Code zu verarbeiten, implementiere deinen eigenen Worker, wie unter [Ein Bereitstellungsmuster wählen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern) beschrieben.
      </CodeGroupItem>

      <CodeGroupItem language="Ruby">
        Das Ruby-SDK hat keinen `EnvironmentWorker`. Um Arbeitselemente aus deinem eigenen Code zu verarbeiten, implementiere deinen eigenen Worker, wie unter [Ein Bereitstellungsmuster wählen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern) beschrieben.
      </CodeGroupItem>
    </CodeGroup>

    In den Python-, TypeScript- und Go-SDKs benötigt `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) das Secret des Arbeitselements, um Memory Stores einzubinden. Ein Worker, der mit `run()` (go: `Run()`) pollt, hat das Secret bereits. Dieser Handler beansprucht jedes Arbeitselement selbst und übergibt das Secret daher im Argument `work_secret` (typescript: `workSecret`; go: `WorkSecret`). Siehe [Das Secret des Arbeitselements weiterleiten](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-per-session#forward-the-work-items-secret).
  </Step>
</Steps>

Dieser Handler führt jedes beanspruchte Arbeitselement in einem Prozess aus, und er führt Arbeitselemente aus separaten Webhook-Zustellungen gleichzeitig aus. Diese Sitzungen teilen sich ein Dateisystem, einschließlich `/workspace` und `/mnt/memory`. Wenn deine Sitzungen denselben Memory Store anhängen, siehe [Sitzungen isolieren, die sich einen Store teilen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory#isolate-sessions-that-share-a-store).

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Eine Sandbox pro Sitzung ausführen" icon="cube" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-per-session">
    Starte Sandboxes mit dem Helm-Chart auf Kubernetes, einem Spawn-Skript oder dem SDK-Poller.
  </Card>

  <Card title="Selbst gehostete Worker überwachen und Fehler beheben" icon="lightning" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-operations">
    Lies die Warteschlangentiefe aus, stoppe Sitzungen und Worker sauber und behebe häufige Fehler.
  </Card>

  <Card title="Sicherheitsmodell" icon="lock" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-security">
    Modell der geteilten Verantwortung für selbst gehostete Sandbox-Umgebungen.
  </Card>
</CardGroup>

## Verfügbarkeit

Vorgefertigte selbst gehostete Worker sind 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`
