---
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
  zdr:
    eligibility: not-eligible
    note: Não é elegível para ZDR, exceto o Managed Agents auto-hospedado. Sessões são recursos com estado; as transcrições persistem até que você as exclua.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
    Claude Models on Google Cloud (Anthropic managed): beta
---

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: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "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 (consulte [Iniciar 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: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "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`) instala pacotes no sandbox antes de o agente usá-lo. Os gerenciadores de pacotes são executados em ordem alfabética (apt, cargo, gem, go, npm, pip). Você pode fixar versões específicas. 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 API rejeita a requisição 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: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "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)
  }
  ```

  ```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 web fetch](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 **Limitado** 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: 2026-10-21" \
    -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)
  }
  ```

  ```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 hosts 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 hosts 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 API rejeita a requisição com um erro 400, mesmo que `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) liste os hosts de registro.

#### 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 solicitaçã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ões](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 da web, respostas de API e outros conteúdos que o agente lê podem conter instruções (injeção de prompt) que mudam 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 web fetch](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é que você os arquive ou exclua.
* 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: 2026-10-21" \
    -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: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Arquivar um ambiente (somente leitura, sem novas sessões)
  curl -fsS -X POST "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Excluir um ambiente
  curl -fsS -X DELETE "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -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, sem novas sessões)
  ant beta:environments archive --environment-id "$ENVIRONMENT_ID"

  # Excluir um environment
  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, sem novas sessões)
  client.beta.environments.archive(environment.id)

  # Excluir um ambiente
  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, sem novas sessões)
  await client.beta.environments.archive(environment.id);

  // Excluir um ambiente
  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, sem novas sessões)
  await client.Beta.Environments.Archive(environment.ID);

  // Excluir um ambiente
  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, sem novas sessões)
  _, err = client.Beta.Environments.Archive(ctx, environment.ID, anthropic.BetaEnvironmentArchiveParams{})
  // ...

  // Excluir um ambiente
  _, 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, sem novas sessões)
  client.beta().environments().archive(environment.id());
  // Excluir um ambiente
  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, sem novas sessões)
  $client->beta->environments->archive($environment->id);
  // Excluir um ambiente
  $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, sem novas sessões)
  client.beta.environments.archive(environment.id)

  # Excluir um ambiente
  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. 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>

## Disponibilidade

Sandboxes na nuvem estão em beta em todos os modelos.

### Suporte da API

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

* Disponibilidade: Disponível

| Status | Plataformas de nuvem | Modelos |
| ----- | ----- | ----- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed) | [Todos os modelos](https://platform.claude.com/docs/pt-BR/models/overview) |

### Cabeçalhos beta obrigatórios

[Visão geral dos cabeçalhos beta](https://platform.claude.com/docs/pt-BR/api/beta-headers)

Os cabeçalhos beta permitem que você acesse recursos experimentais e novas capacidades de modelos antes que eles se tornem parte da API padrão.

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

### Tratamento de dados

[Visão geral do tratamento de dados](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention#feature-eligibility)

| Item | Retenção zero de dados | HIPAA |
| ----- | ----- | ----- |
| Status | Não elegível | Não elegível |
| Detalhes | Não é elegível para ZDR, exceto o Managed Agents auto-hospedado. Sessões são recursos com estado; as transcrições persistem até que você as exclua. [Saiba mais](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Não é elegível para HIPAA. Aplica-se a todos os sub-recursos do Managed Agents. |

Endpoints aplicáveis:

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