---
title: "Sandboxes para agentes de IA: microVM Firecracker · Pethost"
description: "MicroVM Firecracker para agentes de IA: se inician en unos 0,15 s, se pausan con su memoria mientras el agente piensa y despiertan en 0,1 s. 2 vCPU por 0,018 US$/h, facturado por segundo."
---

Pethost Agent Sandboxes

# VM en la nube para agentes de IA, en pausa mientras piensan

Cada sandbox es una microVM Firecracker con su propio kernel y acceso root dentro. Se inicia en unos 0,15 s, se pausa con su memoria y sus procesos cuando está inactivo y despierta en unos 0,1 s con la siguiente llamada, justo donde estaba; un inicio de sesión SSH o una petición web también lo despiertan.

Desde **0,018 US$** la hora por 2 vCPU y 4 GiB, facturado por segundo. En pausa, el 30 % de eso. Iniciar uno es gratis.

[Empezar la prueba gratis](https://console.pethost.dev/welcome?kind=sandboxes) [Leer la documentación](https://pethost.dev/es/docs/sandboxes/)

7 días con 1 US$ de uso. Se pide una tarjeta, y el primer pago del plan llega cuando termina la prueba.

Doce sandboxes de un espacio de trabajo: tres en ejecución, siete en pausa con su memoria y dos detenidos. Juntos cuestan unos 0,09 US$ la hora.

- **~0,15 s** para iniciar un sandbox desde una plantilla
- **~0,1 s** para despertar uno en pausa, con la memoria y los procesos como estaban
- **0,018 US$/h** por 2 vCPU, 4 GiB y 10 GiB en ejecución
- **1 s** como unidad de facturación: cada ejecución se redondea al segundo, con 10 s como mínimo
- **0 US$** por crear, copiar o iniciar un sandbox

Medido en nuestros servidores el 18 de noviembre de 2026, a través de una API a 16 ms: una creación, en la mediana, de 123 ms (SMALL) a 158 ms (XLARGE); una reanudación, 124 ms; un comando a un sandbox en pausa, 80 ms.

## Para qué se usa

- [**El código que escribe tu modelo** Un producto de IA ejecuta el código de cada usuario en un sandbox aparte: un comando y su salida en una llamada, archivos editados en su sitio, un puerto en su propia dirección.](https://pethost.dev/es/sandboxes/code-execution/)
- [**Agentes de programación en la nube** Claude Code, Codex y OpenCode vienen instalados en cada sandbox. Una llamada le da un prompt a un agente, y otra transmite cada llamada a herramienta que hace.](https://pethost.dev/es/sandboxes/coding-agents/)
- [**RL y evals** Haz un fork de un entorno preparado, con su memoria, en una llamada: tres copias tardan unos 0,25 s. Inicia mil ejecuciones al día sin cargo por inicio.](https://pethost.dev/es/sandboxes/fork/)
- [**Escritorio para computer use** Chrome en un escritorio de 1280×800 en cada sandbox: haz clic, escribe y toma una captura de pantalla en una llamada, o míralo en tiempo real.](https://pethost.dev/es/sandboxes/computer-use/)

## Tres estados, tres precios

La VM de un agente pasa casi todo el tiempo esperando mientras el agente piensa. Sus procesos no deben terminar, así que se pausa con su memoria al 30 % del precio y despierta con la siguiente llamada.

Un sandbox en ejecución se pausa tras 5 minutos inactivo y se detiene tras 30; la siguiente llamada despierta uno en pausa en 0,1 s.

- En memoria Trabajando, facturado por segundo al precio de su tamaño: 0,018 US$ la hora por 2 vCPU y 4 GiB. Cada ejecución se redondea al segundo, 10 s como mínimo. **0,018 US$ la hora**
- En el disco de su servidor Memoria, procesos y disco conservados, al 30 % del precio en ejecución. La siguiente llamada lo despierta en unos 0,1 s (una petición web, en unos 0,2 s), y despertarlo nunca se rechaza por falta de espacio. **0,0054 US$ la hora**
- En almacenamiento de objetos Su disco se conserva, cifrado, a 0,03 US$ por GiB al mes de sus propios datos; sus procesos terminan. Una reanudación lo arranca desde su disco en unos 0,2 s, o en unos 10 s por GiB si hubo que traer su disco de vuelta. **0,03 US$ por GiB al mes**

Por defecto, un sandbox se pausa tras 5 minutos inactivo y se detiene tras 30, y nunca se elimina. Cada temporizador se configura por sandbox, y 0 lo desactiva.

## Todo lo que hace la VM de un agente

Quince cosas que hace un sandbox, cada una con una página que explica cómo funciona.

- [Tres sandboxes en un servidor, cada uno una microVM con su propio kernel y su propio shell de root; un cuarto se inicia en 0,12 s. Una microVM por sandbox Cada sandbox es una microVM Firecracker con su propio kernel Linux, root dentro y su propia red, iniciada desde un snapshot en unos 0,15 s. Cómo funciona](https://pethost.dev/es/sandboxes/firecracker-microvm/)
- [Un sandbox se pausa: su memoria pasa al disco de su servidor y su precio baja al 30 %; llega una petición y despierta en 0,08 s con el mismo proceso aún en ejecución. Se pausa con su memoria Un sandbox en pausa conserva su memoria y sus procesos en su servidor al 30 % del precio, y la siguiente llamada lo despierta en unos 0,1 s, justo donde estaba. Cómo funciona](https://pethost.dev/es/sandboxes/pause-resume/)
- [Una línea de tiempo inactivo: a los 5 minutos el sandbox se pausa a 0,0054 US$ la hora; a los 30 minutos se detiene en almacenamiento de objetos a 0,03 US$ por GiB al mes. Se pausa solo si está inactivo Cinco minutos sin llamadas y un sandbox se pausa; treinta y se detiene en almacenamiento de objetos. Cada temporizador se configura por sandbox, y 0 lo desactiva. Cómo funciona](https://pethost.dev/es/sandboxes/auto-pause/)
- [Un sandbox en ejecución en el paso 41 de una tarea se copia en tres en 0,25 s; cada copia sigue por su cuenta desde el paso 41. Fork con memoria y todo Copia un sandbox en ejecución, con su memoria, sus procesos y su disco, en sandboxes nuevos en una llamada. Tres copias tardan alrededor de un cuarto de segundo. Cómo funciona](https://pethost.dev/es/sandboxes/fork/)
- [Dos carriles de segundos: una ejecución de 37 segundos facturada a 0,000005 US$ por segundo, redondeada al segundo entero, y luego segundos en pausa al 30 %; crearlo costó 0 US$. Facturado por segundo El tiempo en ejecución se factura por segundo al precio del tamaño, desde 0,018 US$ la hora; en pausa al 30 %; detenido por GiB de datos. Crear, copiar e iniciar no cuesta nada. Cómo funciona](https://pethost.dev/es/sandboxes/per-second-billing/)
- [Un programa llama a run_command y la salida de los tests llega en tiempo real; edita un archivo en su sitio; inicia un servidor de desarrollo y la llamada responde cuando el puerto 5173 escucha. Comandos, archivos y terminal Ejecuta un comando y espera su puerto, recibe su salida en tiempo real, edita archivos con reemplazos exactos, abre una terminal en el navegador: una llamada a la API cada cosa. Cómo funciona](https://pethost.dev/es/sandboxes/code-execution/)
- [Un prompt a un agente de programación en un sandbox, y sus llamadas a herramientas llegando en tiempo real: lee un archivo, lo edita, ejecuta los tests, y el turno termina con éxito y su cuenta de tokens. Agentes de programación, ya instalados Claude Code, Codex y OpenCode se ejecutan en cada sandbox con autonomía total: una llamada le da un prompt a uno, otra transmite cada llamada a herramienta que hace. Cómo funciona](https://pethost.dev/es/sandboxes/coding-agents/)
- [Un escritorio con Chrome en un sandbox: el puntero hace clic en un campo, escribe una dirección, pulsa Enter y vuelve una captura de 1280×800. Un escritorio con Chrome Cada sandbox tiene una pantalla de 1280×800 con Chrome, que se inicia la primera vez que se usa: haz clic, escribe y toma una captura en una llamada, o míralo en tiempo real. Cómo funciona](https://pethost.dev/es/sandboxes/computer-use/)
- [Un comando ssh a un sandbox en pausa en el puerto 2222 lo despierta y abre un shell; luego se copia un archivo con scp y se reenvía un puerto con ssh -L. SSH normal, scp y túneles ssh, scp, sftp y ssh -L a cualquier sandbox con una clave del espacio de trabajo o un token como contraseña; un inicio de sesión despierta uno en pausa. Cómo funciona](https://pethost.dev/es/sandboxes/ssh/)
- [Una visita a la dirección HTTPS del puerto 3000 despierta un sandbox en pausa en 0,2 s y aparece su página; un puerto privado responde 200 a una petición con su token y 401 a una sin él. Una URL para cada puerto Un servidor de desarrollo en el puerto 3000 responde en su propia dirección HTTPS, pública o tras un token, y una visita despierta un sandbox en pausa en unos 0,2 s. Cómo funciona](https://pethost.dev/es/sandboxes/preview-urls/)
- [Un sandbox con sus paquetes e imágenes de Docker se guarda como la plantilla my-app@3 en 1,2 s, y tres sandboxes nuevos se inician desde ella en dos servidores. Guarda un sandbox como plantilla Guarda el disco de un sandbox, con sus paquetes e imágenes de Docker, como versión de una plantilla, e inicia sandboxes nuevos desde ella en cualquier servidor. Cómo funciona](https://pethost.dev/es/sandboxes/templates/)
- [Un volumen de 50 GiB en un servidor: un sandbox escribe archivos en él en /data y se elimina; el volumen y sus archivos se quedan, y dos sandboxes nuevos lo montan de solo lectura. Volúmenes que sobreviven al sandbox Monta un volumen en un path: de lectura y escritura en un sandbox o de solo lectura en los que quieras. Se queda cuando se eliminan, en el disco de su servidor. Cómo funciona](https://pethost.dev/es/sandboxes/volumes/)
- [Las conexiones de un sandbox pasan por una puerta que permite pypi.org y *.github.com y rechaza example.com con un 403; una consulta DNS por un nombre fuera de la lista recibe REFUSED, y UDP no sale. La salida que permites, por nombre Lista los dominios, comodines, IP y CIDR a los que puede llegar un sandbox; su DNS no responde nada más, ningún UDP sale, y un cambio se aplica al momento. Cómo funciona](https://pethost.dev/es/sandboxes/egress-allowlist/)
- [Dentro del sandbox la clave de API es un marcador; el proxy de salida pone la clave real en la petición a api.anthropic.com, y una petición a otro host conserva el marcador. Claves que nunca entran Un sandbox ve un marcador; el proxy de salida pone la clave de API real en las cabeceras de las peticiones HTTPS, solo para los hosts que indiques. Cómo funciona](https://pethost.dev/es/sandboxes/secrets/)
- [El panel de un sandbox: una línea de CPU, la memoria en uso y un stream de eventos: creado, un comando que terminó con 0, los hosts a los que llegó, un turno de agente con sus tokens, en pausa. Cada comando, host y turno CPU, memoria, disco y red de 24 horas; cada cambio del ciclo de vida, comando, host alcanzado y turno de agente, como lista o como stream en tiempo real. Cómo funciona](https://pethost.dev/es/sandboxes/observability/)

## Para tu agente, tu código y tu terminal

Los tres manejan sandboxes con la misma API y solo necesitan tu token de Pethost: Pethost encuentra por ti el servidor de cada sandbox e inicia sesión en él.

- **Servidor MCP** Agrégalo a Claude, ChatGPT, Cursor o cualquier cliente MCP. Inicia sesión con tu cuenta de Pethost, y con él tu agente crea, inicia, copia y pausa sandboxes. `https://mcp.pethost.dev/sandboxes`Copiar
- **SDK** Python, TypeScript, Go y Rust, generados a partir de la API, cada uno con los mismos métodos.
- **CLI** `pethost sandbox` crea, usa, abre y copia sandboxes desde tu terminal.

Python

TypeScript

Go

Rust

CLI

Instalar `pip install pethost`

```
from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # lee 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  # una shell dentro
```

## Cómo se compara

Precios y funciones tal como los indicaban las propias páginas de cada proveedor el 21 de noviembre de 2026, para 2 vCPU y 4 GiB.

### Qué hace cada uno

|  | Pethost | E2B | Daytona | Modal | Vercel Sandbox | boat.dev |
| --- | --- | --- | --- | --- | --- | --- |
| Aislamiento | Sí microVM Firecracker | Sí Firecracker | En parte contenedores; una clase de VM Linux1 | En parte gVisor; una opción de runtime de VM2 | Sí Firecracker | Sí una VM por sandbox |
| En ejecución, 2 vCPU · 4 GiB, por hora | 0,018 US$ | 0,1656 US$ | 0,1656 US$ más el disco por encima de 5 GiB | 0,2380 US$ | 0,1104 US$ con un 10 % de CPU, 0,3408 US$ con un 100 % de CPU | 0,018 US$ |
| La pausa conserva memoria y procesos | Sí 30 % del precio en ejecución | Sí gratis en pausa | En parte solo la clase VM, se cobra el disco3 | En parte snapshots de memoria en alpha, conservados 7 días4 | No solo el sistema de archivos | No “No hay pausa” |
| Sin cargo por inicio | Sí dentro de los límites del plan | Sí | Sí | Sí | En parte 0,60 US$ por millón de creaciones | No 0,03–0,07 US$ pasados los inicios incluidos5 |
| Fork con memoria | Sí 3 copias en 0,25 s | Sí | En parte clase VM | En parte desde un snapshot de memoria, en alpha | No solo el sistema de archivos | No desde el último snapshot del disco |
| Plantillas propias | Sí guardadas desde un sandbox | Sí un constructor de plantillas | Sí desde una imagen o un Dockerfile | Sí imágenes | Sí imágenes, snapshots | Sí snapshots guardados |
| Lista de destinos permitidos | Sí dominios, IP, CIDR, puertos | Sí | En parte desde el nivel 36 | En parte beta, TLS en el puerto 443 | Sí | No |
| Claves de API fuera del sandbox | Sí las pone el proxy | Sí | No consta en las páginas que leímos | En parte en beta | Sí | En parte solo claves de IA, 1 US$ al día + 1 US$ por cada 1000 peticiones |
| SSH, scp, túneles | Sí | En parte a través de un proxy WebSocket | No consta en las páginas que leímos | No consta en las páginas que leímos | No solo su CLI | Sí |
| Escritorio para computer use | Sí Chrome, 1280×800 | Sí | Sí | No consta en las páginas que leímos | No consta en las páginas que leímos | Sí |
| Servidor MCP para sandboxes | Sí | En parte un gateway de herramientas dentro del sandbox | Sí | No consta en las páginas que leímos | No consta en las páginas que leímos | En parte solo de su documentación |
| SDK | Python, TypeScript, Go, Rust | Python, JS/TS | Python, TS, Ruby, Go, Java | Python, JS, Go | TypeScript | Python, TypeScript |
| Dónde | UE | EE. UU.; UE a petición | EE. UU., UE | regiones a 1,15–1,75× el precio | 19 regiones | UE |
| Factura mensual mínima | 20 US$, todo como uso | 0 US$ en Hobby | 0 US$ | 0 US$, con 30 US$ de crédito al mes | 0 US$ en Hobby | 20 US$, todo como uso |

Sí En parte No No consta en las páginas que leímos

1. Daytona ejecuta contenedores por defecto; su clase de VM Linux se pausa y admite forks.
2. Modal ejecuta los sandboxes en gVisor y ofrece una opción de runtime de VM.
3. Daytona cobra por una VM en pausa solo su disco; la memoria conservada no se cobra.
4. Los snapshots de memoria de Modal están en alpha y caducan 7 días después de crearse.
5. boat.dev incluye 12, 60 y 200 inicios por minuto, hora y día en su plan de 20 US$, vende más a entre 0,03 y 0,07 US$ cada uno, y rechaza a partir de 6 veces esa cantidad (3 veces por minuto).
6. Los niveles 1 y 2 de Daytona restringen el acceso a la red a servicios esenciales, y un sandbox no puede cambiarlo.

- E2B y Daytona no tienen mínimo mensual: allí un agente ligero cuesta menos que nuestro plan de 20 US$. Cuatro agentes así cuestan allí más que el plan.
- E2B no cobra nada por un sandbox en pausa, y Daytona solo su disco; el nuestro cuesta el 30 % del precio en ejecución y conserva su sitio en su servidor. A lo largo de un mes pesa más el precio en ejecución.

### Una hora de 2 vCPU y 4 GiB

- **Pethost**SMALL **0,018 US$**
- **boat.dev**small **0,018 US$**
- **Cloudflare Containers**2 vCPU · 4 GiB · 8 GB **0,052 US$** con un 10 % de CPU 0,182 US$ con un 100 % de CPU
- **Northflank** **0,0667 US$**
- **Vercel Sandbox** **0,1104 US$** con un 10 % de CPU 0,3408 US$ con un 100 % de CPU
- **E2B** **0,1656 US$**
- **Daytona** **0,1656 US$** más el disco por encima de 5 GiB
- **Blaxel** **0,1656 US$** mientras está activo
- **Modal** **0,2380 US$**
- **Runloop**MEDIUM **0,3195 US$**

Una hora en ejecución, 2 vCPU y 4 GiB, solo cómputo, al precio de lista de cada proveedor el 21 de noviembre de 2026.

### Dos cargas de trabajo, un mes

#### Un agente: un sandbox, 2 horas activo y 22 inactivo al día

| Proveedor | Mientras espera | Memoria conservada | Uso | Factura |
| --- | --- | --- | --- | --- |
| Pethost | en pausa | Sí | 4,64 US$ | **20 US$**el plan, que cubre unos cuatro agentes así |
| E2B | en pausa, gratis | Sí | 9,94 US$ | **9,94 US$**en Hobby, con una pausa cada hora; 159,94 US$ en Pro |
| Daytona | clase VM, en pausa | Sí | 10,17 US$ | **10,17 US$** |
| Blaxel | en espera | Sí | 11,74 US$ | **11,74 US$** |
| boat.dev | detenido | No | 1,08 US$ | **20 US$** |
| Modal | un snapshot, 24 h como máximo | No | 14,28 US$ | **0 US$**dentro del crédito mensual de 30 US$ |

Con la memoria conservada, el mes del agente cuesta aquí 4,64 US$, menos de la mitad que en E2B, Daytona o Blaxel. boat.dev cuesta menos si la memoria puede perderse. Para un solo agente, E2B y Daytona cobran menos que nuestro plan de 20 US$; a partir de cuatro agentes, el plan cuesta menos.

#### Evals: 1000 sandboxes al día, 60 segundos cada uno

| Proveedor | Cómputo | Cargos por inicio | Factura |
| --- | --- | --- | --- |
| Pethost | 9,00 US$ | 0 US$ | 20 US$ |
| boat.dev | 9,00 US$ | 144 US$ con su plan de 100 US$, o 1500 US$ con el de 20 US$ | 244 US$ |
| E2B | 82,80 US$ | 0 US$ | 82,80 US$ en Hobby |
| Daytona | 82,96 US$ | 0 US$ | 82,96 US$ |
| Modal | 118,98 US$ | 0 US$ | 88,98 US$ tras el crédito de 30 US$ |
| Vercel Sandbox | 55,22 US$ con un 10 % de CPU, 170,42 US$ con un 100 % de CPU | 0,02 US$ | 55,22 US$ con un 10 % de CPU, 170,42 US$ con un 100 % de CPU |

Los sandboxes cortos y numerosos cuestan menos aquí. En boat.dev, los cargos por inicio son la mayor parte de la factura.

Con el plan de 20 US$, 1000 inicios al día repartidos a lo largo del día (unos 42 por hora) caben en sus inicios gratis, y 10 sandboxes SMALL se ejecutan a la vez.

2 vCPU y 4 GiB en todos, un mes de 30 días, 5 GiB de datos propios del sandbox conservados mientras está inactivo. No se cuentan los créditos que se agotan; sí los que llegan cada mes.

### Cada inicio que boat.dev te deja comprar, gratis

boat.dev incluye algunos inicios en cada plan, vende más a entre 0,03 y 0,07 US$ cada uno y rechaza a partir de seis veces su cantidad incluida (tres veces por minuto). Nuestros planes cuestan lo mismo, y sus inicios son gratis hasta exactamente esas cantidades. Despertar un sandbox en pausa nunca es un inicio.

| Plan | boat.dev incluye | boat.dev vende hasta, y luego rechaza | Pethost, gratis |
| --- | --- | --- | --- |
| 20 US$ | 12 · 60 · 200 | 36 · 360 · 1200 | 36 · 360 · 1200 |
| 100 US$ | 30 · 210 · 840 | 90 · 1260 · 5040 | 90 · 1260 · 5040 |
| 500 US$ | 65 · 420 · 1680 | 195 · 2520 · 10.080 | 195 · 2520 · 10.080 |
| 2000 US$ | 90 · 600 · 2400 | 270 · 3600 · 14.400 | 270 · 3600 · 14.400 |

Inicios por minuto · por hora · por día.

## El precio del plan es tu uso

El precio mensual de cada plan vuelve entero como uso, a las tarifas de abajo. Por encima de él paga un saldo que recargas: de 10 a 1000 US$, y nunca caduca.

- **20 US$**al mes Uso incluido20 US$vCPU a la vez20cuentan los sandboxes en ejecución y en pausaTamaño máximoLARGEVolúmenes100 GiBPlantillas5 GiBInicios gratis36 · 360 · 1200por minuto · por hora · por día [Empezar la prueba gratis](https://console.pethost.dev/welcome?kind=sandboxes)
- **100 US$**al mes Uso incluido100 US$vCPU a la vez128cuentan los sandboxes en ejecución y en pausaTamaño máximoXLARGEVolúmenes600 GiBPlantillas30 GiBInicios gratis90 · 1260 · 5040por minuto · por hora · por día [Empezar la prueba gratis](https://console.pethost.dev/welcome?kind=sandboxes)
- **500 US$**al mes Uso incluido500 US$vCPU a la vez700cuentan los sandboxes en ejecución y en pausaTamaño máximoXLARGEVolúmenes3500 GiBPlantillas175 GiBInicios gratis195 · 2520 · 10.080por minuto · por hora · por día [Empezar la prueba gratis](https://console.pethost.dev/welcome?kind=sandboxes)
- **2000 US$**al mes Uso incluido2000 US$vCPU a la vez3000cuentan los sandboxes en ejecución y en pausaTamaño máximoXLARGEVolúmenes16.000 GiBPlantillas800 GiBInicios gratis270 · 3600 · 14.400por minuto · por hora · por día [Empezar la prueba gratis](https://console.pethost.dev/welcome?kind=sandboxes)

### Prueba gratis

7 días con 1 US$ de uso, 4 vCPU a la vez y tamaños hasta DEFAULT. Se pide una tarjeta, y el primer pago del plan llega cuando termina la prueba o cuando empiezas el plan.

vCPU a la vez4 Tamaño máximoDEFAULT Volúmenes10 GiB Inicios gratis15 · 75 · 225por minuto · por hora · por día

| Tamaño | En ejecución | En pausa |
| --- | --- | --- |
| SMALL2 vCPU · 4 GiB · 10 GiB | **0,018 US$** por hora | 0,0054 US$ por hora |
| DEFAULT4 vCPU · 8 GiB · 20 GiB | **0,036 US$** por hora | 0,0108 US$ por hora |
| LARGE8 vCPU · 16 GiB · 40 GiB | **0,072 US$** por hora | 0,0216 US$ por hora |
| XLARGE16 vCPU · 32 GiB · 80 GiB | **0,144 US$** por hora | 0,0432 US$ por hora |

- Detenido: 0,03 US$ por GiB al mes de los datos propios del sandbox, nunca del espacio vacío.
- Volúmenes: 0,20 US$ por GiB al mes de su tamaño.
- Plantillas: gratis, dentro del espacio del plan.
- 20 US$ de uso son 1111 horas de un sandbox SMALL en ejecución, o 3704 horas en pausa.

Precios en dólares estadounidenses, sin impuestos. En la UE pagas las mismas cifras en euros, más IVA.

## Preguntas

**¿Cómo se separa un sandbox de otro?**

Cada sandbox es su propia microVM Firecracker, con su propio kernel Linux, iniciada dentro del jailer de Firecracker: su propio chroot, un usuario sin privilegios, límites de cgroup, un filtro seccomp y su propio network namespace. Dentro eres root. La virtualización anidada está desactivada, y las claves de API vinculadas como secretos nunca entran en la VM.

**¿Las vCPU y la memoria se comparten con otros sandboxes?**

El hardware se comparte, como en cualquier nube de este rango de precios: muchos sandboxes se ejecutan en un mismo servidor, y cada uno se limita a su tamaño, nunca más que el tiempo de sus vCPU y su memoria. Un vecino ocupado puede frenar la CPU de un sandbox, y un servidor con poca memoria pausa antes de tiempo los sandboxes que llevan un minuto o más inactivos, que la siguiente llamada despierta como siempre.

**¿Dónde se ejecutan los sandboxes y dónde están mis datos?**

En la UE. Los sandboxes se ejecutan en nuestros servidores de la UE, y el disco de un sandbox detenido y tus plantillas se guardan en almacenamiento de objetos en la UE, cifrados, cada uno con su propia clave. Hay una sola región, así que no hay nada que elegir. La [política de privacidad](https://pethost.dev/privacy/) dice quién trata qué datos.

**¿Qué pasa cuando mi agente se queda callado?**

Tras 5 minutos sin llamadas, sesiones SSH ni peticiones web, el sandbox se pausa: la memoria y los procesos se conservan al 30 % del precio en ejecución, y la siguiente llamada lo despierta en unos 0,1 s. A los 30 minutos se detiene: su disco pasa al almacenamiento de objetos a 0,03 US$ por GiB al mes, y sus procesos terminan. No se elimina nada salvo que configures un temporizador para ello. Un comando iniciado con `keep_awake` lo mantiene despierto.

**¿Hay GPU?**

No. El tamaño más grande tiene 16 vCPU, 32 GiB de memoria y 80 GiB de disco.

**¿Cuáles son los límites?**

Un plan fija cuántas vCPU tienen a la vez sus sandboxes en ejecución y en pausa (20 en el plan de 20 US$, es decir, 10 sandboxes SMALL), su tamaño máximo y sus inicios gratis por minuto, por hora y por día. Los sandboxes detenidos no tienen límite de cantidad, y ningún sandbox tiene límite de cuánto tiempo vive. Un fork hace hasta 100 copias en una llamada, tantas como quepan en el servidor de su sandbox, y un sandbox abre hasta 20 puertos públicos.

**¿Cómo funciona la facturación?**

El precio mensual de un plan es uso que incluye. Un sandbox en ejecución se factura por segundo al precio de su tamaño, cada ejecución redondeada al segundo, con 10 s como mínimo; uno en pausa, al 30 % de eso; uno detenido, por los GiB que ocupan sus propios datos. Crear, copiar e iniciar no cuestan nada. El uso por encima del plan se paga con un saldo que recargas, de 10 a 1000 US$, que nunca caduca.

Si se agotan los dos, los sandboxes en ejecución y en pausa se detienen y no se inicia nada nuevo hasta que entre dinero; no se elimina nada.

**¿En qué se diferencia de E2B?**

Los dos ejecutan cada sandbox en una microVM Firecracker, y los dos conservan la memoria y los procesos cuando un sandbox se pausa. 2 vCPU y 4 GiB en ejecución cuestan 0,018 US$ la hora aquí y 0,1656 US$ en E2B, que no cobra nada en pausa, donde nosotros cobramos el 30 %. E2B tiene un plan Hobby gratis con un crédito único de 100 US$; nuestros planes empiezan en 20 US$ al mes, todo como uso. Aquí los sandboxes tienen SSH normal y se ejecutan en la UE; E2B se ejecuta en EE. UU. salvo que pidas su clúster de la UE. Las cifras de E2B son de sus propias páginas, del 21 de noviembre de 2026.

**¿Hay una prueba gratis?**

Sí: 7 días con 1 US$ de uso, 4 vCPU a la vez y tamaños hasta DEFAULT, es decir, 55 horas de un sandbox SMALL en ejecución. Se pide una tarjeta, y el primer pago del plan llega cuando termina la prueba.

## Dale a tu agente una VM en 0,15 s

[Empezar la prueba gratis](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Plantillas](https://pethost.dev/es/templates/)
- [Sobre nosotros](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/es/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Términos](https://pethost.dev/terms/)
- [Privacidad](https://pethost.dev/privacy/)
- [Reembolsos](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bases de datos

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

Agent Sandboxes

- [Sandboxes](https://pethost.dev/es/sandboxes/)
- [Precios](https://pethost.dev/es/sandboxes/#pricing)
- [Docs](https://pethost.dev/es/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Comparativas

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/es/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/es/blog/coolify-cloud-vs-dokploy-cloud/)
- [Precios de Railway vs Render vs Fly.io](https://pethost.dev/es/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hosting gestionado para Docker Compose](https://pethost.dev/es/blog/managed-docker-compose-hosting/)

Alternativas

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