---
title: Configuração do ambiente em nuvem
url: https://platform.claude.com/docs/pt-BR/managed-agents/environments
description: Personalize sandboxes em nuvem para suas sessões.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Os ambientes definem a configuração do sandbox onde seu agente é executado. Você cria um ambiente uma vez e depois referencia seu ID cada vez que inicia uma sessão. Várias sessões podem compartilhar o mesmo ambiente, mas cada sessão recebe seu próprio sandbox isolado (um contêiner Linux novo).

Esta página aborda ambientes `type: cloud`. Para executar sandboxes em sua própria infraestrutura, consulte [Sandboxes auto-hospedados](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes). Para escolher entre os dois, consulte [Escolhendo um ambiente de agente](https://platform.claude.com/docs/pt-BR/managed-agents/choosing-an-environment).

## Criar um ambiente

<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/pt-BR/cli-sdks-libraries/cli/apply) cria o ambiente a partir de `environment.yaml`, imprime seu ID e o registra em `claude-lock.json`. Faça commit de `claude-lock.json` para que o próximo `ant apply` atualize este ambiente em vez de tentar criá-lo novamente.
  </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>

Use um `name` (csharp, go: `Name`) único e descritivo para que você possa distinguir os ambientes. Este exemplo usa [rede](https://platform.claude.com/docs/pt-BR/managed-agents/environments#networking) `limited` com gerenciadores de pacotes permitidos, para que o sandbox possa acessar os registros de pacotes e os hosts de código. Para permitir que ele acesse outros hosts, adicione-os a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

## Usar o ambiente em uma sessão

Passe o ID do ambiente como uma string ao [criar uma sessão](https://platform.claude.com/docs/pt-BR/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>

## Opções de configuração

### Pacotes

O campo `packages` (csharp, go: `Packages`) pré-instala pacotes no sandbox antes de o agente iniciar. Os pacotes são instalados por seus respectivos gerenciadores de pacotes e armazenados em cache entre sessões que compartilham o mesmo ambiente. Quando vários gerenciadores de pacotes são especificados, eles são executados em ordem alfabética (apt, cargo, gem, go, npm, pip). Opcionalmente, você pode fixar versões específicas. Pacotes sem versão fixada instalam a versão mais recente. Se o ambiente usar [rede](https://platform.claude.com/docs/pt-BR/managed-agents/environments#networking) `limited`, defina também `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) em `networking` (csharp, go: `Networking`) como `true`; caso contrário, a requisição será rejeitada com um erro 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>

Gerenciadores de pacotes suportados:

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

### Rede

O campo `networking` (csharp, go: `Networking`) controla o acesso de rede de saída do sandbox.

Com a rede `limited`, `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) também se aplica às ferramentas `web_search` e `web_fetch`, que são executadas nos servidores da Anthropic. Uma chamada `web_fetch` para uma URL em um host que não corresponde a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) retorna um resultado de erro ao agente. `web_search` omite resultados de hosts que não correspondem a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) e `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) não adicionam hosts para essas ferramentas. Quando `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) não lista nenhum host, nenhuma chamada `web_fetch` ou `web_search` retorna uma página ou um resultado de pesquisa. Um host que você adiciona a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) para essas ferramentas também fica aberto ao sandbox. A rede `unrestricted` e os ambientes auto-hospedados não limitam essas ferramentas. Para restringi-las ainda mais, defina `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) ou `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) na entrada da ferramenta no conjunto de ferramentas do agente. Consulte [Restringir domínios de pesquisa na web e busca na web](https://platform.claude.com/docs/pt-BR/managed-agents/tools-web-restrictions).

| Modo           | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `limited`      | Restringe o acesso de rede do sandbox aos hosts em `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Defina `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) e `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) como `true` para permitir acesso adicional. Use este modo, a menos que o agente precise acessar sites que você não pode listar com antecedência. |
| `unrestricted` | Acesso de rede de saída completo, exceto por uma lista de bloqueio de segurança geral. Antes de usá-lo, leia [Riscos da rede irrestrita](https://platform.claude.com/docs/pt-BR/managed-agents/environments#risks-of-unrestricted-networking).                                                                                                                                                                                                                                                                 |

<Note>
  Defina `networking` (csharp, go: `Networking`) explicitamente nas requisições de API; uma requisição de criação que o omite recebe `unrestricted`. O formulário do Claude Console para criar um ambiente começa com **Limited** selecionado e nada mais permitido.
</Note>

O exemplo a seguir cria um ambiente com rede `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>
  Use a rede `limited` com uma lista explícita de `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Siga o princípio do menor privilégio, concedendo apenas o acesso de rede mínimo de que seu agente precisa, e audite regularmente seus domínios permitidos.
</Info>

Com a rede `limited` e nenhum outro campo definido, nenhum host é permitido. Arquivos, memory stores (armazenamentos de memória) e repositórios do GitHub que você anexa à sessão permanecem disponíveis. Quando uma requisição do sandbox na porta 80 ou 443 é recusada porque seu host não é permitido, a resposta é um 403 que nomeia o host bloqueado.

Ao usar a rede `limited`:

* `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) especifica os domínios que o sandbox pode acessar. Especifique nomes de host simples ou padrões curinga (como `*.example.com`). Não inclua um esquema de URL, porta ou caminho. Um nome de host simples corresponde exatamente a esse host: `example.com` não corresponde a `www.example.com`. `*.example.com` corresponde a todos os subdomínios de `example.com`, mas não ao próprio `example.com`.
* `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) permite acesso de saída aos endpoints de servidores MCP configurados no agente, além daqueles listados no array `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). O padrão é `false`. Enquanto for `false`, a criação da sessão falha com um erro 400 se o agente declarar um servidor MCP cujo host não esteja em `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). O mesmo se aplica a [um agente para o qual ele pode delegar](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration). Para corrigir isso, adicione o host a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) ou defina `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) como `true`.
* `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) permite acesso de saída a um conjunto de registros de pacotes públicos e hosts de código além daqueles listados no array `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Consulte [Hosts de gerenciadores de pacotes](https://platform.claude.com/docs/pt-BR/managed-agents/environments#package-manager-hosts) para ver a lista. O padrão é `false`. Defina-o como `true` sempre que o ambiente especificar `packages` (csharp, go: `Packages`); caso contrário, a requisição será rejeitada com um erro 400, mesmo que os hosts de registro estejam listados em `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

