---
title: Referenz für selbst gehostete Worker
url: https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference
description: "Referenz für selbst gehostete Sandbox-Worker: ant-CLI-Flags, Umgebungsvariablen, Host-Anforderungen, Dateisystempfade und Optionen der SDK-Helfer."
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
---

Diese Seite dokumentiert die vorgefertigten Worker, die eine `self_hosted`-Umgebung bedienen. Für aufgabenorientierte Leitfäden beginne mit [Selbst gehostete Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes) und [Selbst gehostete Worker bereitstellen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers).

## CLI-Befehle und Flags

| Befehl | Beschreibung |
| ----- | ----- |
| `ant beta:worker poll` | Beansprucht Arbeitselemente aus der Warteschlange der Umgebung und führt jede Sitzung im Prozess aus. Mit `--on-work` ruft es stattdessen für jedes Arbeitselement dein Skript auf. |
| `ant beta:worker run` | Verarbeitet eine beanspruchte Sitzung und beendet sich. Verwende es als Einstiegspunkt einer Sandbox pro Sitzung. |

| Flag | Beschreibung |
| ----- | ----- |
| `--environment-id` | Die Umgebung, die nach Arbeit abgefragt wird. Wird auch aus `ANTHROPIC_ENVIRONMENT_ID` gelesen. |
| `--environment-key` | Authentifiziert den Worker bei dieser Umgebung. Wird auch aus `ANTHROPIC_ENVIRONMENT_KEY` gelesen. |
| `--workdir` | Verzeichnis, in das der Worker Skills herunterlädt und in dem Tools Dateien lesen und schreiben. Standardmäßig `.` (das aktuelle Verzeichnis). Das Verzeichnis muss existieren, bevor der Worker startet. |
| `--on-work` | Skript, das für jedes beanspruchte Arbeitselement aufgerufen wird, anstatt Tools im Prozess auszuführen. Erhält Sitzungsdetails als Umgebungsvariablen und das Arbeitselement als JSON über die Standardeingabe. |
| `--max-idle` | Wie lange der Worker wartet, während eine Sitzung im Leerlauf ist, bevor sich `ant beta:worker run` beendet oder `ant beta:worker poll` zum nächsten Arbeitselement übergeht. Leerlaufzeit mit einem [`requires_action`-Stop-Grund](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) zählt nicht. Standardmäßig `60s`. Setze den Wert auf `0`, um das Timeout zu deaktivieren. Mit einem `--on-work`-Skript ignoriert `ant beta:worker poll` dieses Flag. Übergib es stattdessen an den `ant beta:worker run`-Befehl, den dein Skript startet. |
| `--log-format` | Format der Log-Ausgabe. Verwende `json` für die strukturierte Log-Erfassung. Standardmäßig `text`. |

## Umgebungsvariablen

