---
title: Referencia de workers autoalojados
url: https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference
description: "Referencia para workers de sandbox autoalojados: flags de la CLI ant, variables de entorno, requisitos del host, rutas del sistema de archivos y opciones de los helpers del SDK."
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: No es elegible para ZDR, excepto Managed Agents autoalojado. Las sesiones son recursos con estado; las transcripciones persisten hasta que las eliminas.
  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
---

Esta página documenta los workers predefinidos que atienden un entorno `self_hosted`. Para guías orientadas a tareas, comienza con [Sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes) y [Implementar workers autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers).

## Comandos y flags de la CLI

| Comando | Descripción |
| ----- | ----- |
| `ant beta:worker poll` | Reclama elementos de trabajo de la cola del entorno y ejecuta cada sesión en el mismo proceso. Con `--on-work`, llama a tu script para cada elemento de trabajo en su lugar. |
| `ant beta:worker run` | Gestiona una sesión reclamada y termina. Úsalo como punto de entrada de un sandbox por sesión. |

| Flag | Descripción |
| ----- | ----- |
| `--environment-id` | El entorno que se consulta en busca de trabajo. También se lee de `ANTHROPIC_ENVIRONMENT_ID`. |
| `--environment-key` | Autentica el worker con este entorno. También se lee de `ANTHROPIC_ENVIRONMENT_KEY`. |
| `--workdir` | Directorio donde el worker descarga las skills y donde las herramientas leen y escriben archivos. El valor predeterminado es `.` (el directorio actual). El directorio debe existir antes de que se inicie el worker. |
| `--on-work` | Script al que se llama para cada elemento de trabajo reclamado en lugar de ejecutar las herramientas en el mismo proceso. Recibe los detalles de la sesión como variables de entorno y el elemento de trabajo como JSON en la entrada estándar. |
| `--max-idle` | Cuánto tiempo espera el worker mientras una sesión está inactiva antes de que `ant beta:worker run` termine o `ant beta:worker poll` pase al siguiente elemento de trabajo. El tiempo de inactividad con un [motivo de detención `requires_action`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) no cuenta. El valor predeterminado es `60s`. Establécelo en `0` para desactivar el límite de tiempo de espera. Con un script de `--on-work`, `ant beta:worker poll` ignora este flag. En su lugar, pásalo al comando `ant beta:worker run` que tu script inicia. |
| `--log-format` | Formato de salida de los logs. Usa `json` para la ingesta de logs estructurados. El valor predeterminado es `text`. |

## Variables de entorno

