---
title: Configuración del entorno en la nube
url: https://platform.claude.com/docs/es/managed-agents/environments
description: Personaliza los sandboxes en la nube para tus sesiones.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Los entornos definen la configuración del sandbox donde se ejecuta tu agente. Creas un entorno una vez y luego haces referencia a su ID cada vez que inicias una sesión. Varias sesiones pueden compartir el mismo entorno, pero cada sesión obtiene su propio sandbox aislado (un contenedor Linux nuevo).

Esta página cubre los entornos `type: cloud`. Para ejecutar sandboxes en tu propia infraestructura, consulta [Sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes). Para elegir entre ambos, consulta [Elegir un entorno para el agente](https://platform.claude.com/docs/es/managed-agents/choosing-an-environment).

## Crear un entorno

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS 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" \
    --data '{
      "name": "python-dev",
      "config": {
        "type": "cloud",
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <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: python-dev
      config:
        type: cloud
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>

    [`ant apply`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/apply) crea el entorno a partir de `environment.yaml`, imprime su ID y lo registra en `claude-lock.json`. Haz commit de `claude-lock.json` para que el siguiente `ant apply` actualice este entorno en lugar de intentar crearlo de nuevo.
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="python-dev",
      config={
          "type": "cloud",
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )

  print(f"Environment ID: {environment.id}")
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "python-dev",
    config: {
      type: "cloud",
      networking: { type: "limited", allow_package_managers: true }
    }
  });

  console.log(`Environment ID: ${environment.id}`);
  ```

  ```csharp C#
  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "python-dev",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });

  Console.WriteLine($"Environment ID: {environment.ID}");
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "python-dev",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("Environment ID: %s\n", environment.ID)
  ```

  ```java Java
  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("python-dev")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  IO.println("Environment ID: " + environment.id());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'python-dev',
      config: [
          'type' => 'cloud',
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  echo "Environment ID: {$environment->id}\n";
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "python-dev",
    config: {
      type: "cloud",
      networking: {type: "limited", allow_package_managers: true}
    }
  )

  puts "Environment ID: #{environment.id}"
  ```
</CodeGroup>

Usa un `name` (csharp, go: `Name`) único y descriptivo para poder distinguir los entornos. Este ejemplo usa [redes](https://platform.claude.com/docs/es/managed-agents/environments#networking) `limited` con los gestores de paquetes permitidos, de modo que el sandbox pueda acceder a los registros de paquetes y a los servicios de alojamiento de código. Para permitirle acceder a otros hosts, agrégalos a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

## Usar el entorno en una sesión

Pasa el ID del entorno como una cadena al [crear una sesión](https://platform.claude.com/docs/es/managed-agents/sessions).

<CodeGroup>
  ```bash cURL
  curl -fsS 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" \
    --data '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  ant beta:sessions create --agent "$AGENT_ID" --environment-id "$ENVIRONMENT_ID"
  ```

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

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

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

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  ```

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

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

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id
  )
  ```
</CodeGroup>

## Opciones de configuración

### Paquetes

El campo `packages` (csharp, go: `Packages`) preinstala paquetes en el sandbox antes de que se inicie el agente. Los paquetes se instalan mediante sus respectivos gestores de paquetes y se almacenan en caché entre las sesiones que comparten el mismo entorno. Cuando se especifican varios gestores de paquetes, se ejecutan en orden alfabético (apt, cargo, gem, go, npm, pip). Opcionalmente, puedes fijar versiones específicas. Los paquetes sin versión fijada instalan la versión más reciente. Si el entorno usa [redes](https://platform.claude.com/docs/es/managed-agents/environments#networking) `limited`, establece también `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) de `networking` (csharp, go: `Networking`) en `true`; de lo contrario, la solicitud se rechaza con un error 400.

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS 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" \
    --data '{
      "name": "data-analysis",
      "config": {
        "type": "cloud",
        "packages": {
          "pip": ["pandas", "numpy", "scikit-learn"],
          "npm": ["express"]
        },
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <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: data-analysis
      config:
        type: cloud
        packages:
          pip:
            - pandas
            - numpy
            - scikit-learn
          npm:
            - express
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="data-analysis",
      config={
          "type": "cloud",
          "packages": {
              "pip": ["pandas", "numpy", "scikit-learn"],
              "npm": ["express"],
          },
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: ["pandas", "numpy", "scikit-learn"],
        npm: ["express"]
      },
      networking: { type: "limited", allow_package_managers: true }
    }
  });
  ```

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

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "data-analysis",
      Config = new BetaCloudConfigParams
      {
          Packages = new()
          {
              Pip = ["pandas", "numpy", "scikit-learn"],
              Npm = ["express"],
          },
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "data-analysis",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Packages: anthropic.BetaPackagesParams{
  				Pip: []string{"pandas", "numpy", "scikit-learn"},
  				Npm: []string{"express"},
  			},
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = environment
  ```

  ```java Java
  import com.anthropic.models.beta.environments.*;
  import java.util.List;

  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("data-analysis")
      .config(BetaCloudConfigParams.builder()
          .packages(BetaPackagesParams.builder()
              .pip(List.of("pandas", "numpy", "scikit-learn"))
              .npm(List.of("express"))
              .build())
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'data-analysis',
      config: [
          'type' => 'cloud',
          'packages' => [
              'pip' => ['pandas', 'numpy', 'scikit-learn'],
              'npm' => ['express'],
          ],
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: %w[pandas numpy scikit-learn],
        npm: %w[express]
      },
      networking: {type: "limited", allow_package_managers: true}
    }
  )
  ```