#### Hosts de gerenciadores de pacotes

Quando `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) é `true`, o sandbox pode acessar os seguintes hosts, além daqueles em `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). A Anthropic mantém esta lista e pode alterá-la.

| Ecossistema          | Hosts                                                                                                                                                                                      |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Hospedagem 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`                                                                                                                           |
| Contêineres          | `registry-1.docker.io`, `auth.docker.io`, `production.cloudflare.docker.com`, `download.docker.com`, `ghcr.io`                                                                             |

<Warning>
  O acesso à rede é concedido por host, não por operação. O sandbox pode enviar qualquer requisição a um host permitido, incluindo uploads como `git push` e publicação de pacotes, com qualquer credencial que o comando forneça. Se o agente processar entradas não confiáveis (arquivos de repositório, conteúdo da web obtido ou saída de ferramentas de terceiros), uma "prompt injection" (injeção de prompt) bem-sucedida poderia usar um host permitido para copiar arquivos para fora do sandbox. Para reduzir esse risco, defina a [política de permissão](https://platform.claude.com/docs/pt-BR/managed-agents/permission-policies) da ferramenta `bash` como `always_ask` ou `auto`. Se o ambiente não especificar `packages` (csharp, go: `Packages`), você pode, em vez disso, deixar `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) definido como `false` e listar apenas os hosts de que seu agente precisa em `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).
</Warning>

#### Riscos da rede irrestrita

Com a rede `unrestricted`, o código no sandbox pode enviar requisições a qualquer host na internet, exceto hosts em uma lista de bloqueio de segurança geral. Antes de escolher este modo, considere o que o agente pode fazer com esse acesso:

* **O agente pode alterar coisas em sites externos, não apenas lê-las:** A ferramenta `bash` pode enviar qualquer requisição. O agente pode publicar dados, enviar formulários, chamar APIs e executar scripts que alteram dados em sites externos. Mesmo uma requisição que apenas busca uma URL pode alterar dados em alguns sites.
* **Nada pausa essas requisições por padrão:** A [política de permissão](https://platform.claude.com/docs/pt-BR/managed-agents/permission-policies) padrão do conjunto de ferramentas do agente é `always_allow`, então os comandos `bash` são executados sem aprovação.
* **Qualquer coisa no sandbox pode sair dele:** Isso inclui arquivos, saídas de ferramentas e quaisquer credenciais ou segredos que você coloque no sandbox.
* **O conteúdo obtido pode direcionar o agente:** Páginas web, respostas de API e outros conteúdos que o agente lê podem conter instruções (injeção de prompt) que alteram o que ele faz em seguida.
* **O agente age em seu nome:** Suas ações podem violar os termos de serviço de um site ou criar contas e registros nele.
* **O comportamento do modelo não é um controle de segurança:** O agente pode agir em sites externos de maneiras que você não solicitou, incluindo tentar novamente de uma forma diferente depois que um site bloqueia uma requisição. Use configurações de rede e políticas de permissão para limitar o que ele pode fazer.
* **A lista de bloqueio de segurança não é uma lista de permissões:** Ela não limita quais outros sites o agente acessa, nem o que o agente faz neles.

Para reduzir esses riscos, use a rede `limited` com uma lista explícita de hosts. O seguinte valor de `networking` permite `api.example.com`, além dos [hosts de gerenciadores de pacotes](https://platform.claude.com/docs/pt-BR/managed-agents/environments#package-manager-hosts) para um agente que instala pacotes:

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

Um agente que usa apenas as ferramentas `web_search` e `web_fetch` não precisa de rede `unrestricted` se você puder listar os sites de que ele precisa. Com a rede `limited`, `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) também se aplica a essas ferramentas (consulte [Rede](https://platform.claude.com/docs/pt-BR/managed-agents/environments#networking)), portanto liste esses sites em `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Listá-los também em `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) de `web_search` faz com que ele pesquise nesses sites. Um host que você adiciona a `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) também fica aberto ao sandbox. Para restringir ainda mais as ferramentas, consulte [Restringir domínios de pesquisa na web e busca na web](https://platform.claude.com/docs/pt-BR/managed-agents/tools-web-restrictions).

Use `unrestricted` somente quando o agente precisar acessar sites que você não pode listar com antecedência. Nesse caso, mantenha segredos e arquivos confidenciais fora do sandbox e forneça ao agente apenas as credenciais de que a tarefa precisa. Considere definir a política de permissão da ferramenta `bash` como `always_ask` ou `auto` e [acompanhar os eventos da sessão](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming).

## Ciclo de vida do ambiente

* Os ambientes persistem até serem explicitamente arquivados ou excluídos.
* Cada sessão recebe sua própria instância de sandbox, mesmo quando várias sessões referenciam o mesmo ambiente. As sessões não compartilham o estado do sistema de arquivos.
* Os ambientes não são versionados. Se você atualiza um ambiente com frequência, mantenha seu próprio registro das alterações para poder identificar qual configuração cada sessão usou.

## Gerenciar ambientes

<CodeGroup>
  ```bash cURL
  # Listar ambientes
  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 um ambiente 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"

  # Arquivar um ambiente (somente leitura, sessões existentes continuam)
  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"

  # Excluir um ambiente (somente se nenhuma sessão o referenciar)
  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 environments
  ant beta:environments list

  # Recuperar um environment específico
  ant beta:environments retrieve --environment-id "$ENVIRONMENT_ID"

  # Arquivar um environment (somente leitura, sessões existentes continuam)
  ant beta:environments archive --environment-id "$ENVIRONMENT_ID"

  # Excluir um environment (só se nenhuma sessão o referenciar)
  ant beta:environments delete --environment-id "$ENVIRONMENT_ID"
  ```

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

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

  # Arquivar um ambiente (somente leitura, sessões existentes continuam)
  client.beta.environments.archive(environment.id)

  # Excluir um ambiente (somente se nenhuma sessão o referenciar)
  client.beta.environments.delete(environment.id)
  ```

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

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

  // Arquivar um ambiente (somente leitura, sessões existentes continuam)
  await client.beta.environments.archive(environment.id);

  // Excluir um ambiente (somente se nenhuma sessão o referenciar)
  await client.beta.environments.delete(environment.id);
  ```

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

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

  // Arquivar um ambiente (somente leitura, sessões existentes continuam)
  await client.Beta.Environments.Archive(environment.ID);

  // Excluir um ambiente (somente se nenhuma sessão o referenciar)
  await client.Beta.Environments.Delete(environment.ID);
  ```

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

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

  // Arquivar um ambiente (somente leitura, sessões existentes continuam)
  _, err = client.Beta.Environments.Archive(ctx, environment.ID, anthropic.BetaEnvironmentArchiveParams{})
  // ...

  // Excluir um ambiente (somente se nenhuma sessão o referenciar)
  _, err = client.Beta.Environments.Delete(ctx, environment.ID, anthropic.BetaEnvironmentDeleteParams{})
  ```

  ```java Java
  // Listar ambientes
  var environments = client.beta().environments().list();
  // Recuperar um ambiente específico
  var env = client.beta().environments().retrieve(environment.id());
  // Arquivar um ambiente (somente leitura, sessões existentes continuam)
  client.beta().environments().archive(environment.id());
  // Excluir um ambiente (somente se nenhuma sessão o referenciar)
  client.beta().environments().delete(environment.id());
  ```

  ```php PHP
  // Listar ambientes
  $environments = $client->beta->environments->list();
  // Recuperar um ambiente específico
  $env = $client->beta->environments->retrieve($environment->id);
  // Arquivar um ambiente (somente leitura, sessões existentes continuam)
  $client->beta->environments->archive($environment->id);
  // Excluir um ambiente (somente se nenhuma sessão o referenciar)
  $client->beta->environments->delete($environment->id);
  ```

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

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

  # Arquivar um ambiente (somente leitura, sessões existentes continuam)
  client.beta.environments.archive(environment.id)

  # Excluir um ambiente (somente se nenhuma sessão o referenciar)
  client.beta.environments.delete(environment.id)
  ```
</CodeGroup>

## Runtimes pré-instalados

Os sandboxes em nuvem incluem runtimes de linguagens comuns, bancos de dados e ferramentas de linha de comando prontos para uso. Consulte a [Referência de sandbox em nuvem](https://platform.claude.com/docs/pt-BR/managed-agents/cloud-sandboxes-reference) para a lista completa.

## Próximos passos

<CardGroup cols={2}>
  <Card title="Referência de sandbox em nuvem" icon="book" href="https://platform.claude.com/docs/pt-BR/managed-agents/cloud-sandboxes-reference">
    Pacotes pré-instalados, bancos de dados e utilitários disponíveis em sandboxes em nuvem.
  </Card>

  <Card title="Iniciar uma sessão" icon="play" href="https://platform.claude.com/docs/pt-BR/managed-agents/sessions">
    Crie uma sessão para executar seu agente e começar a executar tarefas.
  </Card>
</CardGroup>