| Variable | Descripción | Establecida por |
| ----- | ----- | ----- |
| `ANTHROPIC_ENVIRONMENT_ID` | El entorno cuya cola atiende el worker. | Tú, en el host del worker. El sondeador la pasa al script de `--on-work`. |
| `ANTHROPIC_ENVIRONMENT_KEY` | Autentica el worker ante su cola. | Tú, en el host del worker. El sondeador la pasa al script de `--on-work`. |
| `ANTHROPIC_SESSION_ID` | La sesión que representa un elemento de trabajo reclamado. | El sondeador, para el script de `--on-work`. |
| `ANTHROPIC_WORK_ID` | El elemento de trabajo reclamado. | El sondeador, para el script de `--on-work`. |
| `ANTHROPIC_WORK_SECRET` | El secreto del elemento de trabajo para su sesión. | Tú. El sondeador no la establece. Consulta [Reenvía el secreto del elemento de trabajo](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-per-session#forward-the-work-items-secret). |
| `ANTHROPIC_BASE_URL` | Sobrescribe el endpoint predeterminado de la API. Opcional. | Tú, en el host del worker. |
| `ANTHROPIC_WEBHOOK_SIGNING_KEY` | Verifica las cargas útiles de webhooks entrantes. | Tú, en un host que gestione webhooks. |

## Requisitos del host

| Worker | Requisito |
| ----- | ----- |
| Todos los workers | Un host Linux o macOS con `/bin/bash` en esa ruta exacta. La herramienta `bash` del worker lo ejecuta directamente, sin consultar `PATH`. En macOS, se trata del Bash 3.2 del sistema. |
| SDK de TypeScript | `unzip` y `tar` en el `PATH`, y Node.js 22 o posterior. |
| SDK de Python y Go | Ningún binario adicional. Estos SDK usan sus bibliotecas estándar para la extracción de archivos comprimidos. |

Los [almacenes de memoria](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory#requirements) añaden sus propios requisitos.

En macOS, el volumen raíz es de solo lectura, por lo que `mkdir` no puede crear `/workspace`. Establece como directorio de trabajo del worker uno en el que puedas escribir, como un directorio `workspace` en tu directorio personal. Para usar almacenes de memoria en macOS, primero [prepara el host macOS](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory#prepare-a-macos-host).

## Sistema de archivos del sandbox

| Ruta | Contenido |
| ----- | ----- |
| `/workspace` | El directorio de trabajo de los ejemplos de las páginas de sandboxes autoalojados. No es el valor predeterminado del worker: el worker usa el directorio actual a menos que establezcas `--workdir` o `workdir` (go: `Workdir`). Los sandboxes en la nube de Anthropic guardan las skills y los repositorios en `/workspace`. Si usas un directorio de trabajo diferente, actualiza la indicación del sistema de tu agente para que Claude pueda localizar los archivos de las skills. |
| `<workdir>/skills/<name>/` | Las skills descargadas del agente. |
| `/mnt/memory/<store>/` | Una copia local de cada almacén de memoria adjunto, un directorio por almacén. La API devuelve la ruta completa de cada directorio en el campo `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) del recurso de almacén de memoria de la sesión (por ejemplo, `/mnt/memory/user-preferences/`). |

El worker crea los directorios de los almacenes de memoria cuando reclama una sesión. Los elimina cuando termina con esa sesión o cuando [detienes el worker de forma ordenada](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-operations#stop-workers-gracefully). Eso elimina solo las copias locales, y las memorias permanecen en el almacén.

Las skills pueden incluir ejecutables que el agente puede ejecutar directamente. Los workers de la CLI y del SDK conservan los permisos de ejecución registrados en el paquete de la skill al extraerlo. Si descargas las skills por tu cuenta, establece tú mismo sus permisos de ejecución.

### Cuándo termina el worker con una sesión

El worker termina con una sesión en cualquiera de estos casos:

* La sesión termina.
* [Detienes el elemento de trabajo de la sesión](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-operations#stop-a-session-gracefully).
* La sesión permanece inactiva durante el límite de inactividad del worker. La sesión en sí permanece abierta. Cuando luego le envías un nuevo evento, como un mensaje de usuario, el mismo worker u otro la reclama. Ese worker vuelve a descargar los almacenes.

El límite de inactividad es de 60 segundos de forma predeterminada. Para cambiarlo, usa [`--max-idle`](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference#cli-commands-and-flags) para el worker de la CLI `ant` o [`max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`)](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference#environment-worker) para `EnvironmentWorker`. El [chart de Helm `cma-sandboxes`](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-per-session#run-sandboxes-on-kubernetes), en cambio, inicia sus workers con un límite de 30 minutos. Para cambiar ese límite, cambia la opción `sandbox.idleTimeout` del chart.

### Entregables finales

Los sandboxes autoalojados no tienen un directorio `/mnt/session/outputs`. En los sandboxes en la nube de Anthropic, la indicación del sistema de la sesión instruye al agente para que copie allí los entregables finales. En los entornos autoalojados, la indicación del sistema omite esa instrucción. Los entregables finales quedan donde el agente los escriba, normalmente dentro del directorio de trabajo, y el worker no los sube.

Para reunir los entregables finales en un solo lugar, proporciona la ruta completa de un directorio en la indicación del sistema de tu agente. Elige un directorio en el que puedan escribir las herramientas de archivos del worker:

* **Dentro del directorio de trabajo:** Por ejemplo, `/workspace/outputs` si el directorio de trabajo es `/workspace`.
* **En cualquier otro lugar, solo con un worker del SDK:** Añade el directorio a `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`). Consulta [AgentToolContext y el conjunto de herramientas del agente](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference#agent-tool-context-and-the-agent-toolset).

## Helpers del SDK

Los SDK de Python, TypeScript y Go proporcionan tres helpers con distintos niveles de control:

| Helper | Qué hace | Úsalo cuando |
| ----- | ----- | ----- |
| [`EnvironmentWorker`](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference#environment-worker) | Gestiona el sondeo, la configuración y las ejecuciones de herramientas de principio a fin. | En la mayoría de los casos. |
| [`work.poller()` (typescript: `new WorkPoller()`; go: `environments.NewWorkPoller()`)](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference#work-poller) | Sondea la cola de trabajo y te entrega cada sesión reclamada. | Tú determinas cómo gestionar cada sesión, por ejemplo, lanzando un sandbox en lugar de ejecutar las herramientas en el mismo proceso. |
| [`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`)](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference#session-tool-runner) | Ejecuta las llamadas a herramientas de una sola sesión, dados el ID de la sesión y una lista de herramientas. | Ya reclamaste el trabajo y solo necesitas ejecutar las herramientas. |

### EnvironmentWorker

| Método | Descripción |
| ----- | ----- |
| `run()` (go: `Run()`) | Se ejecuta indefinidamente, tomando las sesiones a medida que llegan. |
| `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) | Gestiona un elemento de trabajo ya reclamado por un sondeador. El sondeador puede ser `ant beta:worker poll --on-work` o tu propio código. El método retorna cuando el worker termina con la sesión del elemento. Puedes pasar `work_id` (typescript: `workId`; go: `WorkID`), `session_id` (typescript: `sessionId`; go: `SessionID`), `environment_id` (typescript: `environmentId`; go: `EnvironmentID`) y `work_secret` (typescript: `workSecret`; go: `WorkSecret`). Para cada uno que omitas, el método lee la [variable `ANTHROPIC_*`](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference#environment-variables) correspondiente. |

| Opción | Descripción |
| ----- | ----- |
| `tools` (go: `ToolsFunc`) | Una fábrica que recibe el `AgentToolContext` de la sesión y devuelve la lista de herramientas. El valor predeterminado es el conjunto de herramientas estándar del agente. |
| `max_idle` (typescript: `maxIdleMs`; go: `MaxIdle`) | Cuánto tiempo espera el worker mientras una sesión está inactiva antes de terminar con la sesión. El tiempo de inactividad con un [motivo de detención `requires_action`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#respond-when-the-session-goes-idle) no cuenta. El valor predeterminado es de 60 segundos. Para esperar 5 minutos, establécelo en `300` (typescript: `300_000`; go: `anthropic.Ptr(5 * time.Minute)`). Para desactivar el límite, establécelo en `None` (typescript: `0`; go: `new(time.Duration)`). |
| `memory_sync_interval` (typescript: `memorySyncIntervalMs`; go: `MemorySyncInterval`) | El tiempo mínimo entre dos sincronizaciones de los almacenes de memoria adjuntos mientras se ejecuta la sesión. El worker comprueba el intervalo después de cada llamada a una herramienta que se ejecuta en tu sandbox, no con un temporizador. El valor predeterminado es de 15 segundos. Consulta [Intervalo de sincronización](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory#sync-interval). |
| `memory_sync_deletions` (typescript: `memorySyncDeletions`; go: `MemorySyncDeletions`) | Si los archivos que el agente elimina localmente también se eliminan del almacén. Consulta [Eliminaciones](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory#deletions). |

`EnvironmentWorker` gestiona automáticamente el `AgentToolContext` y el conjunto de herramientas. Pasa una fábrica `tools` (go: `ToolsFunc`) para personalizar la lista de herramientas:

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Un worker es un proceso de larga duración, no una única solicitud HTTP. Para personalizar la lista de herramientas, usa `EnvironmentWorker` en el SDK de Python, TypeScript o Go.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    El worker de la CLI `ant` siempre usa el conjunto de herramientas estándar del agente. Para personalizar la lista de herramientas, usa `EnvironmentWorker` en el SDK de Python, TypeScript o Go.
  </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,
              # Enumera todas las herramientas que el agente puede llamar. El worker no responde a ninguna otra herramienta.
              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,
    // Enumera todas las herramientas que el agente puede llamar. El worker no responde a ninguna otra herramienta.
    tools: (ctx) => [betaBashTool(ctx), getOrderStatus]
  }).run();
  ```

  <CodeGroupItem language="C#">
    El SDK de C# no tiene `EnvironmentWorker`. Para responder a las llamadas a herramientas personalizadas desde tu propio código, envía cada resultado en el flujo de eventos de la sesión, como en [Devolver un resultado de herramienta personalizada](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </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,
  		// Enumera todas las herramientas que el agente puede llamar. El worker no responde a ninguna otra herramienta.
  		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">
    El SDK de Java no tiene `EnvironmentWorker`. Para responder a las llamadas a herramientas personalizadas desde tu propio código, envía cada resultado en el flujo de eventos de la sesión, como en [Devolver un resultado de herramienta personalizada](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    El SDK de PHP no tiene `EnvironmentWorker`. Para responder a las llamadas a herramientas personalizadas desde tu propio código, envía cada resultado en el flujo de eventos de la sesión, como en [Devolver un resultado de herramienta personalizada](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    El SDK de Ruby no tiene `EnvironmentWorker`. Para responder a las llamadas a herramientas personalizadas desde tu propio código, envía cada resultado en el flujo de eventos de la sesión, como en [Devolver un resultado de herramienta personalizada](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#return-a-custom-tool-result).
  </CodeGroupItem>
</CodeGroup>

### Sondeador de trabajo

| Opción | Descripción |
| ----- | ----- |
| `drain` (go: `Drain`) | Si se debe dejar de sondear una vez que la cola está vacía en lugar de esperar trabajo nuevo. |
| `block_ms` (typescript: `blockMs`; go: `BlockMs`) | Cuánto tiempo espera cada sondeo a que llegue trabajo antes de retornar, en milisegundos. Debe estar entre 1 y 999. El helper vuelve a sondear automáticamente. Pasa `null` (python: `None`; go: `param.Null[int64]()`) para una comprobación no bloqueante. El valor predeterminado es un sondeo largo de 999 ms. |
| `reclaim_older_than_ms` (typescript: `reclaimOlderThanMs`; go: `ReclaimOlderThanMs`) | Vuelve a reclamar los elementos de trabajo que se reclamaron pero nunca se confirmaron dentro de esta cantidad de milisegundos. |
| `auto_stop` (typescript: `autoStop`; go: `AutoStop`) | Si el sondeador publica una señal de detención para cada elemento de trabajo una vez que el cuerpo de tu bucle termina con él. El valor predeterminado es `true` (python: `True`). Establécelo en `false` (python: `False`; go: `param.NewOpt(false)`) en los dos casos que siguen a esta tabla. |

Establece `auto_stop` (typescript: `autoStop`; go: `AutoStop`) en `false` (python: `False`; go: `param.NewOpt(false)`) en dos casos:

1. Tu bucle llama a `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`), que publica la detención por sí mismo.
2. Tu bucle lanza un sandbox para el elemento y continúa. El worker de ese sandbox debe publicar la detención cuando termine el trabajo de la sesión, como hacen `ant beta:worker run` y `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`).

Para ver un ejemplo completo, consulta [Lanza sandboxes desde el sondeador del SDK](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-per-session#launch-sandboxes-from-the-sdk-poller).

### Ejecutor de herramientas de sesión

`client.beta.sessions.events.tool_runner()` (typescript: `client.beta.sessions.events.toolRunner()`; go: `client.Beta.Sessions.Events.NewToolRunner()`) recibe una lista de herramientas como `tools` (go: `Tools`). Para construir esa lista, configura tú mismo `AgentToolContext` y llama a `beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`):

<CodeGroup exclude="shell, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    `AgentToolContext` es un helper de los SDK de Python, TypeScript y Go. cURL no tiene equivalente. Usa uno de esos SDK.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    `AgentToolContext` es un helper de los SDK de Python, TypeScript y Go. La CLI `ant` no tiene equivalente. Usa uno de esos SDK.
  </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 descargadas en /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#">
    El SDK de C# no tiene `AgentToolContext`.
  </CodeGroupItem>

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

  <CodeGroupItem language="Java">
    El SDK de Java no tiene `AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    El SDK de PHP no tiene `AgentToolContext`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    El SDK de Ruby no tiene `AgentToolContext`.
  </CodeGroupItem>
</CodeGroup>

### AgentToolContext y el conjunto de herramientas del agente

`AgentToolContext` es el contexto de ejecución para las llamadas a herramientas. Define el directorio de trabajo y la política de rutas, y puede descargar las skills de la sesión.

| Opción | Descripción |
| ----- | ----- |
| `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`) | Directorios, además del directorio de trabajo, a los que pueden acceder las herramientas de archivos (`read`, `write`, `edit`, `glob`, `grep`). |
| `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`) | Directorios bajo los cuales `write` y `edit` rechazan rutas. |

`EnvironmentWorker` añade por sí mismo los directorios de los almacenes de memoria de la sesión a `allowed_roots` (typescript: `allowedRoots`; go: `AllowedRoots`), y los directorios de los almacenes adjuntos con `access: "read_only"` a `read_only_roots` (typescript: `readOnlyRoots`; go: `ReadOnlyRoots`).

El confinamiento es una barrera de protección solo para las herramientas de archivos, no un sandbox. No restringe `bash`.

`beta_agent_toolset_20260401(env)` (typescript: `betaAgentToolset20260401(ctx)`; go: `agenttoolset.BetaAgentToolset20260401(env)`) recibe un `AgentToolContext` y devuelve las implementaciones de herramientas estándar (`bash`, `read`, `write`, `edit`, `glob`, `grep`).