</CodeGroup>

Gestores de paquetes compatibles:

| Campo   | Gestor de paquetes             | Ejemplo                                     |
| ------- | ------------------------------ | ------------------------------------------- |
| `apt`   | Paquetes del sistema (apt-get) | `"graphviz"`                                |
| `cargo` | Rust (cargo)                   | `"hyperfine@1.18.0"`                        |
| `gem`   | Ruby (gem)                     | `"rails:7.1.0"`                             |
| `go`    | Módulos de Go                  | `"golang.org/x/tools/cmd/goimports@latest"` |
| `npm`   | Node.js (npm)                  | `"express@4.18.0"`                          |
| `pip`   | Python (pip)                   | `"sqlalchemy==2.0.30"`                      |

### Redes

El campo `networking` (csharp, go: `Networking`) controla el acceso de red saliente del sandbox.

Con redes `limited`, `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) también se aplica a las herramientas `web_search` y `web_fetch`, que se ejecutan en los servidores de Anthropic. Una llamada a `web_fetch` para una URL en un host que no coincide con `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) devuelve un resultado de error al agente. `web_search` omite los resultados de hosts que no coinciden con `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) y `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) no agregan hosts para estas herramientas. Cuando `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) no incluye ningún host, ninguna llamada a `web_fetch` o `web_search` devuelve una página o un resultado de búsqueda. Un host que agregues a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) para estas herramientas también queda abierto para el sandbox. Las redes `unrestricted` y los entornos autoalojados no limitan estas herramientas. Para restringirlas aún más, establece `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) o `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) en la entrada de la herramienta dentro del conjunto de herramientas del agente. Consulta [Restringir los dominios de búsqueda web y obtención web](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions).

| Modo           | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `limited`      | Restringe el acceso de red del sandbox a los hosts en `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Establece `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) y `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) en `true` para permitir acceso adicional. Usa este modo a menos que el agente deba acceder a sitios que no puedes enumerar de antemano. |
| `unrestricted` | Acceso de red saliente completo, excepto por una lista general de bloqueo de seguridad. Antes de usarlo, lee [Riesgos de las redes sin restricciones](https://platform.claude.com/docs/es/managed-agents/environments#risks-of-unrestricted-networking).                                                                                                                                                                                                                                                    |

<Note>
  Establece `networking` (csharp, go: `Networking`) explícitamente en las solicitudes a la API; una solicitud de creación que lo omite obtiene `unrestricted`. El formulario de la Claude Console para crear un entorno comienza con **Limited** seleccionado y nada más permitido.
</Note>

El siguiente ejemplo crea un entorno con redes en modo `limited`:

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS 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": "api-access",
      "config": {
        "type": "cloud",
        "networking": {
          "type": "limited",
          "allowed_hosts": ["api.example.com"],
          "allow_mcp_servers": true,
          "allow_package_managers": true
        }
      }
    }'
  ```

  <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: api-access
      config:
        type: cloud
        networking:
          type: limited
          allowed_hosts:
            - api.example.com
          allow_mcp_servers: true
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="api-access",
      config={
          "type": "cloud",
          "networking": {
              "type": "limited",
              "allowed_hosts": ["api.example.com"],
              "allow_mcp_servers": True,
              "allow_package_managers": True,
          },
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: ["api.example.com"],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  });
  ```

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

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "api-access",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowedHosts = ["api.example.com"],
              AllowMcpServers = true,
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "api-access",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowedHosts:         []string{"api.example.com"},
  					AllowMCPServers:      anthropic.Bool(true),
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = environment
  ```

  ```java Java
  import com.anthropic.models.beta.environments.*;
  import java.util.List;

  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("api-access")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowedHosts(List.of("api.example.com"))
              .allowMcpServers(true)
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'api-access',
      config: [
          'type' => 'cloud',
          'networking' => [
              'type' => 'limited',
              'allowed_hosts' => ['api.example.com'],
              'allow_mcp_servers' => true,
              'allow_package_managers' => true,
          ],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: %w[api.example.com],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  )
  ```
</CodeGroup>

<Info>
  Usa redes `limited` con una lista explícita de `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Sigue el principio de mínimo privilegio otorgando solo el acceso de red mínimo que tu agente requiere, y audita regularmente tus dominios permitidos.