| Variable | Beschreibung | Gesetzt von |
| ----- | ----- | ----- |
| `ANTHROPIC_ENVIRONMENT_ID` | Die Umgebung, deren Warteschlange der Worker bedient. | Dir, auf dem Worker-Host. Der Poller übergibt sie an das `--on-work`-Skript. |
| `ANTHROPIC_ENVIRONMENT_KEY` | Authentifiziert den Worker bei seiner Warteschlange. | Dir, auf dem Worker-Host. Der Poller übergibt sie an das `--on-work`-Skript. |
| `ANTHROPIC_SESSION_ID` | Die Sitzung, die ein beanspruchtes Arbeitselement repräsentiert. | Dem Poller, für das `--on-work`-Skript. |
| `ANTHROPIC_WORK_ID` | Das beanspruchte Arbeitselement. | Dem Poller, für das `--on-work`-Skript. |
| `ANTHROPIC_WORK_SECRET` | Das Secret des Arbeitselements für seine Sitzung. | Dir. Der Poller setzt sie nicht. Siehe [Das Secret des Arbeitselements weiterleiten](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-per-session#forward-the-work-items-secret). |
| `ANTHROPIC_BASE_URL` | Überschreibt den Standard-API-Endpunkt. Optional. | Dir, auf dem Worker-Host. |
| `ANTHROPIC_WEBHOOK_SIGNING_KEY` | Verifiziert eingehende Webhook-Payloads. | Dir, auf einem Webhook-Handler-Host. |

## Host-Anforderungen

| Worker | Anforderung |
| ----- | ----- |
| Alle Worker | Ein Linux- oder macOS-Host mit `/bin/bash` unter genau diesem Pfad. Das `bash`-Tool des Workers führt es direkt aus, ohne `PATH` zu berücksichtigen. Unter macOS ist das die System-Bash 3.2. |
| TypeScript SDK | `unzip` und `tar` im `PATH` sowie Node.js 22 oder neuer. |
| Python und Go SDKs | Keine zusätzlichen Binärdateien. Diese SDKs verwenden ihre Standardbibliotheken zum Entpacken von Archiven. |

[Memory Stores](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory#requirements) bringen eigene Anforderungen mit.

Unter macOS ist das Root-Volume schreibgeschützt, daher kann `mkdir` das Verzeichnis `/workspace` nicht erstellen. Setze das Arbeitsverzeichnis des Workers auf ein Verzeichnis, in das du schreiben kannst, etwa ein `workspace`-Verzeichnis in deinem Home-Verzeichnis. Um Memory Stores unter macOS zu verwenden, [bereite zuerst den macOS-Host vor](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory#prepare-a-macos-host).

## Sandbox-Dateisystem

| Pfad | Inhalt |
| ----- | ----- |
| `/workspace` | Das Arbeitsverzeichnis in den Beispielen auf den Seiten zu selbst gehosteten Sandboxes. Es ist nicht der Standard des Workers: Der Worker verwendet das aktuelle Verzeichnis, sofern du nicht `--workdir` oder `workdir` (go: `Workdir`) setzt. Die Cloud-Sandboxes von Anthropic legen Skills und Repositorys in `/workspace` ab. Wenn du ein anderes Arbeitsverzeichnis verwendest, aktualisiere den System-Prompt deines Agenten, damit Claude die Skill-Dateien finden kann. |
| `<workdir>/skills/<name>/` | Die heruntergeladenen Skills des Agenten. |
| `/mnt/memory/<store>/` | Eine lokale Kopie jedes angehängten Memory Stores, ein Verzeichnis pro Store. Die API gibt den vollständigen Pfad jedes Verzeichnisses im Feld `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) der Memory-Store-Ressource der Sitzung zurück (zum Beispiel `/mnt/memory/user-preferences/`). |

Der Worker erstellt die Memory-Store-Verzeichnisse, wenn er eine Sitzung beansprucht. Er entfernt sie, wenn er mit dieser Sitzung fertig ist oder wenn du [den Worker ordnungsgemäß stoppst](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-operations#stop-workers-gracefully). Dadurch werden nur die lokalen Kopien entfernt, und die Memories bleiben im Store.

Skills können ausführbare Dateien enthalten, die der Agent direkt ausführen kann. Die CLI- und SDK-Worker behalten beim Entpacken die im Skill-Bundle hinterlegten Ausführungsberechtigungen bei. Wenn du Skills selbst herunterlädst, setze ihre Ausführungsberechtigungen selbst.

### Wann der Worker mit einer Sitzung fertig ist

Der Worker ist in jedem dieser Fälle mit einer Sitzung fertig:

* Die Sitzung endet.
* Du [stoppst das Arbeitselement der Sitzung](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-operations#stop-a-session-gracefully).
* Die Sitzung bleibt für die Dauer des Leerlauflimits des Workers im Leerlauf. Die Sitzung selbst bleibt offen. Wenn du ihr dann ein neues Event sendest, etwa eine Benutzernachricht, beansprucht derselbe Worker oder ein anderer die Sitzung. Dieser Worker lädt die Stores erneut herunter.

Das Leerlauflimit beträgt standardmäßig 60 Sekunden. Um es zu ändern, verwende [`--max-idle`](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference#cli-commands-and-flags) für den `ant`-CLI-Worker oder [`max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`)](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference#environment-worker) für `EnvironmentWorker`. Das [`cma-sandboxes`-Helm-Chart](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes) startet seine Worker stattdessen mit einem Limit von 30 Minuten. Um dieses Limit zu ändern, ändere die Einstellung `sandbox.idleTimeout` des Charts.

### Endgültige Ergebnisse

Selbst gehostete Sandboxes haben kein `/mnt/session/outputs`-Verzeichnis. In den Cloud-Sandboxes von Anthropic weist der System-Prompt der Sitzung den Agenten an, endgültige Ergebnisse dorthin zu kopieren. In selbst gehosteten Umgebungen lässt der System-Prompt diese Anweisung weg. Endgültige Ergebnisse bleiben dort, wo der Agent sie ablegt, typischerweise unterhalb des Arbeitsverzeichnisses, und der Worker lädt sie nicht hoch.

Um endgültige Ergebnisse an einem Ort zu sammeln, gib im System-Prompt deines Agenten den vollständigen Pfad eines Verzeichnisses an. Wähle ein Verzeichnis, in das die Datei-Tools des Workers schreiben können:

* **Innerhalb des Arbeitsverzeichnisses:** Zum Beispiel `/workspace/outputs`, wenn das Arbeitsverzeichnis `/workspace` ist.
* **An einem anderen Ort, nur mit einem SDK-Worker:** Füge das Verzeichnis zu `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`) hinzu. Siehe [AgentToolContext und das Agent-Toolset](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference#agent-tool-context-and-the-agent-toolset).

## SDK-Helfer

Die Python-, TypeScript- und Go-SDKs bieten drei Helfer mit unterschiedlichem Kontrollgrad:

| Helfer | Was er tut | Verwende ihn, wenn |
| ----- | ----- | ----- |
| [`EnvironmentWorker`](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference#environment-worker) | Übernimmt Polling, Einrichtung und Tool-Ausführung von Anfang bis Ende. | In den meisten Fällen. |
| [`work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`)](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference#work-poller) | Fragt die Arbeitswarteschlange ab und übergibt dir jede beanspruchte Sitzung. | Du bestimmst, wie jede Sitzung behandelt wird, zum Beispiel durch das Starten einer Sandbox, anstatt Tools im Prozess auszuführen. |
| [`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`)](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference#session-tool-runner) | Führt Tool-Aufrufe für eine einzelne Sitzung aus, anhand der Sitzungs-ID und einer Tool-Liste. | Du hast die Arbeit bereits beansprucht und musst nur die Tools ausführen. |

### EnvironmentWorker

| Methode | Beschreibung |
| ----- | ----- |
| `run()` (go: `Run()`) | Läuft unbegrenzt und übernimmt Sitzungen, sobald sie eintreffen. |
| `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) | Verarbeitet ein Arbeitselement, das bereits von einem Poller beansprucht wurde. Der Poller kann `ant beta:worker poll --on-work` oder dein eigener Code sein. Die Methode kehrt zurück, wenn der Worker mit der Sitzung des Elements fertig ist. Du kannst `work_id` (typescript: `workId`; go: `WorkID`), `session_id` (typescript: `sessionId`; go: `SessionID`), `environment_id` (typescript: `environmentId`; go: `EnvironmentID`) und `work_secret` (typescript: `workSecret`; go: `WorkSecret`) übergeben. Für jeden Wert, den du weglässt, liest die Methode die entsprechende [`ANTHROPIC_*`-Variable](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference#environment-variables). |

| Option | Beschreibung |
| ----- | ----- |
| `tools` (go: `ToolsFunc`) | Eine Factory, die den `AgentToolContext` der Sitzung erhält und die Tool-Liste zurückgibt. Standardmäßig das Standard-Agent-Toolset. |
| `max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`) | Wie lange der Worker wartet, während eine Sitzung im Leerlauf ist, bevor er mit der Sitzung fertig ist. Leerlaufzeit mit einem [`requires_action`-Stop-Grund](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) zählt nicht. Standardmäßig 60 Sekunden. Um 5 Minuten zu warten, setze den Wert auf `300` (typescript: `300_000`; go: `anthropic.Ptr(5 * time.Minute)`). Um das Limit zu deaktivieren, setze den Wert auf `None` (typescript: `0`; go: `new(time.Duration)`). |
| `memory_sync_interval` (typescript: `memorySyncIntervalMs`; go: `MemorySyncInterval`) | Die kürzeste Zeit zwischen zwei Synchronisierungen der angehängten Memory Stores während der Sitzung. Der Worker prüft das Intervall nach jedem Aufruf eines Tools, das in deiner Sandbox läuft, nicht per Timer. Standardmäßig 15 Sekunden. Siehe [Synchronisierungsintervall](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory#sync-interval). |
| `memory_sync_deletions` (typescript: `memorySyncDeletions`; go: `MemorySyncDeletions`) | Ob Dateien, die der Agent lokal löscht, auch aus dem Store gelöscht werden. Siehe [Löschungen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory#deletions). |

`EnvironmentWorker` verwaltet den `AgentToolContext` und das Toolset automatisch. Übergib eine `tools` (go: `ToolsFunc`)-Factory, um die Tool-Liste anzupassen:

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Ein Worker ist ein langlebiger Prozess, keine einzelne HTTP-Anfrage. Um die Tool-Liste anzupassen, verwende `EnvironmentWorker` im Python-, TypeScript- oder Go-SDK.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Der `ant`-CLI-Worker verwendet immer das Standard-Agent-Toolset. Um die Tool-Liste anzupassen, verwende `EnvironmentWorker` im Python-, TypeScript- oder Go-SDK.
  </CodeGroupItem>

  ```python Python
  import asyncio
  import contextlib
  import os
  import signal
  from anthropic import AsyncAnthropic, beta_async_tool
  from anthropic.lib.environments import EnvironmentWorker
  from anthropic.lib.tools.agent_toolset import beta_bash_tool


  @beta_async_tool
  async def get_order_status(order_id: str) -> str:
      """Look up an order in the internal fulfillment system by order ID."""
      return f"Order {order_id}: shipped"


  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,
              # Liste jedes Tool auf, das der Agent aufrufen kann. Der Worker beantwortet kein anderes Tool.
              tools=lambda env: [beta_bash_tool(env), get_order_status],
          )
          task = asyncio.create_task(worker.run())
          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";
  import { betaTool } from "@anthropic-ai/sdk/helpers/beta/json-schema";
  import { betaBashTool } from "@anthropic-ai/sdk/tools/agent-toolset/node";

  const getOrderStatus = betaTool({
    name: "get_order_status",
    description: "Look up an order in the internal fulfillment system by order ID.",
    inputSchema: {
      type: "object",
      properties: { order_id: { type: "string", description: "The order ID" } },
      required: ["order_id"]
    },
    run: async ({ order_id }) => `Order ${order_id}: shipped`
  });

  const environmentKey = process.env.ANTHROPIC_ENVIRONMENT_KEY!;
  const environmentId = process.env.ANTHROPIC_ENVIRONMENT_ID!;
  const client = new Anthropic({ authToken: environmentKey });
  const controller = new AbortController();
  process.once("SIGINT", () => controller.abort());
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    signal: controller.signal,
    // Liste jedes Tool auf, das der Agent aufrufen kann. Der Worker beantwortet kein anderes Tool.
    tools: (ctx) => [betaBashTool(ctx), getOrderStatus]
  }).run();
  ```

  <CodeGroupItem language="C#">
    Das C#-SDK hat keinen `EnvironmentWorker`. Um Aufrufe benutzerdefinierter Tools aus deinem eigenen Code zu beantworten, sende jedes Ergebnis über den Event-Stream der Sitzung, wie unter [Ein Custom-Tool-Ergebnis zurückgeben](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#return-a-custom-tool-result) beschrieben.
  </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"
  	"github.com/anthropics/anthropic-sdk-go/v2/toolrunner"
  	"github.com/anthropics/anthropic-sdk-go/v2/tools/agenttoolset"
  )

  type orderStatusInput struct {
  	OrderID string `json:"order_id"`
  }

  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()

  	getOrderStatus := toolrunner.NewBetaTool(
  		"get_order_status",
  		"Look up an order in the internal fulfillment system by order ID.",
  		anthropic.BetaToolInputSchemaParam{
  			Properties: map[string]any{
  				"order_id": map[string]any{"type": "string", "description": "The order ID"},
  			},
  			Required: []string{"order_id"},
  		},
  		func(ctx context.Context, input orderStatusInput) (anthropic.BetaToolResultBlockParamContentUnion, error) {
  			return anthropic.BetaToolResultBlockParamContentUnion{
  				OfText: &anthropic.BetaTextBlockParam{Text: "Order " + input.OrderID + ": shipped"},
  			}, nil
  		},
  	)

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

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		// Liste jedes Tool auf, das der Agent aufrufen kann. Der Worker beantwortet kein anderes Tool.
  		ToolsFunc: func(env *agenttoolset.AgentToolContext) []anthropic.BetaTool {
  			return []anthropic.BetaTool{agenttoolset.BetaBashTool(env), getOrderStatus}
  		},
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }
  ```

  <CodeGroupItem language="Java">
    Das Java-SDK hat keinen `EnvironmentWorker`. Um Aufrufe benutzerdefinierter Tools aus deinem eigenen Code zu beantworten, sende jedes Ergebnis über den Event-Stream der Sitzung, wie unter [Ein Custom-Tool-Ergebnis zurückgeben](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#return-a-custom-tool-result) beschrieben.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    Das PHP-SDK hat keinen `EnvironmentWorker`. Um Aufrufe benutzerdefinierter Tools aus deinem eigenen Code zu beantworten, sende jedes Ergebnis über den Event-Stream der Sitzung, wie unter [Ein Custom-Tool-Ergebnis zurückgeben](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#return-a-custom-tool-result) beschrieben.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Das Ruby-SDK hat keinen `EnvironmentWorker`. Um Aufrufe benutzerdefinierter Tools aus deinem eigenen Code zu beantworten, sende jedes Ergebnis über den Event-Stream der Sitzung, wie unter [Ein Custom-Tool-Ergebnis zurückgeben](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#return-a-custom-tool-result) beschrieben.
  </CodeGroupItem>
</CodeGroup>

### Work-Poller

| Option | Beschreibung |
| ----- | ----- |
| `drain` (go: `Drain`) | Ob das Polling beendet wird, sobald die Warteschlange leer ist, anstatt auf neue Arbeit zu warten. |
| `block_ms` (typescript: `blockMs`; go: `BlockMs`) | Wie lange jede Abfrage auf eintreffende Arbeit wartet, bevor sie zurückkehrt, in Millisekunden. Muss zwischen 1 und 999 liegen. Der Helfer fragt automatisch erneut ab. Übergib `null` (python: `None`; go: `param.Null[int64]()`) für eine nicht blockierende Prüfung. Standardmäßig ein Long-Poll von 999 ms. |
| `reclaim_older_than_ms` (typescript: `reclaimOlderThanMs`; go: `ReclaimOlderThanMs`) | Beansprucht Arbeitselemente erneut, die beansprucht, aber innerhalb dieser Anzahl von Millisekunden nie bestätigt wurden. |
| `auto_stop` (typescript: `autoStop`; go: `AutoStop`) | Ob der Poller für jedes Arbeitselement ein Stoppsignal sendet, sobald dein Schleifenrumpf damit fertig ist. Standardmäßig `true` (python: `True`). Setze es in den zwei Fällen, die auf diese Tabelle folgen, auf `false` (python: `False`; go: `param.NewOpt(false)`). |

Setze `auto_stop` (typescript: `autoStop`; go: `AutoStop`) in zwei Fällen auf `false` (python: `False`; go: `param.NewOpt(false)`):

1. Deine Schleife ruft `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) auf, das den Stopp selbst sendet.
2. Deine Schleife startet eine Sandbox für das Element und macht weiter. Der Worker in dieser Sandbox muss den Stopp senden, wenn die Arbeit der Sitzung endet, wie es `ant beta:worker run` und `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) tun.

Ein vollständiges Beispiel findest du unter [Sandboxes aus dem SDK-Poller starten](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-from-the-sdk-poller).

### Sitzungs-Tool-Runner

`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`) nimmt eine Tool-Liste als `tools` (go: `Tools`) entgegen. Um diese Liste zu erstellen, richte `AgentToolContext` selbst ein und rufe `beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`) auf:

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    `AgentToolContext` ist ein Helfer in den Python-, TypeScript- und Go-SDKs. cURL hat keine Entsprechung. Verwende eines dieser SDKs.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    `AgentToolContext` ist ein Helfer in den Python-, TypeScript- und Go-SDKs. Die `ant`-CLI hat keine Entsprechung. Verwende eines dieser SDKs.
  </CodeGroupItem>

  ```python Python
  from anthropic.lib.tools.agent_toolset import (
      AgentToolContext,
      beta_agent_toolset_20260401,
  )

  async with AgentToolContext(
      workdir="/workspace", client=client, session_id=work.data.id
  ) as env:
      # Skills heruntergeladen nach /workspace/skills/<name>/
      tools = beta_agent_toolset_20260401(env)
  ```

  ```typescript TypeScript
  import {
    setupSkills,
    betaAgentToolset20260401
  } from "@anthropic-ai/sdk/tools/agent-toolset/node";

  const ctx = { workdir: "/workspace", client, sessionId: work.data.id };
  await setupSkills(ctx);
  const tools = betaAgentToolset20260401(ctx);
  ```

  <CodeGroupItem language="C#">
    Das C#-SDK hat keinen `AgentToolContext`.
  </CodeGroupItem>

  ```go Go
  env := &agenttoolset.AgentToolContext{Workdir: "/workspace"}
  if err := env.SetupSkills(ctx, client, work.Data.ID); err != nil {
  	panic(err)
  }
  // Skills heruntergeladen nach /workspace/skills/<name>/
  tools := agenttoolset.BetaAgentToolset20260401(env)
  ```

  <CodeGroupItem language="Java">
    Das Java-SDK hat keinen `AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    Das PHP-SDK hat keinen `AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    Das Ruby-SDK hat keinen `AgentToolContext`.
  </CodeGroupItem>
</CodeGroup>

### AgentToolContext und das Agent-Toolset

`AgentToolContext` ist der Ausführungskontext für Tool-Aufrufe. Er definiert das Arbeitsverzeichnis und die Pfadrichtlinie und kann die Skills der Sitzung herunterladen.

| Option | Beschreibung |
| ----- | ----- |
| `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`) | Verzeichnisse, zusätzlich zum Arbeitsverzeichnis, die die Datei-Tools (`read`, `write`, `edit`, `glob`, `grep`) erreichen können. |
| `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`) | Verzeichnisse, unterhalb derer `write` und `edit` Pfade ablehnen. |

`EnvironmentWorker` fügt die Memory-Store-Verzeichnisse der Sitzung selbst zu `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`) hinzu und die Verzeichnisse von Stores, die mit `access: "read_only"` angehängt sind, zu `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`).

Die Eingrenzung ist nur eine Schutzvorkehrung für die Datei-Tools, keine Sandbox. Sie schränkt `bash` nicht ein.

`beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`) nimmt einen `AgentToolContext` entgegen und gibt die Standard-Tool-Implementierungen (`bash`, `read`, `write`, `edit`, `glob`, `grep`) zurück.
