---
title: "Sandboxes para agentes de IA: microVMs Firecracker · Pethost"
description: "MicroVMs Firecracker para agentes de IA: iniciam em cerca de 0,15 s, pausam com a memória enquanto o agente pensa e acordam em 0,1 s. 2 vCPU por US$ 0,018/h, cobrado por segundo."
---

Pethost Agent Sandboxes

# VMs na nuvem para agentes de IA, pausadas enquanto eles pensam

Cada sandbox é uma microVM Firecracker com kernel próprio e root lá dentro. Ele inicia em cerca de 0,15 s, pausa com a memória e os processos quando fica ocioso e acorda em cerca de 0,1 s na próxima chamada, exatamente onde estava; um login SSH ou uma requisição web também o acordam.

A partir de **US$ 0,018** por hora para 2 vCPU e 4 GiB, cobrado por segundo. Pausado, 30% disso. Iniciar um sandbox é grátis.

[Começar o teste grátis](https://console.pethost.dev/welcome?kind=sandboxes) [Ler a documentação](https://pethost.dev/pt/docs/sandboxes/)

7 dias com US$ 1 de uso. É preciso um cartão, e o primeiro pagamento do plano vem quando o teste termina.

Doze sandboxes de um espaço de trabalho: três rodando, sete pausados com a memória, dois parados. Juntos, custam cerca de US$ 0,09 por hora.

- **~0,15 s** para iniciar um sandbox a partir de um template
- **~0,1 s** para acordar um pausado, com memória e processos como estavam
- **US$ 0,018/h** por 2 vCPU, 4 GiB e 10 GiB enquanto roda
- **1 s** passo da cobrança: cada execução arredondada para cima ao segundo, no mínimo 10 s
- **US$ 0** para criar, fazer fork ou iniciar um sandbox

Medido nos nossos servidores em 18 de novembro de 2026, por uma API a 16 ms de distância: a mediana de uma criação foi de 123 ms (SMALL) a 158 ms (XLARGE), a de uma retomada 124 ms, a de um comando a um sandbox pausado 80 ms.

## O que as equipes rodam nele

- [**O código que seu modelo escreve** Um produto de IA roda o código de cada usuário em um sandbox só dele: um comando e a saída em uma chamada, arquivos editados direto, uma porta com endereço próprio.](https://pethost.dev/pt/sandboxes/code-execution/)
- [**Agentes de código na nuvem** O Claude Code, o Codex e o OpenCode vêm instalados em todo sandbox. Uma chamada dá um prompt a um agente, outra transmite cada chamada de ferramenta que ele faz.](https://pethost.dev/pt/sandboxes/coding-agents/)
- [**RL e evals** Faça fork de um ambiente preparado, com memória e tudo, em uma chamada: três cópias levam cerca de 0,25 s. Rode mil execuções por dia sem pagar por início.](https://pethost.dev/pt/sandboxes/fork/)
- [**Uso do computador** Chrome em um desktop de 1280×800 em todo sandbox: clique, digite e tire uma captura de tela em uma chamada, ou assista ao vivo.](https://pethost.dev/pt/sandboxes/computer-use/)

## Três estados, três preços

A VM de um agente passa a maior parte do tempo esperando enquanto o agente pensa. Os processos dela não devem terminar, então ela pausa com a memória por 30% do preço e acorda na próxima chamada.

Um sandbox passa de rodando a pausado depois de 5 minutos ocioso e a parado depois de 30; a próxima chamada acorda um pausado em 0,1 s.

- Na memória Trabalhando, cobrado por segundo pelo preço do tamanho: US$ 0,018 por hora para 2 vCPU e 4 GiB. Cada execução é arredondada para cima ao segundo, no mínimo 10 s. **US$ 0,018 por hora**
- No disco do servidor Memória, processos e disco guardados, por 30% do preço rodando. A próxima chamada o acorda em cerca de 0,1 s (uma requisição web em cerca de 0,2 s), e ele nunca deixa de acordar por falta de espaço. **US$ 0,0054 por hora**
- No armazenamento de objetos O disco fica guardado, criptografado, por US$ 0,03 por GiB ao mês dos próprios dados; os processos terminam. Uma retomada o inicia a partir do disco em cerca de 0,2 s, ou em cerca de 10 s por GiB quando o disco precisa ser buscado de volta. **US$ 0,03 por GiB ao mês**

Por padrão, um sandbox pausa depois de 5 minutos ocioso, é parado depois de 30 e nunca é excluído. Cada timer é definido por sandbox, e 0 o desativa.

## Tudo o que o computador de um agente faz

Quinze coisas que um sandbox faz, cada uma com uma página sobre como funciona.

- [Três sandboxes em um servidor, cada um uma microVM com kernel próprio e shell root próprio; um quarto inicia em 0,12 s. Uma microVM por sandbox Cada sandbox é uma microVM Firecracker com kernel Linux próprio, root lá dentro e rede própria, iniciada a partir de um snapshot em cerca de 0,15 s. Como funciona](https://pethost.dev/pt/sandboxes/firecracker-microvm/)
- [Um sandbox pausa: a memória vai para o disco do servidor e o preço cai para 30%; chega uma requisição e ele acorda em 0,08 s com o mesmo processo ainda rodando. Pausa com a memória Um sandbox pausado guarda a memória e os processos no servidor por 30% do preço, e a próxima chamada o acorda em cerca de 0,1 s, exatamente onde estava. Como funciona](https://pethost.dev/pt/sandboxes/pause-resume/)
- [Uma linha do tempo de ociosidade: aos 5 minutos o sandbox pausa por US$ 0,0054 por hora, aos 30 minutos ele para no armazenamento de objetos por US$ 0,03 por GiB ao mês. Pausa sozinho quando ocioso Cinco minutos sem chamada e um sandbox pausa; trinta e ele para no armazenamento de objetos. Cada timer é definido por sandbox, e 0 o desativa. Como funciona](https://pethost.dev/pt/sandboxes/auto-pause/)
- [Um sandbox rodando no passo 41 de uma tarefa vira três cópias por fork em 0,25 s; cada uma segue sozinha a partir do passo 41. Fork com memória e tudo Copie um sandbox rodando, com memória, processos e disco, para novos sandboxes em uma chamada. Três cópias levam cerca de um quarto de segundo. Como funciona](https://pethost.dev/pt/sandboxes/fork/)
- [Duas faixas de segundos: uma execução de 37 segundos cobrada a US$ 0,000005 por segundo, arredondada para cima ao segundo inteiro, depois segundos pausados a 30%; criá-lo custou US$ 0. Cobrado por segundo O tempo rodando é cobrado por segundo pelo preço do tamanho, a partir de US$ 0,018 por hora; pausado, a 30%; parado, por GiB de dados. Criar, fazer fork e iniciar é grátis. Como funciona](https://pethost.dev/pt/sandboxes/per-second-billing/)
- [Um programa chama run_command e a saída dos testes volta ao vivo; ele edita um arquivo direto; inicia um dev server e a chamada responde quando a porta 5173 passa a escutar. Comandos, arquivos e um terminal Rode um comando e espere a porta dele, acompanhe a saída ao vivo, edite arquivos por substituição exata, abra um terminal no navegador: uma chamada de API para cada. Como funciona](https://pethost.dev/pt/sandboxes/code-execution/)
- [Um prompt a um agente de código em um sandbox, e as chamadas de ferramenta dele voltando ao vivo: ele lê um arquivo, edita, roda os testes, e o turno termina concluído com a contagem de tokens. Agentes de código, já instalados O Claude Code, o Codex e o OpenCode rodam em todo sandbox com autonomia total: uma chamada dá um prompt a um deles, outra transmite cada chamada de ferramenta que ele faz. Como funciona](https://pethost.dev/pt/sandboxes/coding-agents/)
- [Um desktop com Chrome em um sandbox: o ponteiro clica em um campo, digita um endereço, aperta Enter, e volta uma captura de tela de 1280×800. Um desktop com Chrome Todo sandbox tem uma tela de 1280×800 com Chrome, iniciada no primeiro uso: clique, digite e tire uma captura de tela em uma chamada, ou assista ao vivo. Como funciona](https://pethost.dev/pt/sandboxes/computer-use/)
- [Um comando ssh para um sandbox pausado na porta 2222 o acorda e abre um shell; depois um arquivo é copiado com scp e uma porta é encaminhada com ssh -L. SSH puro, scp e túneis ssh, scp, sftp e ssh -L em qualquer sandbox, com uma chave do espaço de trabalho ou um token como senha; um login acorda um sandbox pausado. Como funciona](https://pethost.dev/pt/sandboxes/ssh/)
- [Uma visita ao endereço HTTPS da porta 3000 acorda um sandbox pausado em 0,2 s e a página aparece; uma porta privada responde 200 a uma requisição com o token e 401 a uma sem. Uma URL para cada porta Um dev server na porta 3000 responde no próprio endereço HTTPS, público ou atrás de um token, e uma visita acorda um sandbox pausado em cerca de 0,2 s. Como funciona](https://pethost.dev/pt/sandboxes/preview-urls/)
- [Um sandbox com os pacotes e as imagens Docker dele é salvo como o template my-app@3 em 1,2 s, e três sandboxes novos iniciam a partir dele em dois servidores. Salve um sandbox como template Salve o disco de um sandbox, pacotes e imagens Docker incluídos, como uma versão de template, e inicie novos sandboxes a partir dela em qualquer servidor. Como funciona](https://pethost.dev/pt/sandboxes/templates/)
- [Um volume de 50 GiB em um servidor: um sandbox escreve arquivos nele em /data e é excluído; o volume e os arquivos ficam, e dois sandboxes novos o montam só para leitura. Volumes que sobrevivem aos sandboxes Monte um volume em um caminho: leitura e escrita em um sandbox ou só leitura em quantos quiser. Ele fica quando eles são excluídos, no disco do servidor. Como funciona](https://pethost.dev/pt/sandboxes/volumes/)
- [As conexões de um sandbox passam por um portão que libera pypi.org e *.github.com e recusa example.com com 403; uma pergunta DNS por um nome fora da lista recebe REFUSED, e o UDP não sai. Saída que você libera, por nome Liste os domínios, wildcards, IPs e CIDRs que um sandbox pode alcançar; o DNS dele não responde mais nada, nenhum UDP sai, e uma mudança vale na hora. Como funciona](https://pethost.dev/pt/sandboxes/egress-allowlist/)
- [Dentro do sandbox a chave de API é um marcador; o proxy de saída coloca a chave real na requisição para api.anthropic.com, e uma requisição para outro host fica com o marcador. Chaves que nunca entram Um sandbox vê um marcador; o proxy de saída o troca pela chave de API real nos cabeçalhos das requisições HTTPS, só para os hosts que você indicar. Como funciona](https://pethost.dev/pt/sandboxes/secrets/)
- [O painel de um sandbox: uma linha de CPU, a memória em uso e um stream de eventos: criado, um comando que saiu com 0, os hosts que alcançou, um turno de agente com os tokens, pausado. Cada comando, host e turno CPU, memória, disco e rede por 24 horas; cada mudança de ciclo de vida, comando, host alcançado e turno de agente, como lista ou stream ao vivo. Como funciona](https://pethost.dev/pt/sandboxes/observability/)

## Para o seu agente, o seu código e o seu terminal

Cada um controla os sandboxes pela mesma API e só precisa do seu token do Pethost: o servidor em que um sandbox roda é encontrado, e o login nele é feito para você.

- **Servidor MCP** Adicione-o ao Claude, ao ChatGPT, ao Cursor ou a qualquer cliente MCP. Ele entra com a sua conta do Pethost, e o seu agente cria, inicia, faz fork e pausa sandboxes com ele. `https://mcp.pethost.dev/sandboxes`Copiar
- **SDKs** Python, TypeScript, Go e Rust, gerados a partir da API, cada um com os mesmos métodos.
- **CLI** `pethost sandbox` cria, roda, abre e faz fork de sandboxes no seu terminal.

Python

TypeScript

Go

Rust

CLI

Instalar `pip install pethost`

```
from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # lê o PETHOST_TOKEN
box = sandboxes.create_sandbox("base")
result = sandboxes.run_command(box.sandbox_id, command="python3 -c 'print(6 * 7)'")
print(result.stdout)  # 42
```

Instalar `npm install pethost`

```
import { Sandboxes } from "pethost/sandboxes";

const sandboxes = new Sandboxes({ token: process.env.PETHOST_TOKEN! });
const box = await sandboxes.createSandbox({ template: "base" });
const result = await sandboxes.runCommand({ sandboxId: box.sandboxId, command: "node -p 6*7" });
console.log(result.stdout); // 42
```

Instalar `go get github.com/pethost-dev/sdk/go`

```
client := sandboxes.NewClient(sandboxes.Config{Token: os.Getenv("PETHOST_TOKEN")})
box, err := client.CreateSandbox(ctx, &sandboxes.CreateSandboxRequest{Template: "base"})
check(err)
result, err := client.RunCommand(ctx, &sandboxes.RunCommandRequest{
	SandboxID: box.SandboxID, Command: "echo $((6 * 7))",
})
check(err)
fmt.Println(result.Stdout) // 42
```

Instalar `cargo add pethost`

```
use pethost::sandboxes::{types::*, Client};

let client = Client::new(&std::env::var("PETHOST_TOKEN")?);
let base = CreateSandboxRequest { template: "base".into(), ..Default::default() };
let sandbox = client.create_sandbox(base).await?;
let command = RunCommandRequest { sandbox_id: sandbox.sandbox_id, command: "echo $((6 * 7))".into(), ..Default::default() };
let result = client.run_command(command).await?;
println!("{}", result.stdout); // 42
```

Instalar `curl -fsSL https://pethost.dev/install.sh | sh`

```
pethost sandbox new --name api-dev --size small
pethost sandbox run api-dev -- python3 -c 'print(6 * 7)'
pethost sandbox shell api-dev  # um shell lá dentro
```

## Como se compara

Preços e recursos como as páginas de cada fornecedor diziam em 21 de novembro de 2026, para 2 vCPU e 4 GiB.

### O que cada um faz

|  | Pethost | E2B | Daytona | Modal | Vercel Sandbox | boat.dev |
| --- | --- | --- | --- | --- | --- | --- |
| Isolamento | Sim microVM Firecracker | Sim Firecracker | Em parte containers; uma classe de VM Linux1 | Em parte gVisor; uma opção de runtime de VM2 | Sim Firecracker | Sim uma VM por sandbox |
| Rodando, 2 vCPU · 4 GiB, por hora | US$ 0,018 | US$ 0,1656 | US$ 0,1656 mais disco acima de 5 GiB | US$ 0,2380 | US$ 0,1104 com 10% de CPU, US$ 0,3408 com 100% de CPU | US$ 0,018 |
| Pausa guarda memória e processos | Sim 30% do preço rodando | Sim grátis enquanto pausado | Em parte só a classe de VM, disco cobrado3 | Em parte snapshots de memória em alfa, guardados por 7 dias4 | Não só o sistema de arquivos | Não “Não há pausa” |
| Sem taxa por início | Sim dentro dos limites do plano | Sim | Sim | Sim | Em parte US$ 0,60 por milhão de criações | Não US$ 0,03–0,07 além dos inícios incluídos5 |
| Fork com memória | Sim 3 cópias em 0,25 s | Sim | Em parte classe de VM | Em parte de um snapshot de memória, em alfa | Não só o sistema de arquivos | Não do último snapshot do disco |
| Templates próprios | Sim salvos de um sandbox | Sim um construtor de templates | Sim de uma imagem ou de um Dockerfile | Sim imagens | Sim imagens, snapshots | Sim snapshots salvos |
| Lista de permissões de saída | Sim domínios, IPs, CIDRs, portas | Sim | Em parte do tier 3 em diante6 | Em parte beta, TLS na porta 443 | Sim | Não |
| Chaves de API fora do sandbox | Sim inseridas pelo proxy | Sim | Não informado nas páginas que lemos | Em parte em beta | Sim | Em parte só chaves de IA, US$ 1 por dia + US$ 1 a cada 1.000 requisições |
| SSH, scp, túneis | Sim | Em parte por um proxy WebSocket | Não informado nas páginas que lemos | Não informado nas páginas que lemos | Não só a CLI dele | Sim |
| Desktop para uso do computador | Sim Chrome, 1280×800 | Sim | Sim | Não informado nas páginas que lemos | Não informado nas páginas que lemos | Sim |
| Servidor MCP para sandboxes | Sim | Em parte um gateway de ferramentas dentro do sandbox | Sim | Não informado nas páginas que lemos | Não informado nas páginas que lemos | Em parte só para a documentação dele |
| SDKs | Python, TypeScript, Go, Rust | Python, JS/TS | Python, TS, Ruby, Go, Java | Python, JS, Go | TypeScript | Python, TypeScript |
| Onde | UE | EUA; UE sob pedido | EUA, UE | regiões a 1,15–1,75× o preço | 19 regiões | UE |
| Menor conta mensal | US$ 20, tudo em uso | US$ 0 no Hobby | US$ 0 | US$ 0, com US$ 30 de crédito por mês | US$ 0 no Hobby | US$ 20, tudo em uso |

Sim Em parte Não Não informado nas páginas que lemos

1. O Daytona roda containers por padrão; a classe de VM Linux dele pausa e faz fork.
2. O Modal roda sandboxes no gVisor e oferece uma opção de runtime de VM.
3. O Daytona cobra de uma VM pausada só o disco; a memória guardada não é cobrada.
4. Os snapshots de memória do Modal estão em alfa e expiram 7 dias depois de criados.
5. O boat.dev inclui 12, 60 e 200 inícios por minuto, hora e dia no plano de US$ 20, vende mais por US$ 0,03 a US$ 0,07 cada e recusa acima de 6 vezes isso (3 vezes por minuto).
6. Os tiers 1 e 2 do Daytona restringem o acesso à rede a serviços essenciais, e um sandbox não pode mudar isso.

- O E2B e o Daytona não têm mínimo mensal: um agente leve custa menos lá do que o nosso plano de US$ 20. Quatro agentes assim custam mais lá do que o plano.
- O E2B não cobra nada por um sandbox pausado, e o Daytona cobra só o disco; o nosso custa 30% do preço rodando e guarda o lugar dele no servidor. Ao longo de um mês, o preço rodando pesa mais.

### Uma hora de 2 vCPU e 4 GiB

- **Pethost**SMALL **US$ 0,018**
- **boat.dev**small **US$ 0,018**
- **Cloudflare Containers**2 vCPU · 4 GiB · 8 GB **US$ 0,052** com 10% de CPU US$ 0,182 com 100% de CPU
- **Northflank** **US$ 0,0667**
- **Vercel Sandbox** **US$ 0,1104** com 10% de CPU US$ 0,3408 com 100% de CPU
- **E2B** **US$ 0,1656**
- **Daytona** **US$ 0,1656** mais disco acima de 5 GiB
- **Blaxel** **US$ 0,1656** enquanto ativo
- **Modal** **US$ 0,2380**
- **Runloop**MEDIUM **US$ 0,3195**

Uma hora rodando, 2 vCPU e 4 GiB, só computação, pelo preço de tabela de cada fornecedor em 21 de novembro de 2026.

### Duas cargas de trabalho, um mês

#### Um agente: um sandbox, 2 horas ativo e 22 ocioso por dia

| Fornecedor | Quando ocioso | Memória guardada | Uso | Conta |
| --- | --- | --- | --- | --- |
| Pethost | pausado | Sim | US$ 4,64 | **US$ 20**o plano, que cobre cerca de quatro agentes assim |
| E2B | pausado, de graça | Sim | US$ 9,94 | **US$ 9,94**no Hobby, com uma pausa a cada hora; US$ 159,94 no Pro |
| Daytona | classe de VM, pausado | Sim | US$ 10,17 | **US$ 10,17** |
| Blaxel | em standby | Sim | US$ 11,74 | **US$ 11,74** |
| boat.dev | parado | Não | US$ 1,08 | **US$ 20** |
| Modal | um snapshot, 24h no máximo | Não | US$ 14,28 | **US$ 0**dentro do crédito mensal de US$ 30 |

Com a memória guardada, o mês do agente custa US$ 4,64 aqui, menos da metade do que no E2B, no Daytona ou no Blaxel. O boat.dev custa menos quando a memória pode ir embora. Para um agente sozinho, o E2B e o Daytona cobram menos que o nosso plano de US$ 20; a partir de quatro agentes, o plano sai mais barato.

#### Evals: 1.000 sandboxes por dia, 60 segundos cada

| Fornecedor | Computação | Taxas por início | Conta |
| --- | --- | --- | --- |
| Pethost | US$ 9,00 | US$ 0 | US$ 20 |
| boat.dev | US$ 9,00 | US$ 144 no plano de US$ 100, ou US$ 1.500 no plano de US$ 20 | US$ 244 |
| E2B | US$ 82,80 | US$ 0 | US$ 82,80 no Hobby |
| Daytona | US$ 82,96 | US$ 0 | US$ 82,96 |
| Modal | US$ 118,98 | US$ 0 | US$ 88,98 depois do crédito de US$ 30 |
| Vercel Sandbox | US$ 55,22 com 10% de CPU, US$ 170,42 com 100% de CPU | US$ 0,02 | US$ 55,22 com 10% de CPU, US$ 170,42 com 100% de CPU |

Sandboxes curtos e numerosos custam menos aqui. No boat.dev, as taxas por início são a maior parte da conta.

No plano de US$ 20, 1.000 inícios por dia espalhados ao longo do dia (cerca de 42 por hora) ficam dentro dos inícios grátis, e 10 sandboxes SMALL rodam ao mesmo tempo.

2 vCPU e 4 GiB em todos, um mês de 30 dias, 5 GiB de dados do próprio sandbox guardados enquanto está ocioso. Créditos que acabam não entram na conta; créditos que vêm todo mês, sim.

### Todo início que o boat.dev deixa você comprar, grátis

O boat.dev inclui alguns inícios em cada plano, vende mais por US$ 0,03 a US$ 0,07 cada e recusa acima de seis vezes o que inclui (três vezes por minuto). Nossos planos custam o mesmo, e os inícios deles são grátis até exatamente essas quantidades. Acordar um sandbox pausado nunca conta como início.

| Plano | O boat.dev inclui | O boat.dev vende até, depois recusa | Pethost, grátis |
| --- | --- | --- | --- |
| US$ 20 | 12 · 60 · 200 | 36 · 360 · 1.200 | 36 · 360 · 1.200 |
| US$ 100 | 30 · 210 · 840 | 90 · 1.260 · 5.040 | 90 · 1.260 · 5.040 |
| US$ 500 | 65 · 420 · 1.680 | 195 · 2.520 · 10.080 | 195 · 2.520 · 10.080 |
| US$ 2.000 | 90 · 600 · 2.400 | 270 · 3.600 · 14.400 | 270 · 3.600 · 14.400 |

Inícios por minuto · por hora · por dia.

## O preço do plano é o seu uso

O preço mensal de cada plano volta inteiro como uso, pelas tarifas abaixo. Depois disso, paga um saldo que você adiciona: de US$ 10 a US$ 1.000, e ele nunca expira.

- **US$ 20**por mês Uso incluídoUS$ 20vCPUs ao mesmo tempo20contam sandboxes rodando e pausadosMaior tamanhoLARGEVolumes100 GiBTemplates5 GiBInícios grátis36 · 360 · 1.200por minuto · por hora · por dia [Começar o teste grátis](https://console.pethost.dev/welcome?kind=sandboxes)
- **US$ 100**por mês Uso incluídoUS$ 100vCPUs ao mesmo tempo128contam sandboxes rodando e pausadosMaior tamanhoXLARGEVolumes600 GiBTemplates30 GiBInícios grátis90 · 1.260 · 5.040por minuto · por hora · por dia [Começar o teste grátis](https://console.pethost.dev/welcome?kind=sandboxes)
- **US$ 500**por mês Uso incluídoUS$ 500vCPUs ao mesmo tempo700contam sandboxes rodando e pausadosMaior tamanhoXLARGEVolumes3.500 GiBTemplates175 GiBInícios grátis195 · 2.520 · 10.080por minuto · por hora · por dia [Começar o teste grátis](https://console.pethost.dev/welcome?kind=sandboxes)
- **US$ 2.000**por mês Uso incluídoUS$ 2.000vCPUs ao mesmo tempo3.000contam sandboxes rodando e pausadosMaior tamanhoXLARGEVolumes16.000 GiBTemplates800 GiBInícios grátis270 · 3.600 · 14.400por minuto · por hora · por dia [Começar o teste grátis](https://console.pethost.dev/welcome?kind=sandboxes)

### Teste grátis

7 dias com US$ 1 de uso, 4 vCPUs ao mesmo tempo e tamanhos até DEFAULT. É preciso um cartão, e o primeiro pagamento do plano vem quando o teste termina ou quando você inicia o plano.

vCPUs ao mesmo tempo4 Maior tamanhoDEFAULT Volumes10 GiB Inícios grátis15 · 75 · 225por minuto · por hora · por dia

| Tamanho | Rodando | Pausado |
| --- | --- | --- |
| SMALL2 vCPU · 4 GiB · 10 GiB | **US$ 0,018** por hora | US$ 0,0054 por hora |
| DEFAULT4 vCPU · 8 GiB · 20 GiB | **US$ 0,036** por hora | US$ 0,0108 por hora |
| LARGE8 vCPU · 16 GiB · 40 GiB | **US$ 0,072** por hora | US$ 0,0216 por hora |
| XLARGE16 vCPU · 32 GiB · 80 GiB | **US$ 0,144** por hora | US$ 0,0432 por hora |

- Parado: US$ 0,03 por GiB ao mês dos dados do próprio sandbox, nunca do espaço vazio.
- Volumes: US$ 0,20 por GiB ao mês do tamanho deles.
- Templates: grátis, dentro do espaço do plano.
- US$ 20 de uso são 1.111 horas de um sandbox SMALL rodando, ou 3.704 horas pausado.

Preços em dólares americanos, sem impostos. Na UE você paga os mesmos números em euros, mais IVA.

## Perguntas

**Como um sandbox fica separado do outro?**

Cada sandbox é uma microVM Firecracker própria, com o próprio kernel Linux, iniciada dentro do jailer do Firecracker: chroot próprio, um usuário sem privilégios, limites de cgroup, um filtro seccomp e um namespace de rede próprio. Lá dentro você é root. A virtualização aninhada está desativada, e chaves de API ligadas como segredos nunca entram na VM.

**As vCPUs e a memória são compartilhadas com outros sandboxes?**

O hardware é compartilhado, como em qualquer nuvem nessa faixa de preço: muitos sandboxes rodam em um servidor, e cada um fica preso ao seu tamanho, nunca mais que o tempo das suas vCPUs e a sua memória. Um vizinho ocupado pode deixar a CPU de um sandbox mais lenta, e um servidor com pouca memória pausa mais cedo sandboxes ociosos há um minuto ou mais, que a próxima chamada acorda como sempre.

**Onde os sandboxes rodam, e onde ficam meus dados?**

Na UE. Os sandboxes rodam nos nossos servidores na UE, e o disco de um sandbox parado e os seus templates ficam no armazenamento de objetos na UE, criptografados, cada um com uma chave própria. Há uma só região, então não há nada para escolher. A [política de privacidade](https://pethost.dev/privacy/) diz quem processa o quê.

**O que acontece quando meu agente fica quieto?**

Depois de 5 minutos sem chamada, sessão SSH ou requisição web, o sandbox pausa: memória e processos ficam guardados por 30% do preço rodando, e a próxima chamada o acorda em cerca de 0,1 s. Depois de 30 minutos, ele para: o disco vai para o armazenamento de objetos por US$ 0,03 por GiB ao mês, e os processos terminam. Nada é excluído, a não ser que você defina um timer para isso. Um comando iniciado com `keep_awake` o mantém acordado.

**Tem GPU?**

Não. O maior tamanho tem 16 vCPU, 32 GiB de memória e 80 GiB de disco.

**Quais são os limites?**

Um plano define quantas vCPUs os sandboxes rodando e pausados dele podem ter ao mesmo tempo (20 no plano de US$ 20, ou seja, 10 sandboxes SMALL), o maior tamanho e os inícios grátis por minuto, por hora e por dia. Sandboxes parados não têm limite de quantidade, e nenhum sandbox tem limite de tempo de vida. Um fork cria até 100 cópias em uma chamada, quantas couberem no servidor do sandbox, e um sandbox abre até 20 portas públicas.

**Como funciona a cobrança?**

O preço mensal de um plano é uso que ele inclui. Um sandbox rodando é cobrado por segundo pelo preço do tamanho, cada execução arredondada para cima ao segundo, com no mínimo 10 s; um pausado, por 30% disso; um parado, pelos GiB que os próprios dados ocupam. Criar, fazer fork e iniciar não custam nada. O uso além do plano é pago por um saldo que você adiciona, de US$ 10 a US$ 1.000, que nunca expira.

Se os dois acabarem, os sandboxes rodando e pausados são parados e nada novo inicia até entrar dinheiro; nada é excluído.

**Qual a diferença para o E2B?**

Os dois rodam cada sandbox em uma microVM Firecracker, e os dois guardam memória e processos quando um sandbox pausa. 2 vCPU e 4 GiB custam US$ 0,018 por hora rodando aqui e US$ 0,1656 no E2B, que não cobra nada enquanto o sandbox está pausado, onde nós cobramos 30%. O E2B tem um plano Hobby grátis com um crédito único de US$ 100; nossos planos começam em US$ 20 por mês, tudo em uso. Aqui os sandboxes têm SSH puro e rodam na UE; o E2B roda nos EUA, a não ser que você peça o cluster da UE. Os números do E2B são das páginas dele em 21 de novembro de 2026.

**Tem teste grátis?**

Sim: 7 dias com US$ 1 de uso, 4 vCPUs ao mesmo tempo e tamanhos até DEFAULT, o que dá 55 horas de um sandbox SMALL rodando. É preciso um cartão, e o primeiro pagamento do plano vem quando o teste termina.

## Dê um computador ao seu agente em 0,15 s

[Começar o teste grátis](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/pt/templates/)
- [Sobre nós](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pt/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Termos](https://pethost.dev/terms/)
- [Privacidade](https://pethost.dev/privacy/)
- [Reembolsos](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bancos de dados

- [Postgres](https://pethost.dev/pt/postgres/)
- [Valkey](https://pethost.dev/pt/valkey/)

Agent Sandboxes

- [Sandboxes](https://pethost.dev/pt/sandboxes/)
- [Preços](https://pethost.dev/pt/sandboxes/#pricing)
- [Docs](https://pethost.dev/pt/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Comparativos

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pt/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pt/blog/coolify-cloud-vs-dokploy-cloud/)
- [Preços Railway vs Render vs Fly.io](https://pethost.dev/pt/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hospedagem gerenciada de Docker Compose](https://pethost.dev/pt/blog/managed-docker-compose-hosting/)

Alternativas

- [Alternativas ao Railway](https://pethost.dev/pt/blog/railway-alternatives/)
- [Alternativas ao Heroku](https://pethost.dev/pt/blog/heroku-alternatives/)
- [Alternativas ao Dokploy](https://pethost.dev/pt/blog/dokploy-alternatives/)
- [Alternativas ao Coolify](https://pethost.dev/pt/blog/coolify-alternatives/)
- [Alternativas ao Render](https://pethost.dev/pt/blog/render-alternatives/)
- [Alternativas ao Sliplane](https://pethost.dev/pt/blog/sliplane-alternatives/)