</Info>

Con redes `limited` y sin ningún otro campo establecido, no se permite ningún host. Los archivos, los almacenes de memoria y los repositorios de GitHub que adjuntes a la sesión siguen disponibles. Cuando se rechaza una solicitud del sandbox en el puerto 80 o 443 porque su host no está permitido, la respuesta es un 403 que indica el host bloqueado.

Al usar redes `limited`:

* `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) especifica los dominios a los que puede acceder el sandbox. Especifica nombres de host simples o patrones con comodines (como `*.example.com`). No incluyas un esquema de URL, un puerto ni una ruta. Un nombre de host simple coincide exactamente con ese host: `example.com` no coincide con `www.example.com`. `*.example.com` coincide con todos los subdominios de `example.com`, pero no con `example.com` en sí.
* `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) permite el acceso saliente a los endpoints de servidores MCP configurados en el agente, además de los enumerados en el arreglo `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). El valor predeterminado es `false`. Mientras sea `false`, la creación de la sesión falla con un error 400 si el agente declara un servidor MCP cuyo host no está en `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Lo mismo se aplica a [un agente al que pueda delegar](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration). Para solucionarlo, agrega el host a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) o establece `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) en `true`.
* `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) permite el acceso saliente a un conjunto de registros de paquetes públicos y servicios de alojamiento de código, además de los enumerados en el arreglo `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Consulta [Hosts de gestores de paquetes](https://platform.claude.com/docs/es/managed-agents/environments#package-manager-hosts) para ver la lista. El valor predeterminado es `false`. Establécelo en `true` siempre que el entorno especifique `packages` (csharp, go: `Packages`); de lo contrario, la solicitud se rechaza con un error 400, incluso si los hosts de los registros están enumerados en `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

#### Hosts de gestores de paquetes

Cuando `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) es `true`, el sandbox puede acceder a los siguientes hosts además de los que están en `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Anthropic mantiene esta lista y puede cambiarla.

| Ecosistema            | Hosts                                                                                                                                                                                      |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Alojamiento de código | `github.com`, `api.github.com`, `codeload.github.com`, `raw.githubusercontent.com`, `objects.githubusercontent.com`, `release-assets.githubusercontent.com`, `gitlab.com`, `bitbucket.org` |
| Node.js               | `registry.npmjs.org`, `registry.yarnpkg.com`, `nodejs.org`                                                                                                                                 |
| Python                | `pypi.org`, `files.pythonhosted.org`                                                                                                                                                       |
| Rust                  | `crates.io`, `index.crates.io`, `static.crates.io`, `static.rust-lang.org`                                                                                                                 |
| Go                    | `proxy.golang.org`, `sum.golang.org`                                                                                                                                                       |
| Java                  | `repo1.maven.org`, `repo.maven.apache.org`, `services.gradle.org`, `plugins.gradle.org`, `plugins-artifacts.gradle.org`                                                                    |
| Ruby                  | `rubygems.org`, `index.rubygems.org`                                                                                                                                                       |
| PHP                   | `packagist.org`, `repo.packagist.org`                                                                                                                                                      |
| Ubuntu (apt)          | `archive.ubuntu.com`, `security.ubuntu.com`, `ppa.launchpad.net`                                                                                                                           |
| Contenedores          | `registry-1.docker.io`, `auth.docker.io`, `production.cloudflare.docker.com`, `download.docker.com`, `ghcr.io`                                                                             |

