---
title: Sandboxes autoalojados
url: https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes
description: Ejecuta sesiones de Claude Managed Agents en sandboxes autoalojados, manteniendo la ejecución de herramientas, los archivos y el tráfico de salida de red en tu propia infraestructura.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Los "self-hosted sandboxes" (sandboxes autoalojados) trasladan la ejecución de herramientas del agente desde los sandboxes en la nube administrados por Anthropic a una infraestructura que tú controlas, mientras Anthropic sigue ejecutando el agente. Para saber qué significa esto y decidir si se ajusta a tu agente, consulta [Elegir un entorno para el agente](https://platform.claude.com/docs/es/managed-agents/choosing-an-environment).

## Cómo funciona

Un entorno `self_hosted` actúa como una cola de trabajo. Ejecutas un **environment worker** (worker de entorno), un proceso en tu propia infraestructura que atiende esa cola:

1. Creas una [sesión](https://platform.claude.com/docs/es/managed-agents/sessions) dirigida al entorno. Anthropic pone la sesión en cola como un elemento de trabajo.
2. Tu worker reclama el elemento de trabajo y descarga las [skills](https://platform.claude.com/docs/es/managed-agents/skills) del agente y los [almacenes de memoria](https://platform.claude.com/docs/es/managed-agents/memory) de la sesión.
3. Claude se ejecuta del lado de Anthropic y solicita llamadas a herramientas. Tu worker ejecuta cada llamada localmente y envía el resultado de vuelta.

Las entradas y salidas de las herramientas siguen fluyendo hacia el plano de control de Anthropic, para que el modelo pueda ver los resultados y determinar qué hacer a continuación. Anthropic almacena las skills y los almacenes de memoria. Tu sandbox conserva una copia para la sesión. Consulta [Modelo de seguridad](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-security) para conocer el límite completo del flujo de datos.

Los sandboxes autoalojados admiten todos los modelos de Claude disponibles en Managed Agents. El modelo se configura en el agente, no en el entorno.

La CLI `ant` y los SDK de Python, TypeScript y Go incluyen workers prediseñados. Proveedores de sandboxes como Cloudflare, Daytona y Modal también publican sus propias [guías de plataforma](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#platform-guides).

## Inicio rápido

Este inicio rápido ejecuta un worker siempre activo con la CLI `ant`, le envía una sesión y confirma que las llamadas a herramientas del agente se ejecutaron en tu host.

### Requisitos previos

* **Un agente:** Si no tienes uno, completa primero [Comienza con Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/quickstart) y anota el ID del agente.
* **Un host Linux:** El host necesita `/bin/bash` en esa ruta exacta. El worker solo necesita HTTPS saliente.
* **Una clave de API de Claude:** La usas desde tu propia máquina para crear sesiones y leer estadísticas de la cola. Mantenla fuera del host del worker, donde las llamadas a herramientas del agente podrían leerla.
* **La CLI `ant` o el SDK en tu propia máquina:** Los pasos de estadísticas y de sesión de este inicio rápido se ejecutan allí, no en el host del worker. Instala la CLI de la misma forma que lo hace el [paso de instalación](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes#run-your-first-session) para el worker, o instala el [SDK](https://platform.claude.com/docs/es/cli-sdks-libraries/overview).

<Note>
  En [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws), el worker se autentica con AWS IAM (SigV4) o con una [clave de API generada en la consola de AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#api-key-authentication), no con una clave de entorno. Adjunta la política administrada [`AnthropicSelfHostedEnvironmentAccess`](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#managed-policies) a la entidad principal de IAM con la que se ejecuta tu worker. Las claves de entorno generadas en Claude Console no funcionan con el endpoint de Claude Platform on AWS.
</Note>

### Ejecuta tu primera sesión

<Steps>
  <Step title="Crea un entorno autoalojado">
    En la Claude Console, ve a la página [Environments](https://platform.claude.com/environments) (`platform.claude.com/environments`), haz clic en **Create environment** y, en **Hosting**, selecciona **Self-hosted**.

    O a través de la API:

    <CodeGroup defaultLanguage="CLI">
      ```bash cURL
      curl -sS --fail-with-body https://api.anthropic.com/v1/environments \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01" \
        -H "content-type: application/json" \
        -d '{
          "name": "self-hosted",
          "config": {"type": "self_hosted"}
        }'
      ```

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

        <File filename="environment.yaml">
          ```yaml
          # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
          name: self-hosted
          config:
            type: self_hosted
          ```
        </File>
      </CodeGroupItem>

      ```python Python
      client = anthropic.Anthropic()

      environment = client.beta.environments.create(
          name="self-hosted", config={"type": "self_hosted"}
      )
      print(environment.id)
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const environment = await client.beta.environments.create({
        name: "self-hosted",
        config: { type: "self_hosted" }
      });
      console.log(environment.id);
      ```

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

      var client = new AnthropicClient();

      var environment = await client.Beta.Environments.Create(
          new EnvironmentCreateParams
          {
              Name = "self-hosted",
              Config = new BetaSelfHostedConfigParams(),
          }
      );
      Console.WriteLine(environment.ID);
      ```

      ```go Go
      client := anthropic.NewClient()

      environment, err := client.Beta.Environments.New(context.Background(), anthropic.BetaEnvironmentNewParams{
      	Name: "self-hosted",
      	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
      		OfSelfHosted: &anthropic.BetaSelfHostedConfigParams{},
      	},
      })
      if err != nil {
      	panic(err)
      }
      fmt.Println(environment.ID)
      ```

      ```java Java
      import com.anthropic.models.beta.environments.BetaSelfHostedConfigParams;
      import com.anthropic.models.beta.environments.EnvironmentCreateParams;

      void main() {
          var client = AnthropicOkHttpClient.fromEnv();

          var environment = client.beta().environments().create(
              EnvironmentCreateParams.builder()
                  .name("self-hosted")
                  .config(BetaSelfHostedConfigParams.builder().build())
                  .build()
          );
          IO.println(environment.id());
      }
      ```

      ```php PHP
      $client = new \Anthropic\Client();

      $environment = $client->beta->environments->create(
          name: 'self-hosted',
          config: ['type' => 'self_hosted'],
      );
      echo $environment->id, PHP_EOL;
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      environment = client.beta.environments.create(
        name: "self-hosted",
        config: {type: :self_hosted}
      )
      puts environment.id
      ```
    </CodeGroup>
  </Step>

  <Step title="Genera una clave de entorno">
    En la Console, abre el entorno y haz clic en **Generate environment key**. La clave de entorno autentica al worker ante su cola. Solo puedes generarla en la Console, incluso para un entorno que creaste a través de la API.

    Exporta el ID del entorno y la clave en el host del worker:

    ```bash
    export ANTHROPIC_ENVIRONMENT_KEY="sk-ant-oat01-..."
    export ANTHROPIC_ENVIRONMENT_ID="env_..."
    ```
  </Step>

  <Step title="Instala la CLI ant">
    Ejecuta esto en el host del worker.

    <Tabs>
      <Tab title="curl (Linux/WSL)">
        Para entornos Linux, descarga directamente el binario de la versión.

        ```bash
        VERSION=1.42.0
        OS=$(uname -s | tr '[:upper:]' '[:lower:]')
        case $(uname -m) in
          x86_64) ARCH=amd64 ;;
          aarch64) ARCH=arm64 ;;
        esac
        curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
          | sudo tar -xz -C /usr/local/bin ant
        ```

        Puedes encontrar todas las versiones en la [página de versiones de GitHub](https://github.com/anthropics/anthropic-cli/releases).
      </Tab>

      <Tab title="Homebrew (macOS)">
        ```bash
        brew install anthropics/tap/ant
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Inicia el worker">
    Crea el directorio de trabajo y luego inicia el worker. `--workdir` usa de forma predeterminada el directorio actual, así que pasa `/workspace` para que coincida con el valor predeterminado del sistema.

    ```bash
    sudo mkdir -p /workspace && sudo chown "$USER" /workspace
    ant beta:worker poll --workdir /workspace
    ```

    El worker lee las dos variables que exportaste y sondea hasta que lo detengas.
  </Step>

  <Step title="Verifica que el worker esté conectado">
    En tu propia máquina, establece `ANTHROPIC_API_KEY` con tu clave de API de Claude (no la clave de entorno) y `ANTHROPIC_ENVIRONMENT_ID` (python, ruby: `environment_id`; typescript, java, csharp: `environmentId`; go: `environmentID`; php: `$environmentId`) con el ID del entorno. Confirma que `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) sea al menos 1:

    <CodeGroup>
      ```bash cURL
      curl -sS --fail-with-body "https://api.anthropic.com/v1/environments/$ANTHROPIC_ENVIRONMENT_ID/work/stats" \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01"
      ```

      ```bash CLI
      ant beta:environments:work stats --environment-id "$ANTHROPIC_ENVIRONMENT_ID"
      ```

      ```python Python
      client = anthropic.Anthropic()

      stats = client.beta.environments.work.stats(environment_id)
      print(f"workers_polling={stats.workers_polling}")
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const stats = await client.beta.environments.work.stats(environmentId);

      console.log(`workers_polling=${stats.workers_polling}`);
      ```

      ```csharp C#
      var client = new AnthropicClient();

      var stats = await client.Beta.Environments.Work.Stats(environmentId);

      Console.WriteLine($"workers_polling={stats.WorkersPolling}");
      ```

      ```go Go
      client := anthropic.NewClient()

      stats, err := client.Beta.Environments.Work.Stats(
      	context.Background(),
      	environmentID,
      	anthropic.BetaEnvironmentWorkStatsParams{},
      )
      if err != nil {
      	panic(err)
      }

      fmt.Printf("workers_polling=%d\n", stats.WorkersPolling)
      ```

      ```java Java
      var client = AnthropicOkHttpClient.fromEnv();

      var stats = client.beta().environments().work().stats(environmentId);

      IO.println("workers_polling=" + stats.workersPolling().orElse(null));
      ```

      ```php PHP
      $client = new Client();

      $stats = $client->beta->environments->work->stats($environmentId);

      printf("workers_polling=%d\n", $stats->workersPolling);
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      stats = client.beta.environments.work.stats(environment_id)

      puts "workers_polling=#{stats.workers_polling}"
      ```
    </CodeGroup>

    Si `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) se mantiene en 0, consulta [Solución de problemas](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-operations#troubleshooting).
  </Step>

  <Step title="Inicia una sesión">
    Establece `AGENT_ID` (python, ruby: `agent_id`; typescript, java, csharp: `agentId`; go: `agentID`; php: `$agentId`) con el ID de tu agente. Crea una sesión dirigida al entorno y luego envíale una tarea:

    <CodeGroup>
      ```bash cURL
      SESSION_ID=$(curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01" \
        -H "content-type: application/json" \
        -d '{
          "agent": "'"$AGENT_ID"'",
          "environment_id": "'"$ANTHROPIC_ENVIRONMENT_ID"'"
        }' | jq -er '.id'
      )

      curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01" \
        -H "content-type: application/json" \
        -d '{
          "events": [
            {
              "type": "user.message",
              "content": [
                {
                  "type": "text",
                  "text": "Write the output of \"uname -a\" to hello.txt in your working directory."
                }
              ]
            }
          ]
        }'
      ```

      ```bash CLI
      SESSION_ID=$(ant beta:sessions create \
        --agent "$AGENT_ID" \
        --environment-id "$ANTHROPIC_ENVIRONMENT_ID" \
        --transform id --raw-output)

      ant beta:sessions:events send --session-id "$SESSION_ID" <<'YAML'
      events:
        - type: user.message
          content:
            - type: text
              text: Write the output of "uname -a" to hello.txt in your working directory.
      YAML
      ```

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

      client.beta.sessions.events.send(
          session.id,
          events=[
              {
                  "type": "user.message",
                  "content": [
                      {
                          "type": "text",
                          "text": 'Write the output of "uname -a" to hello.txt in your working directory.',
                      },
                  ],
              },
          ],
      )
      ```

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

      await client.beta.sessions.events.send(session.id, {
        events: [
          {
            type: "user.message",
            content: [
              {
                type: "text",
                text: 'Write the output of "uname -a" to hello.txt in your working directory.'
              }
            ]
          }
        ]
      });
      ```

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

      await client.Beta.Sessions.Events.Send(session.ID, new()
      {
          Events =
          [
              new BetaManagedAgentsUserMessageEventParams
              {
                  Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
                  Content =
                  [
                      new BetaManagedAgentsTextBlock
                      {
                          Type = BetaManagedAgentsTextBlockType.Text,
                          Text = "Write the output of \"uname -a\" to hello.txt in your working directory.",
                      },
                  ],
              },
          ],
      });
      ```

      ```go Go
      session, err := client.Beta.Sessions.New(context.Background(), anthropic.BetaSessionNewParams{
      	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agentID)},
      	EnvironmentID: environmentID,
      })
      if err != nil {
      	panic(err)
      }

      _, err = client.Beta.Sessions.Events.Send(context.Background(), session.ID, anthropic.BetaSessionEventSendParams{
      	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
      		OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
      			Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
      			Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
      				OfText: &anthropic.BetaManagedAgentsTextBlockParam{
      					Type: anthropic.BetaManagedAgentsTextBlockTypeText,
      					Text: "Write the output of \"uname -a\" to hello.txt in your working directory.",
      				},
      			}},
      		},
      	}},
      })
      if err != nil {
      	panic(err)
      }
      ```

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

      client.beta().sessions().events().send(
          session.id(),
          EventSendParams.builder()
              .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
                  .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
                  .addTextContent("Write the output of \"uname -a\" to hello.txt in your working directory.")
                  .build())
              .build());
      ```

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

      $client->beta->sessions->events->send(
          $session->id,
          events: [
              [
                  'type' => 'user.message',
                  'content' => [['type' => 'text', 'text' => 'Write the output of "uname -a" to hello.txt in your working directory.']],
              ],
          ],
      );
      ```

      ```ruby Ruby
      session = client.beta.sessions.create(
        agent: agent_id,
        environment_id: environment_id
      )

      client.beta.sessions.events.send_(
        session.id,
        events: [
          {
            type: :"user.message",
            content: [{type: :text, text: 'Write the output of "uname -a" to hello.txt in your working directory.'}]
          }
        ]
      )
      ```
    </CodeGroup>

    La sesión espera en la cola del entorno hasta que un worker la reclama. Si no hay ningún worker conectado, la sesión permanece en cola en lugar de fallar.
  </Step>

  <Step title="Confirma que las herramientas se ejecutaron en tu host">
    En el host del worker, lee el archivo que escribió el agente:

    ```bash
    cat /workspace/hello.txt
    ```

    El archivo describe el kernel de tu propio host, por lo que las llamadas a herramientas del agente se ejecutaron allí. Para seguir el trabajo del agente a medida que ocurre, consulta [Flujo de eventos de la sesión](https://platform.claude.com/docs/es/managed-agents/events-and-streaming).
  </Step>
</Steps>

## Recursos de la sesión

Los sandboxes autoalojados solo admiten recursos `memory_store`. Una sesión en un entorno autoalojado que incluya un recurso `file` o `github_repository` se rechaza con un error 400:

```text wrap
Environment env_... is a self-hosted environment. `resources` are not supported with self-hosted environments.
```

Los [despliegues](https://platform.claude.com/docs/es/managed-agents/scheduled-deployments) dirigidos a un entorno autoalojado siguen la misma regla. Para proporcionar a una sesión sus propios archivos de entrada, consulta [Preparar archivos para una sesión](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers#stage-files-for-a-session).

## Sandboxes autoalojados y túneles MCP

El autoalojamiento controla *dónde se ejecuta el código del agente*. Los [túneles MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-tunnels/overview) controlan *cómo Anthropic llega a los servidores MCP de tu red*. Ambos son independientes:

* Una sesión en los sandboxes en la nube de Anthropic puede acceder a servidores MCP privados a través de un túnel. Por ejemplo, un servidor MCP privado podría estar delante de una base de datos o de una API interna detrás de tu firewall.
* Una sesión autoalojada puede usar servidores MCP tunelizados o públicos.

Usa ambos cuando quieras que la ejecución y el acceso a herramientas permanezcan dentro de tu límite. Para omitir el túnel, [envuelve el servidor MCP como herramientas personalizadas](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-custom-tools#wrap-an-mcp-server-as-custom-tools) que tu worker atienda.

## Guías de plataforma

Estas páginas describen cómo crear un worker en cualquier plataforma de sandboxing. También hay guías específicas de plataforma disponibles:

* [AWS Lambda MicroVMs](https://docs.aws.amazon.com/lambda/latest/dg/microvms-integrations-claude-managed-agents.html)
* [Blaxel](https://docs.blaxel.ai/Tutorials/Claude-Managed-Agents)
* [Cloudflare](https://developers.cloudflare.com/sandbox/claude-managed-agents/)
* [Daytona](https://www.daytona.io/docs/en/guides/claude/claude-managed-agents)
* [E2B](https://e2b.dev/docs/agents/claude-managed-agents)
* [Fly.io](https://docs.sprites.dev/integrations/claude-managed-agents/)
* [GKE Agent Sandbox](https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/tree/main/ai-ml/anthropic-agent-sandbox)
* [Modal](https://github.com/modal-labs/claude-managed-agents-modal-sandbox)
* [Namespace](https://namespace.so/docs/integrations/claude)
* [Superserve](https://docs.superserve.ai/integrations/managed-agents/claude-managed-agents)
* [Vercel](https://vercel.com/kb/guide/run-claude-managed-agent-tools-with-vercel-sandbox)

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Desplegar workers" icon="play" href="https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-workers">
    Ejecuta el worker del SDK, activa workers desde webhooks o proporciona a cada sesión su propio sandbox.
  </Card>

  <Card title="Almacenes de memoria" icon="brain" href="https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory">
    Prepara el host, configura la sincronización y gestiona los almacenes de solo lectura y los conflictos.
  </Card>

  <Card title="Herramientas personalizadas y servidores MCP" icon="tool" href="https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-custom-tools">
    Atiende tus propias herramientas desde el worker, incluidas herramientas de un servidor MCP dentro de tu red.
  </Card>

  <Card title="Monitorear y solucionar problemas" 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="Referencia del worker" icon="book" href="https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-reference">
    Flags de la CLI, variables de entorno, rutas del sistema de archivos y opciones de los helpers del SDK.
  </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 sandboxes autoalojados.
  </Card>
</CardGroup>