---
title: Implementar workers autoalojados
url: https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers
description: Elige cómo los workers de sandbox autoalojados reclaman trabajo y dónde se ejecutan las sesiones, y luego ejecuta un worker siempre activo o activa workers desde webhooks.
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
---

El [inicio rápido de sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#quickstart) ejecuta un worker de la CLI `ant` que sondea continuamente y ejecuta cada sesión en un solo proceso. Esta página te ayuda a elegir un patrón de implementación y luego cubre los workers siempre activos y los activados por webhook.

## Elige un patrón de implementación

Al implementar workers, debes tomar dos decisiones: cómo el worker reclama trabajo y dónde se ejecuta cada sesión.

**Cómo el worker reclama trabajo:**

* **Siempre activo:** Un proceso de larga duración sondea la cola continuamente. El proceso solo realiza solicitudes HTTPS salientes, así que no expones ningún endpoint a Anthropic.
* **Activado por webhook:** Un controlador se activa con `session.status_run_started` y comienza a sondear. Esto evita un sondeador inactivo, pero requiere un endpoint de [webhook](https://platform.claude.com/docs/es/managed-agents/webhooks) al que Anthropic pueda acceder.

**Dónde se ejecuta cada sesión:**

* **En proceso:** El worker que reclama una sesión también ejecuta sus llamadas a herramientas, en un único directorio de trabajo compartido.
* **Sandbox por sesión:** Un sondeador lanza un sandbox nuevo para cada sesión reclamada. Elige esta opción para un aislamiento más fuerte: un sistema de archivos nuevo, límites de recursos o controles de red por sesión. Consulta [Ejecutar un sandbox por sesión](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-per-session), que también cubre el chart de Helm para Kubernetes.

Los workers de la CLI y del SDK admiten diferentes combinaciones:

| Capacidad | CLI `ant` | SDK (Python, TypeScript, Go) |
| ----- | ----- | ----- |
| Sondeo siempre activo | Sí | Sí |
| Activado por webhook | No | Sí |
| [Sandbox por sesión](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-per-session) | Sí | Sí |
| [Almacenes de memoria](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory) | Sí, con la configuración de sincronización predeterminada | Sí, con sincronización configurable |
| [Herramientas personalizadas](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-custom-tools) | No | Sí |

Consulta la [referencia de workers autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference) para ver cada flag de la CLI y cada opción del SDK.

Para tener más control, llama directamente a los [endpoints de trabajo del entorno](https://platform.claude.com/docs/es/api/beta/environments/work) e implementa tu propio worker. Tu worker hace entonces lo que hacen los workers del SDK. Entre otras cosas, confirma cada elemento de trabajo, envía “heartbeats” (latidos) y descarga las skills del agente. Ejecuta solo las llamadas a herramientas que permite la [política de permisos](https://platform.claude.com/docs/es/managed-agents/permission-policies#see-how-each-call-was-evaluated) de la sesión. Devuelve cada resultado como un evento `user.tool_result` o `user.custom_tool_result`. Al final, detiene el elemento. Usa como referencia el código fuente del worker en el [SDK de Python](https://github.com/anthropics/anthropic-sdk-python/tree/main/src/anthropic/lib/environments), el [SDK de TypeScript](https://github.com/anthropics/anthropic-sdk-typescript/tree/main/src/lib/environments) o el [SDK de Go](https://github.com/anthropics/anthropic-sdk-go/tree/main/lib/environments).

## Ejecuta un worker siempre activo

Estos ejemplos usan `/workspace` como directorio de trabajo del worker. El directorio debe existir antes de que se inicie el worker. En un host nuevo, créalo y dale al usuario del worker acceso de escritura, como en el paso “Inicia el worker” de [Ejecuta tu primera sesión](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#run-your-first-session).

En macOS, `mkdir` no puede crear `/workspace`, porque el volumen raíz es de solo lectura. Crea `~/workspace` en su lugar, como muestra ese paso. En lugar de `/workspace`, usa la ruta completa que imprime `echo ~/workspace`, porque el SDK no expande `~`.

Inicia un worker que sondee la cola continuamente. Se autentica con la [clave del entorno](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#run-your-first-session) del inicio rápido:

<CodeGroup exclude="shell:cURL, csharp, java, php, ruby">
  <CodeGroupItem language="cURL">
    Un worker es un proceso de larga duración, no una única solicitud HTTP. En su lugar, ejecuta el worker de la CLI `ant`: `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())
          # Cancelar la tarea, en lugar de matar el proceso, permite que el worker detenga su
          # elemento de trabajo en curso y suba los archivos de memoria modificados antes de salir.
          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();
  // Abortar con cualquiera de las señales permite al worker subir los archivos de memoria modificados y eliminar sus
  // directorios de almacenamiento antes de que el proceso termine.
  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#">
    El SDK de C# no tiene `EnvironmentWorker`. En su lugar, ejecuta el worker de la CLI `ant`: `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">
    El SDK de Java no tiene `EnvironmentWorker`. En su lugar, ejecuta el worker de la CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="PHP">
    El SDK de PHP no tiene `EnvironmentWorker`. En su lugar, ejecuta el worker de la CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>

  <CodeGroupItem language="Ruby">
    El SDK de Ruby no tiene `EnvironmentWorker`. En su lugar, ejecuta el worker de la CLI `ant`: `ant beta:worker poll --workdir /workspace`.
  </CodeGroupItem>
</CodeGroup>

## Activa workers desde webhooks

<Steps>
  <Step title="Suscríbete a los webhooks de sesión">
    En la [Claude Console](https://platform.claude.com/settings/workspaces/default/webhooks), define un endpoint de webhook que escuche eventos `session.status_run_started`. Consulta [Suscribirse a webhooks](https://platform.claude.com/docs/es/managed-agents/webhooks) para más detalles.
  </Step>

  <Step title="Exporta la clave de firma del webhook">
    Junto con el ID y la clave del entorno de [Ejecuta tu primera sesión](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#run-your-first-session), exporta la clave de firma del webhook en el host de tu controlador. El controlador la usa para verificar las cargas útiles entrantes.

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

  <Step title="Implementa el controlador del webhook">
    Inicia el worker cuando se dispare `session.status_run_started`. El controlador vacía la cola y entrega cada elemento de trabajo reclamado a `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) (en los SDK de Python, TypeScript y Go). Ese método descarga las skills, ejecuta las llamadas a herramientas, publica los resultados y regresa.

    Los ejemplos usan `/workspace` como directorio de trabajo. Antes de iniciar el controlador, crea ese directorio en el host del controlador. Asegúrate de que el usuario del controlador pueda escribir en él, como en el paso “Inicia el worker” de [Ejecuta tu primera sesión](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#run-your-first-session).

    <CodeGroup exclude="shell, csharp, java, php, ruby">
      <CodeGroupItem language="cURL">
        Este controlador requiere más lógica que un solo comando de shell. Usa el SDK de Python, TypeScript o Go para ejecutarlo.
      </CodeGroupItem>

      <CodeGroupItem language="CLI">
        Este controlador requiere más lógica que un solo comando de shell. Usa el SDK de Python, TypeScript o Go para ejecutarlo.
      </CodeGroupItem>

      <CodeGroupItem>
        Para verificar las firmas de webhook, instala el extra de webhooks: `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,
        )
        # Cancelado por shutdown() para que un elemento de trabajo en curso pueda subir los archivos de memoria modificados y
        # eliminar sus directorios de almacén antes de que el proceso termine.
        inflight: set[asyncio.Task[None]] = set()


        # Espera esto desde el hook de apagado del host, como un apagado de lifespan de ASGI (el código tras
        # `yield` en un lifespan de FastAPI), que uvicorn ejecuta al recibir SIGTERM. uvicorn deja terminar las solicitudes abiertas
        # antes de ejecutar ese hook, así que configura --timeout-graceful-shutdown para limitar la espera.
        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:
                # Protegido: una entrega descartada o con tiempo de espera agotado no debe cancelar el elemento; shutdown() sí lo hace.
                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,
                    # El secreto por sesión es lo que permite al worker montar los almacenes de memoria de la sesión.
                    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
      });
      // Llama a shutdown.abort() desde el manejador SIGTERM/SIGINT del host, junto con cerrar el servidor,
      // luego espera las llamadas handle() en curso antes de salir: el abort permite que un elemento de trabajo en ejecución
      // suba primero los archivos de memoria modificados y elimine sus directorios de almacén.
      export const shutdown = new AbortController();

      export async function handle(req: Request): Promise<Response> {
        // Nunca confirmes una entrega cuyo trabajo no se ejecutará aquí; un 503 hace que el remitente reintente.
        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,
            // El secreto por sesión es lo que permite al worker montar los almacenes de memoria de la sesión.
            workSecret: work.secret ?? undefined,
            signal: shutdown.signal
          });
        }
        // El poller y handleItem retornan silenciosamente al abortar, así que un drenaje interrumpido termina aquí.
        if (shutdown.signal.aborted) {
          return Response.json({ status: "shutting down" }, { status: 503 });
        }
        return Response.json({ status: "ok" });
      }
      ```

      <CodeGroupItem language="C#">
        El SDK de C# no tiene `EnvironmentWorker`. Para gestionar elementos de trabajo desde tu propio código, implementa tu propio worker, como se describe en [Elige un patrón de implementación](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </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",
      	})
      	// Se cancela con SIGINT o SIGTERM (configurado en main) para que un elemento de trabajo en curso pueda
      	// subir los archivos de memoria modificados y eliminar sus directorios de almacén antes de salir.
      	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
      	}

      	// El SDK de Go no ofrece la utilidad RunOne: vacía los elementos pendientes
      	// con WorkPoller y ejecuta cada uno con HandleItem.
      	// Desvincula de r.Context(): la sesión puede durar más que el tiempo de espera de entrega del webhook.
      	// El contexto de apagado de todo el proceso aún finaliza el elemento limpiamente con SIGTERM.
      	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,
      			// El secreto por sesión es lo que permite al worker montar los almacenes de memoria de la sesión.
      			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)
      		}
      	}()
      	// Ante una señal, deja de aceptar entregas y retorna solo después de que los controladores
      	// en curso, y por tanto la limpieza de memoria de sus elementos de trabajo, hayan terminado.
      	<-ctx.Done()
      	if err := server.Shutdown(context.Background()); err != nil {
      		slog.Error("http shutdown", "err", err)
      	}
      }
      ```

      <CodeGroupItem language="Java">
        El SDK de Java no tiene `EnvironmentWorker`. Para gestionar elementos de trabajo desde tu propio código, implementa tu propio worker, como se describe en [Elige un patrón de implementación](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>

      <CodeGroupItem language="PHP">
        El SDK de PHP no tiene `EnvironmentWorker`. Para gestionar elementos de trabajo desde tu propio código, implementa tu propio worker, como se describe en [Elige un patrón de implementación](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>

      <CodeGroupItem language="Ruby">
        El SDK de Ruby no tiene `EnvironmentWorker`. Para gestionar elementos de trabajo desde tu propio código, implementa tu propio worker, como se describe en [Elige un patrón de implementación](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers#choose-a-deployment-pattern).
      </CodeGroupItem>
    </CodeGroup>

    En los SDK de Python, TypeScript y Go, `handle_item()` (typescript: `handleItem()`; go: `HandleItem()`) necesita el secreto del elemento de trabajo para montar almacenes de memoria. Un worker que sondea con `run()` (go: `Run()`) ya tiene el secreto. Este controlador reclama cada elemento por sí mismo, así que pasa el secreto en el argumento `work_secret` (typescript: `workSecret`; go: `WorkSecret`). 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).
  </Step>
</Steps>

Este controlador ejecuta cada elemento reclamado en un solo proceso, y ejecuta al mismo tiempo elementos de entregas de webhook distintas. Esas sesiones comparten un único sistema de archivos, incluidos `/workspace` y `/mnt/memory`. Si tus sesiones adjuntan el mismo almacén de memoria, consulta [Aislar sesiones que comparten un almacén](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory#isolate-sessions-that-share-a-store).

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Ejecutar un sandbox por sesión" icon="cube" href="https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-per-session">
    Lanza sandboxes con el chart de Helm en Kubernetes, un script de lanzamiento o el sondeador del SDK.
  </Card>

  <Card title="Supervisar y solucionar problemas de workers autoalojados" icon="lightning" href="https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-operations">
    Lee la profundidad de la cola, detén sesiones y workers de forma limpia y corrige fallos comunes.
  </Card>

  <Card title="Modelo de seguridad" icon="lock" href="https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-security">
    Modelo de responsabilidad compartida para entornos de sandbox autoalojados.
  </Card>
</CardGroup>

## Disponibilidad

Estado de Workers autoalojados predefinidos: en beta en todos los modelos.

### Compatibilidad con la API

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

* Disponibilidad: Disponible

| Estado | Plataformas en la nube |
| ----- | ----- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws) |

### Encabezados beta requeridos

[Descripción general de los encabezados beta](https://platform.claude.com/docs/es/api/beta-headers)

Los encabezados beta te permiten acceder a funciones experimentales y nuevas capacidades de los modelos antes de que formen parte de la API estándar.

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

### Manejo de datos

[Descripción general del manejo de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#feature-eligibility)

| Elemento | Retención de datos cero | HIPAA |
| ----- | ----- | ----- |
| Estado | No elegible | No elegible |
| Detalles | No es elegible para ZDR, excepto Managed Agents autoalojado. Las sesiones son recursos con estado; las transcripciones persisten hasta que las eliminas. [Más información](https://platform.claude.com/docs/es/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | No es elegible para HIPAA. Se aplica a todas las subfunciones de Managed Agents. |

Endpoints aplicables:

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