<Warning>
  El acceso de red se otorga por host, no por operación. El sandbox puede enviar cualquier solicitud a un host permitido, incluidas cargas como `git push` y la publicación de paquetes, con cualquier credencial que proporcione el comando. Si el agente procesa entradas no confiables (archivos del repositorio, contenido web obtenido o salidas de herramientas de terceros), una "prompt injection" (inyección de prompts) exitosa podría usar un host permitido para copiar archivos fuera del sandbox. Para reducir este riesgo, establece la [política de permisos](https://platform.claude.com/docs/es/managed-agents/permission-policies) de la herramienta `bash` en `always_ask` o `auto`. Si el entorno no especifica `packages` (csharp, go: `Packages`), puedes en su lugar dejar `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) en `false` y enumerar solo los hosts que tu agente necesita en `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).
</Warning>

#### Riesgos de las redes sin restricciones

Con redes `unrestricted`, el código del sandbox puede enviar solicitudes a cualquier host de internet, excepto a los hosts de una lista general de bloqueo de seguridad. Antes de elegir este modo, considera lo que el agente puede hacer con ese acceso:

* **El agente puede cambiar cosas en sitios externos, no solo leerlas:** La herramienta `bash` puede enviar cualquier solicitud. El agente puede publicar datos, enviar formularios, llamar a APIs y ejecutar scripts que cambian datos en sitios externos. Incluso una solicitud que solo obtiene una URL puede cambiar datos en algunos sitios.
* **Nada pausa estas solicitudes de forma predeterminada:** La [política de permisos](https://platform.claude.com/docs/es/managed-agents/permission-policies) predeterminada del conjunto de herramientas del agente es `always_allow`, por lo que los comandos de `bash` se ejecutan sin aprobación.
* **Cualquier cosa en el sandbox puede salir de él:** Esto incluye archivos, salidas de herramientas y cualquier credencial o secreto que pongas en el sandbox.
* **El contenido obtenido puede dirigir al agente:** Las páginas web, las respuestas de API y otro contenido que lee el agente pueden contener instrucciones (inyección de prompts) que cambian lo que hace a continuación.
* **El agente actúa en tu nombre:** Sus acciones pueden infringir los términos de servicio de un sitio, o crear cuentas y registros en él.
* **El comportamiento del modelo no es un control de seguridad:** El agente puede actuar en sitios externos de formas que no pediste, incluido reintentar de otra manera después de que un sitio bloquee una solicitud. Usa la configuración de red y las políticas de permisos para limitar lo que puede hacer.
* **La lista de bloqueo de seguridad no es una lista de permitidos:** No limita a qué otros sitios accede el agente ni lo que el agente hace en ellos.

Para reducir estos riesgos, usa redes `limited` con una lista explícita de hosts. El siguiente valor de `networking` permite `api.example.com`, además de los [hosts de gestores de paquetes](https://platform.claude.com/docs/es/managed-agents/environments#package-manager-hosts) para un agente que instala paquetes:

```json
{
  "type": "limited",
  "allowed_hosts": ["api.example.com"],
  "allow_package_managers": true
}
```

Un agente que solo usa las herramientas `web_search` y `web_fetch` no necesita redes `unrestricted` si puedes enumerar los sitios que necesita. Con redes `limited`, `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) también se aplica a esas herramientas (consulta [Redes](https://platform.claude.com/docs/es/managed-agents/environments#networking)), así que enumera esos sitios en `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Enumerarlos también en `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) de `web_search` hace que busque en esos sitios. Un host que agregues a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) también queda abierto para el sandbox. Para restringir aún más las herramientas, consulta [Restringir los dominios de búsqueda web y obtención web](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions).

Usa `unrestricted` solo cuando el agente deba acceder a sitios que no puedes enumerar de antemano. En ese caso, mantén los secretos y los archivos confidenciales fuera del sandbox, y dale al agente solo las credenciales que necesita la tarea. Considera establecer la política de permisos de la herramienta `bash` en `always_ask` o `auto`, y [supervisa los eventos de la sesión](https://platform.claude.com/docs/es/managed-agents/events-and-streaming).

## Ciclo de vida del entorno

* Los entornos persisten hasta que se archivan o eliminan explícitamente.
* Cada sesión obtiene su propia instancia de sandbox, incluso cuando varias sesiones hacen referencia al mismo entorno. Las sesiones no comparten el estado del sistema de archivos.
* Los entornos no tienen versiones. Si actualizas un entorno con frecuencia, mantén tu propio registro de los cambios para poder saber qué configuración usó cada sesión.

## Administrar entornos

<CodeGroup>
  ```bash cURL
  # Listar entornos
  curl -fsS 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"

  # Recuperar un entorno específico
  curl -fsS "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Archivar un entorno (solo lectura, las sesiones existentes continúan)
  curl -fsS -X POST "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Eliminar un entorno (solo si ninguna sesión lo referencia)
  curl -fsS -X DELETE "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  # Listar entornos
  ant beta:environments list

  # Obtener un entorno específico
  ant beta:environments retrieve --environment-id "$ENVIRONMENT_ID"

  # Archivar un entorno (solo lectura, las sesiones existentes continúan)
  ant beta:environments archive --environment-id "$ENVIRONMENT_ID"

  # Eliminar un entorno (solo si ninguna sesión lo referencia)
  ant beta:environments delete --environment-id "$ENVIRONMENT_ID"
  ```

  ```python Python
  # Listar entornos
  environments = client.beta.environments.list()

  # Recuperar un entorno específico
  env = client.beta.environments.retrieve(environment.id)

  # Archivar un entorno (solo lectura, las sesiones existentes continúan)
  client.beta.environments.archive(environment.id)

  # Eliminar un entorno (solo si ninguna sesión lo referencia)
  client.beta.environments.delete(environment.id)
  ```

  ```typescript TypeScript
  // Listar entornos
  const environments = await client.beta.environments.list();

  // Recuperar un entorno específico
  const env = await client.beta.environments.retrieve(environment.id);

  // Archivar un entorno (solo lectura, las sesiones existentes continúan)
  await client.beta.environments.archive(environment.id);

  // Eliminar un entorno (solo si ninguna sesión lo referencia)
  await client.beta.environments.delete(environment.id);
  ```

  ```csharp C#
  // Listar entornos
  var environments = await client.Beta.Environments.List();

  // Recuperar un entorno específico
  var env = await client.Beta.Environments.Retrieve(environment.ID);

  // Archivar un entorno (solo lectura, las sesiones existentes continúan)
  await client.Beta.Environments.Archive(environment.ID);

  // Eliminar un entorno (solo si ninguna sesión lo referencia)
  await client.Beta.Environments.Delete(environment.ID);
  ```

  ```go Go
  // Listar entornos
  environments, err := client.Beta.Environments.List(ctx, anthropic.BetaEnvironmentListParams{})
  // ...

  // Recuperar un entorno específico
  env, err := client.Beta.Environments.Get(ctx, environment.ID, anthropic.BetaEnvironmentGetParams{})
  // ...

  // Archivar un entorno (solo lectura, las sesiones existentes continúan)
  _, err = client.Beta.Environments.Archive(ctx, environment.ID, anthropic.BetaEnvironmentArchiveParams{})
  // ...

  // Eliminar un entorno (solo si ninguna sesión lo referencia)
  _, err = client.Beta.Environments.Delete(ctx, environment.ID, anthropic.BetaEnvironmentDeleteParams{})
  ```

  ```java Java
  // Listar entornos
  var environments = client.beta().environments().list();
  // Recuperar un entorno específico
  var env = client.beta().environments().retrieve(environment.id());
  // Archivar un entorno (solo lectura, las sesiones existentes continúan)
  client.beta().environments().archive(environment.id());
  // Eliminar un entorno (solo si ninguna sesión lo referencia)
  client.beta().environments().delete(environment.id());
  ```

  ```php PHP
  // Listar entornos
  $environments = $client->beta->environments->list();
  // Recuperar un entorno específico
  $env = $client->beta->environments->retrieve($environment->id);
  // Archivar un entorno (solo lectura, las sesiones existentes continúan)
  $client->beta->environments->archive($environment->id);
  // Eliminar un entorno (solo si ninguna sesión lo referencia)
  $client->beta->environments->delete($environment->id);
  ```

  ```ruby Ruby
  # Listar entornos
  environments = client.beta.environments.list

  # Recuperar un entorno específico
  env = client.beta.environments.retrieve(environment.id)

  # Archivar un entorno (solo lectura, las sesiones existentes continúan)
  client.beta.environments.archive(environment.id)

  # Eliminar un entorno (solo si ninguna sesión lo referencia)
  client.beta.environments.delete(environment.id)
  ```
</CodeGroup>

## Entornos de ejecución preinstalados

Los sandboxes en la nube incluyen de forma predeterminada entornos de ejecución de lenguajes comunes, bases de datos y herramientas de línea de comandos. Consulta la [Referencia de sandboxes en la nube](https://platform.claude.com/docs/es/managed-agents/cloud-sandboxes-reference) para ver la lista completa.

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Referencia de sandboxes en la nube" icon="book" href="https://platform.claude.com/docs/es/managed-agents/cloud-sandboxes-reference">
    Paquetes preinstalados, bases de datos y utilidades disponibles en los sandboxes en la nube.
  </Card>

  <Card title="Iniciar una sesión" icon="play" href="https://platform.claude.com/docs/es/managed-agents/sessions">
    Crea una sesión para ejecutar tu agente y comenzar a ejecutar tareas.
  </Card>
</CardGroup>