---
title: "Sandboxes für KI-Agenten: Firecracker-MicroVMs · Pethost"
description: "Firecracker-MicroVMs für KI-Agenten: Start in etwa 0,15 s, Pause mit RAM, während der Agent denkt, Aufwachen in 0,1 s. 2 vCPU für 0,018 $/h, sekundengenau abgerechnet."
---

Pethost Agent Sandboxes

# Cloud-VMs für KI-Agenten, pausiert, während sie denken

Jede Sandbox ist eine Firecracker-MicroVM mit eigenem Kernel, und darin bist du root. Sie startet in etwa 0,15 s, pausiert im Leerlauf mit RAM und Prozessen und wacht beim nächsten Aufruf in etwa 0,1 s auf, genau dort, wo sie war; auch ein SSH-Login oder ein Web-Request weckt sie.

Ab **0,018 $** pro Stunde für 2 vCPU und 4 GiB, sekundengenau abgerechnet. Pausiert 30 % davon. Der Start kostet nichts.

[Kostenlose Testphase starten](https://console.pethost.dev/welcome?kind=sandboxes) [Doku lesen](https://pethost.dev/de/docs/sandboxes/)

7 Tage mit 1 $ Verbrauch. Eine Karte ist nötig, und die erste Zahlung für den Tarif kommt, wenn die Testphase endet.

Zwölf Sandboxes eines Workspace: drei laufen, sieben sind mit ihrem RAM pausiert, zwei gestoppt. Zusammen kosten sie etwa 0,09 $ pro Stunde.

- **~0,15 s** zum Start einer Sandbox aus einer Vorlage
- **~0,1 s** zum Wecken einer pausierten, RAM und Prozesse wie zuvor
- **0,018 $/h** für 2 vCPU, 4 GiB und 10 GiB, solange sie läuft
- **1 s** Abrechnungsschritt: jeder Lauf auf eine Sekunde aufgerundet, mindestens 10 s
- **0 $** für Erstellen, Forken oder Starten einer Sandbox

Gemessen auf unseren Servern am 18. November 2026, über eine API in 16 ms Entfernung: Erstellen im Median 123 ms (SMALL) bis 158 ms (XLARGE), Fortsetzen 124 ms, ein Befehl an eine pausierte Sandbox 80 ms.

## Was Teams darauf laufen lassen

- [**Code, den dein Modell schreibt** Ein KI-Produkt führt den Code jeder Person in einer eigenen Sandbox aus: Befehl und Ausgabe in einem Aufruf, Dateien direkt bearbeitet, ein Port unter eigener Adresse.](https://pethost.dev/de/sandboxes/code-execution/)
- [**Coding-Agenten in der Cloud** Claude Code, Codex und OpenCode sind in jeder Sandbox installiert. Ein Aufruf gibt einem Agenten einen Prompt, ein anderer streamt jeden Tool-Aufruf, den er macht.](https://pethost.dev/de/sandboxes/coding-agents/)
- [**RL und Evals** Forke eine vorbereitete Umgebung samt RAM mit einem Aufruf: Drei Kopien dauern etwa 0,25 s. Starte tausend Läufe am Tag ohne Startgebühr.](https://pethost.dev/de/sandboxes/fork/)
- [**Computer Use** Chrome auf einem Desktop mit 1280×800 in jeder Sandbox: klicken, tippen und einen Screenshot machen in einem Aufruf, oder live zusehen.](https://pethost.dev/de/sandboxes/computer-use/)

## Drei Zustände, drei Preise

Die VM eines Agenten wartet meistens, während der Agent denkt. Ihre Prozesse sollen dabei nicht enden, also pausiert sie mit ihrem RAM zu 30 % des Preises und wacht beim nächsten Aufruf auf.

Eine Sandbox geht nach 5 min Leerlauf von laufend zu pausiert und nach 30 min zu gestoppt; der nächste Aufruf weckt eine pausierte in 0,1 s.

- Im RAM Arbeitet und wird sekundengenau zum Preis ihrer Größe abgerechnet: 0,018 $ pro Stunde für 2 vCPU und 4 GiB. Jeder Lauf wird auf eine Sekunde aufgerundet, mindestens 10 s. **0,018 $ pro Stunde**
- Auf der Disk ihres Servers RAM, Prozesse und Disk bleiben erhalten, zu 30 % des Preises im Betrieb. Der nächste Aufruf weckt sie in etwa 0,1 s (ein Web-Request in etwa 0,2 s), und ein Aufwachen wird nie aus Platzmangel abgelehnt. **0,0054 $ pro Stunde**
- Im Objektspeicher Ihre Disk bleibt verschlüsselt erhalten, für 0,03 $ pro GiB und Monat ihrer eigenen Daten; ihre Prozesse enden. Fortsetzen bootet sie in etwa 0,2 s von ihrer Disk, oder in etwa 10 s pro GiB, wenn die Disk erst zurückgeholt werden muss. **0,03 $ pro GiB und Monat**

Standardmäßig pausiert eine Sandbox nach 5 min Leerlauf, stoppt nach 30 min und wird nie gelöscht. Jeder Timer wird pro Sandbox eingestellt, und 0 schaltet ihn ab.

## Alles, was der Computer eines Agenten kann

Fünfzehn Dinge, die eine Sandbox kann, jedes mit einer Seite dazu, wie es funktioniert.

- [Drei Sandboxes auf einem Server, jede eine MicroVM mit eigenem Kernel und eigener Root-Shell; eine vierte startet in 0,12 s. Eine MicroVM pro Sandbox Jede Sandbox ist eine Firecracker-MicroVM mit eigenem Linux-Kernel, Root-Zugriff und eigenem Netzwerk, in etwa 0,15 s aus einem Snapshot gestartet. So funktioniert es](https://pethost.dev/de/sandboxes/firecracker-microvm/)
- [Eine Sandbox pausiert: Ihr RAM wandert auf die Disk ihres Servers, und ihr Preis sinkt auf 30 %; ein Request kommt, und sie wacht in 0,08 s auf, derselbe Prozess läuft noch. Pausiert mit ihrem RAM Eine pausierte Sandbox behält RAM und Prozesse auf ihrem Server zu 30 % des Preises, und der nächste Aufruf weckt sie in etwa 0,1 s, genau dort, wo sie war. So funktioniert es](https://pethost.dev/de/sandboxes/pause-resume/)
- [Eine Zeitleiste des Leerlaufs: Nach 5 Minuten pausiert die Sandbox für 0,0054 $ pro Stunde, nach 30 Minuten stoppt sie in den Objektspeicher für 0,03 $ pro GiB und Monat. Pausiert im Leerlauf von selbst Fünf Minuten ohne Aufruf, und eine Sandbox pausiert; nach dreißig stoppt sie in den Objektspeicher. Jeder Timer gilt pro Sandbox, und 0 schaltet ihn ab. So funktioniert es](https://pethost.dev/de/sandboxes/auto-pause/)
- [Eine laufende Sandbox bei Schritt 41 einer Aufgabe wird in 0,25 s in drei Kopien geforkt; jede macht ab Schritt 41 für sich weiter. Fork samt RAM Kopier eine laufende Sandbox mit RAM, Prozessen und Disk in einem Aufruf in neue Sandboxes. Drei Kopien dauern etwa eine Viertelsekunde. So funktioniert es](https://pethost.dev/de/sandboxes/fork/)
- [Zwei Spuren aus Sekunden: ein Lauf von 37 Sekunden zu 0,000005 $ pro Sekunde, auf die ganze Sekunde aufgerundet, dann pausierte Sekunden zu 30 %; das Erstellen kostete 0 $. Sekundengenau abgerechnet Laufzeit wird pro Sekunde zum Preis der Größe abgerechnet, ab 0,018 $ pro Stunde; pausiert zu 30 %; gestoppt pro GiB Daten. Erstellen, Forken und Starten kosten nichts. So funktioniert es](https://pethost.dev/de/sandboxes/per-second-billing/)
- [Ein Programm ruft run_command auf, und die Testausgabe streamt zurück; es bearbeitet eine Datei direkt; es startet einen Dev-Server, und der Aufruf antwortet, sobald Port 5173 lauscht. Befehle, Dateien und ein Terminal Führ einen Befehl aus und warte auf seinen Port, streame seine Ausgabe, bearbeite Dateien per exaktem Ersetzen, öffne ein Terminal im Browser: je ein API-Aufruf. So funktioniert es](https://pethost.dev/de/sandboxes/code-execution/)
- [Ein Prompt an einen Coding-Agenten in einer Sandbox, und seine Tool-Aufrufe streamen zurück: Er liest eine Datei, bearbeitet sie, führt die Tests aus, und der Turn endet fertig mit seiner Token-Zahl. Coding-Agenten, schon installiert Claude Code, Codex und OpenCode laufen in jeder Sandbox mit voller Autonomie: Ein Aufruf gibt einem einen Prompt, ein anderer streamt jeden Tool-Aufruf, den er macht. So funktioniert es](https://pethost.dev/de/sandboxes/coding-agents/)
- [Ein Desktop mit Chrome in einer Sandbox: Der Mauszeiger klickt in ein Feld, tippt eine Adresse, drückt Enter, und ein Screenshot mit 1280×800 kommt zurück. Ein Desktop mit Chrome Jede Sandbox hat einen Bildschirm mit 1280×800 und Chrome, gestartet bei der ersten Nutzung: klicken, tippen und Screenshot in einem Aufruf, oder live zusehen. So funktioniert es](https://pethost.dev/de/sandboxes/computer-use/)
- [Ein ssh-Befehl an eine pausierte Sandbox auf Port 2222 weckt sie und öffnet eine Shell; dann geht eine Datei mit scp hinüber, und ein Port wird mit ssh -L weitergeleitet. Einfaches SSH, scp und Tunnel ssh, scp, sftp und ssh -L in jede Sandbox, mit einem Key des Workspace oder einem Token als Passwort; ein Login weckt eine pausierte. So funktioniert es](https://pethost.dev/de/sandboxes/ssh/)
- [Ein Besuch der HTTPS-Adresse von Port 3000 weckt eine pausierte Sandbox in 0,2 s, und ihre Seite erscheint; ein privater Port antwortet 200 auf einen Request mit seinem Token und 401 auf einen ohne. Eine URL für jeden Port Ein Dev-Server auf Port 3000 antwortet unter einer eigenen HTTPS-Adresse, öffentlich oder hinter einem Token, und ein Besuch weckt eine pausierte Sandbox in etwa 0,2 s. So funktioniert es](https://pethost.dev/de/sandboxes/preview-urls/)
- [Eine Sandbox mit ihren Paketen und Docker-Images wird in 1,2 s als Vorlage my-app@3 gespeichert, und drei neue Sandboxes starten daraus auf zwei Servern. Eine Sandbox als Vorlage speichern Speichere die Disk einer Sandbox samt Paketen und Docker-Images als Version einer Vorlage, und starte neue Sandboxes daraus auf jedem Server. So funktioniert es](https://pethost.dev/de/sandboxes/templates/)
- [Ein Volume mit 50 GiB auf einem Server: Eine Sandbox schreibt unter /data Dateien darauf und wird gelöscht; Volume und Dateien bleiben, und zwei neue Sandboxes mounten es nur lesbar. Volumes, die Sandboxes überdauern Mounte ein Volume unter einem Pfad: mit Schreibzugriff in einer Sandbox oder nur lesbar in beliebig vielen. Es bleibt, wenn sie gelöscht werden, auf der Disk seines Servers. So funktioniert es](https://pethost.dev/de/sandboxes/volumes/)
- [Die Verbindungen einer Sandbox passieren ein Tor, das pypi.org und *.github.com erlaubt und example.com mit 403 ablehnt; eine DNS-Frage nach einem Namen, der nicht auf der Liste steht, bekommt REFUSED, und UDP geht nicht hinaus. Egress nur zu erlaubten Namen Führ die Domains, Wildcards, IPs und CIDRs auf, die eine Sandbox erreichen darf; ihr DNS beantwortet nichts anderes, kein UDP geht hinaus, und eine Änderung gilt sofort. So funktioniert es](https://pethost.dev/de/sandboxes/egress-allowlist/)
- [In der Sandbox ist der API-Key ein Platzhalter; der Egress-Proxy setzt den echten Key in den Request an api.anthropic.com ein, und ein Request an einen anderen Host behält den Platzhalter. Keys, die nie hineinkommen Eine Sandbox sieht einen Platzhalter; der Egress-Proxy setzt den echten API-Key in die Header von HTTPS-Requests ein, nur für die Hosts, die du nennst. So funktioniert es](https://pethost.dev/de/sandboxes/secrets/)
- [Das Dashboard einer Sandbox: eine CPU-Linie, belegter RAM und ein Strom von Events: erstellt, ein Befehl mit Exit-Code 0, die erreichten Hosts, ein Agent-Turn mit seinen Tokens, pausiert. Jeder Befehl, Host und Turn CPU, RAM, Disk und Netzwerk für 24 h; jede Änderung im Lebenszyklus, jeder Befehl, jeder erreichte Host und jeder Agent-Turn, als Liste oder als Live-Stream. So funktioniert es](https://pethost.dev/de/sandboxes/observability/)

## Für deinen Agenten, deinen Code und dein Terminal

Alle drei steuern Sandboxes über dieselbe API und brauchen nur dein Pethost-Token: Den Server, auf dem eine Sandbox läuft, und die Anmeldung dort erledigen sie für dich.

- **MCP-Server** Füg ihn zu Claude, ChatGPT, Cursor oder einem anderen MCP-Client hinzu. Er meldet sich mit deinem Pethost-Konto an, und dein Agent erstellt, startet, forkt und pausiert damit Sandboxes. `https://mcp.pethost.dev/sandboxes`Kopieren
- **SDKs** Python, TypeScript, Go und Rust, aus der API generiert, jedes mit denselben Methoden.
- **CLI** `pethost sandbox` erstellt, öffnet und forkt Sandboxes und führt Befehle darin aus, direkt aus deinem Terminal.

Python

TypeScript

Go

Rust

CLI

Installieren `pip install pethost`

```
from pethost.sandboxes import Sandboxes

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

Installieren `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
```

Installieren `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
```

Installieren `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
```

Installieren `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  # eine Shell darin
```

## Im Vergleich

Preise und Funktionen, wie sie am 21. November 2026 auf den eigenen Seiten der Anbieter standen, für 2 vCPU und 4 GiB.

### Was jeder Anbieter kann

|  | Pethost | E2B | Daytona | Modal | Vercel Sandbox | boat.dev |
| --- | --- | --- | --- | --- | --- | --- |
| Isolation | Ja Firecracker-MicroVM | Ja Firecracker | Teilweise Container; eine Linux-VM-Klasse1 | Teilweise gVisor; VM-Runtime als Option2 | Ja Firecracker | Ja eine VM pro Sandbox |
| Laufend, 2 vCPU · 4 GiB, pro Stunde | 0,018 $ | 0,1656 $ | 0,1656 $ plus Disk über 5 GiB | 0,2380 $ | 0,1104 $ bei 10 % CPU, 0,3408 $ bei 100 % CPU | 0,018 $ |
| Pause behält RAM und Prozesse | Ja 30 % des Preises im Betrieb | Ja kostenlos, solange pausiert | Teilweise nur VM-Klasse, Disk wird berechnet3 | Teilweise RAM-Snapshots in Alpha, 7 Tage aufbewahrt4 | Nein nur das Dateisystem | Nein „Es gibt keine Pause“ |
| Keine Startgebühr | Ja innerhalb der Grenzen des Tarifs | Ja | Ja | Ja | Teilweise 0,60 $ pro Million Erstellungen | Nein 0,03–0,07 $ über die enthaltenen Starts hinaus5 |
| Fork mit RAM | Ja 3 Kopien in 0,25 s | Ja | Teilweise VM-Klasse | Teilweise aus einem RAM-Snapshot, in Alpha | Nein nur das Dateisystem | Nein aus dem letzten Disk-Snapshot |
| Eigene Vorlagen | Ja aus einer Sandbox gespeichert | Ja ein Vorlagen-Builder | Ja aus einem Image oder Dockerfile | Ja Images | Ja Images, Snapshots | Ja gespeicherte Snapshots |
| Egress-Allowlist | Ja Domains, IPs, CIDRs, Ports | Ja | Teilweise ab Tier 36 | Teilweise Beta, TLS auf Port 443 | Ja | Nein |
| API-Keys bleiben außerhalb der Sandbox | Ja vom Proxy eingesetzt | Ja | Nicht auf den Seiten angegeben, die wir gelesen haben | Teilweise Beta | Ja | Teilweise nur KI-Keys, 1 $ am Tag + 1 $ pro 1.000 Requests |
| SSH, scp, Tunnel | Ja | Teilweise über einen WebSocket-Proxy | Nicht auf den Seiten angegeben, die wir gelesen haben | Nicht auf den Seiten angegeben, die wir gelesen haben | Nein nur über die eigene CLI | Ja |
| Desktop für Computer Use | Ja Chrome, 1280×800 | Ja | Ja | Nicht auf den Seiten angegeben, die wir gelesen haben | Nicht auf den Seiten angegeben, die wir gelesen haben | Ja |
| MCP-Server für Sandboxes | Ja | Teilweise ein Tool-Gateway in der Sandbox | Ja | Nicht auf den Seiten angegeben, die wir gelesen haben | Nicht auf den Seiten angegeben, die wir gelesen haben | Teilweise nur für die eigene Doku |
| SDKs | Python, TypeScript, Go, Rust | Python, JS/TS | Python, TS, Ruby, Go, Java | Python, JS, Go | TypeScript | Python, TypeScript |
| Wo | EU | USA; EU auf Anfrage | USA, EU | Regionen zum 1,15- bis 1,75-fachen Preis | 19 Regionen | EU |
| Kleinste Monatsrechnung | 20 $, komplett als Verbrauch | 0 $ bei Hobby | 0 $ | 0 $, mit 30 $ Guthaben im Monat | 0 $ bei Hobby | 20 $, komplett als Verbrauch |

Ja Teilweise Nein Nicht auf den Seiten angegeben, die wir gelesen haben

1. Daytona führt standardmäßig Container aus; seine Linux-VM-Klasse pausiert und forkt.
2. Modal führt Sandboxes in gVisor aus und bietet eine VM-Runtime als Option.
3. Daytona berechnet für eine pausierte VM nur ihre Disk; der behaltene RAM kostet nichts.
4. Die RAM-Snapshots von Modal sind in Alpha und verfallen 7 Tage nach ihrer Erstellung.
5. boat.dev enthält im Tarif für 20 $ 12, 60 und 200 Starts pro Minute, Stunde und Tag, verkauft weitere für 0,03 bis 0,07 $ pro Start und lehnt ab dem Sechsfachen ab (pro Minute ab dem Dreifachen).
6. Bei Daytona beschränken die Tiers 1 und 2 den Netzwerkzugang auf grundlegende Dienste, und eine Sandbox kann das nicht ändern.

- E2B und Daytona haben kein monatliches Minimum: Ein einzelner sparsamer Agent kostet dort weniger als unser Tarif für 20 $. Vier solche Agenten kosten dort mehr als der Tarif.
- E2B berechnet für eine pausierte Sandbox nichts, Daytona nur ihre Disk; unsere kostet 30 % des Preises im Betrieb und behält ihren Platz auf ihrem Server. Über einen Monat wiegt der Preis im Betrieb schwerer.

### Eine Stunde mit 2 vCPU und 4 GiB

- **Pethost**SMALL **0,018 $**
- **boat.dev**small **0,018 $**
- **Cloudflare Containers**2 vCPU · 4 GiB · 8 GB **0,052 $** bei 10 % CPU 0,182 $ bei 100 % CPU
- **Northflank** **0,0667 $**
- **Vercel Sandbox** **0,1104 $** bei 10 % CPU 0,3408 $ bei 100 % CPU
- **E2B** **0,1656 $**
- **Daytona** **0,1656 $** plus Disk über 5 GiB
- **Blaxel** **0,1656 $** solange aktiv
- **Modal** **0,2380 $**
- **Runloop**MEDIUM **0,3195 $**

Eine Stunde im Betrieb, 2 vCPU und 4 GiB, nur Rechenleistung, zum Listenpreis jedes Anbieters am 21. November 2026.

### Zwei Workloads, ein Monat

#### Ein Agent: eine Sandbox, täglich 2 Stunden aktiv und 22 im Leerlauf

| Anbieter | Im Leerlauf | RAM erhalten | Verbrauch | Rechnung |
| --- | --- | --- | --- | --- |
| Pethost | pausiert | Ja | 4,64 $ | **20 $**der Tarif, der etwa vier solche Agenten abdeckt |
| E2B | pausiert, kostenlos | Ja | 9,94 $ | **9,94 $**bei Hobby, mit einer Pause jede Stunde; 159,94 $ bei Pro |
| Daytona | VM-Klasse, pausiert | Ja | 10,17 $ | **10,17 $** |
| Blaxel | Standby | Ja | 11,74 $ | **11,74 $** |
| boat.dev | gestoppt | Nein | 1,08 $ | **20 $** |
| Modal | ein Snapshot, höchstens 24 h | Nein | 14,28 $ | **0 $**innerhalb des monatlichen Guthabens von 30 $ |

Mit erhaltenem RAM kostet der Monat des Agenten hier 4,64 $, weniger als die Hälfte von E2B, Daytona oder Blaxel. boat.dev kostet weniger, wenn der RAM verloren gehen darf. Für einen einzelnen Agenten berechnen E2B und Daytona weniger als unser Tarif für 20 $; ab vier Agenten ist der Tarif günstiger.

#### Evals: 1.000 Sandboxes am Tag, je 60 s

| Anbieter | Rechenleistung | Startgebühren | Rechnung |
| --- | --- | --- | --- |
| Pethost | 9,00 $ | 0 $ | 20 $ |
| boat.dev | 9,00 $ | 144 $ im Tarif für 100 $, oder 1.500 $ im Tarif für 20 $ | 244 $ |
| E2B | 82,80 $ | 0 $ | 82,80 $ bei Hobby |
| Daytona | 82,96 $ | 0 $ | 82,96 $ |
| Modal | 118,98 $ | 0 $ | 88,98 $ nach dem Guthaben von 30 $ |
| Vercel Sandbox | 55,22 $ bei 10 % CPU, 170,42 $ bei 100 % CPU | 0,02 $ | 55,22 $ bei 10 % CPU, 170,42 $ bei 100 % CPU |

Kurze, zahlreiche Sandboxes kosten hier am wenigsten. Bei boat.dev machen die Startgebühren den Großteil der Rechnung aus.

Im Tarif für 20 $ liegen 1.000 Starts am Tag, über den Tag verteilt (etwa 42 pro Stunde), innerhalb der kostenlosen Starts, und 10 SMALL-Sandboxes laufen gleichzeitig.

Überall 2 vCPU und 4 GiB, ein Monat mit 30 Tagen, 5 GiB eigene Daten der Sandbox, die im Leerlauf erhalten bleiben. Einmaliges Guthaben zählt nicht, monatliches schon.

### Jeder Start, den boat.dev dich kaufen lässt, kostenlos

boat.dev enthält in jedem Tarif einige Starts, verkauft weitere für 0,03 bis 0,07 $ pro Start und lehnt ab dem Sechsfachen der enthaltenen ab (pro Minute ab dem Dreifachen). Unsere Tarife kosten dasselbe, und ihre Starts sind bis genau zu diesen Zahlen kostenlos. Eine pausierte Sandbox zu wecken ist nie ein Start.

| Tarif | boat.dev enthält | boat.dev verkauft bis, dann Ablehnung | Pethost, kostenlos |
| --- | --- | --- | --- |
| 20 $ | 12 · 60 · 200 | 36 · 360 · 1.200 | 36 · 360 · 1.200 |
| 100 $ | 30 · 210 · 840 | 90 · 1.260 · 5.040 | 90 · 1.260 · 5.040 |
| 500 $ | 65 · 420 · 1.680 | 195 · 2.520 · 10.080 | 195 · 2.520 · 10.080 |
| 2.000 $ | 90 · 600 · 2.400 | 270 · 3.600 · 14.400 | 270 · 3.600 · 14.400 |

Starts pro Minute · Stunde · Tag.

## Der Preis des Tarifs ist dein Verbrauch

Der Monatspreis jedes Tarifs kommt vollständig als Verbrauch zu den Preisen unten zurück. Darüber hinaus zahlt ein Guthaben, das du auflädst: von 10 bis 1.000 $, und es verfällt nie.

- **20 $**im Monat Enthaltener Verbrauch20 $vCPUs gleichzeitig20laufende und pausierte Sandboxes zählenMaximale GrößeLARGEVolumes100 GiBVorlagen5 GiBKostenlose Starts36 · 360 · 1.200pro Minute · Stunde · Tag [Kostenlose Testphase starten](https://console.pethost.dev/welcome?kind=sandboxes)
- **100 $**im Monat Enthaltener Verbrauch100 $vCPUs gleichzeitig128laufende und pausierte Sandboxes zählenMaximale GrößeXLARGEVolumes600 GiBVorlagen30 GiBKostenlose Starts90 · 1.260 · 5.040pro Minute · Stunde · Tag [Kostenlose Testphase starten](https://console.pethost.dev/welcome?kind=sandboxes)
- **500 $**im Monat Enthaltener Verbrauch500 $vCPUs gleichzeitig700laufende und pausierte Sandboxes zählenMaximale GrößeXLARGEVolumes3.500 GiBVorlagen175 GiBKostenlose Starts195 · 2.520 · 10.080pro Minute · Stunde · Tag [Kostenlose Testphase starten](https://console.pethost.dev/welcome?kind=sandboxes)
- **2.000 $**im Monat Enthaltener Verbrauch2.000 $vCPUs gleichzeitig3.000laufende und pausierte Sandboxes zählenMaximale GrößeXLARGEVolumes16.000 GiBVorlagen800 GiBKostenlose Starts270 · 3.600 · 14.400pro Minute · Stunde · Tag [Kostenlose Testphase starten](https://console.pethost.dev/welcome?kind=sandboxes)

### Kostenlose Testphase

7 Tage mit 1 $ Verbrauch, 4 vCPUs gleichzeitig und Größen bis DEFAULT. Eine Karte ist nötig, und die erste Zahlung für den Tarif kommt, wenn die Testphase endet oder wenn du den Tarif startest.

vCPUs gleichzeitig4 Maximale GrößeDEFAULT Volumes10 GiB Kostenlose Starts15 · 75 · 225pro Minute · Stunde · Tag

| Größe | Laufend | Pausiert |
| --- | --- | --- |
| SMALL2 vCPU · 4 GiB · 10 GiB | **0,018 $** pro Stunde | 0,0054 $ pro Stunde |
| DEFAULT4 vCPU · 8 GiB · 20 GiB | **0,036 $** pro Stunde | 0,0108 $ pro Stunde |
| LARGE8 vCPU · 16 GiB · 40 GiB | **0,072 $** pro Stunde | 0,0216 $ pro Stunde |
| XLARGE16 vCPU · 32 GiB · 80 GiB | **0,144 $** pro Stunde | 0,0432 $ pro Stunde |

- Gestoppt: 0,03 $ pro GiB und Monat der eigenen Daten der Sandbox, nie für leeren Platz.
- Volumes: 0,20 $ pro GiB und Monat ihrer Größe.
- Vorlagen: kostenlos, im Rahmen des Tarifs.
- 20 $ Verbrauch sind 1.111 Stunden einer laufenden SMALL-Sandbox oder 3.704 Stunden einer pausierten.

Preise in US-Dollar, ohne Steuern. In der EU zahlst du dieselben Zahlen in Euro, zzgl. MwSt.

## Fragen

**Wie ist eine Sandbox von der anderen getrennt?**

Jede Sandbox ist eine eigene Firecracker-MicroVM mit eigenem Linux-Kernel, gestartet im Jailer von Firecracker: eigenes chroot, ein unprivilegierter Benutzer, cgroup-Limits, ein seccomp-Filter und ein eigener Network-Namespace. Darin bist du root. Verschachtelte Virtualisierung ist aus, und API-Keys, die als Secrets gebunden sind, kommen nie in die VM.

**Teilen sich Sandboxes vCPUs und RAM?**

Die Hardware wird geteilt, wie bei jeder Cloud in dieser Preisklasse: Viele Sandboxes laufen auf einem Server, und jede ist auf ihre Größe begrenzt, nie mehr als die Zeit ihrer vCPUs und ihren RAM. Ein beschäftigter Nachbar kann die CPU einer Sandbox bremsen, und ein Server, dem der RAM knapp wird, pausiert Sandboxes früher, die eine Minute oder länger im Leerlauf sind; der nächste Aufruf weckt sie wie immer.

**Wo laufen Sandboxes, und wo liegen meine Daten?**

In der EU. Sandboxes laufen auf unseren Servern in der EU, und die Disk einer gestoppten Sandbox und deine Vorlagen liegen verschlüsselt in einem Objektspeicher in der EU, jede mit eigenem Schlüssel. Es gibt eine Region, also nichts auszuwählen. Die [Datenschutzerklärung](https://pethost.dev/privacy/) nennt, wer was verarbeitet.

**Was passiert, wenn mein Agent still wird?**

Nach 5 min ohne Aufruf, SSH-Sitzung oder Web-Request pausiert die Sandbox: RAM und Prozesse bleiben zu 30 % des Preises im Betrieb erhalten, und der nächste Aufruf weckt sie in etwa 0,1 s. Nach 30 min stoppt sie: Ihre Disk geht für 0,03 $ pro GiB und Monat in den Objektspeicher, und ihre Prozesse enden. Gelöscht wird nichts, außer du stellst einen Timer dafür ein. Ein Befehl, der mit `keep_awake` gestartet wurde, hält sie wach.

**Gibt es GPUs?**

Nein. Die größte Größe hat 16 vCPU, 32 GiB RAM und 80 GiB Disk.

**Welche Limits gibt es?**

Ein Tarif legt fest, wie viele vCPUs seine laufenden und pausierten Sandboxes gleichzeitig haben (20 im Tarif für 20 $, also 10 SMALL-Sandboxes), seine maximale Größe und seine kostenlosen Starts pro Minute, Stunde und Tag. Für gestoppte Sandboxes gibt es keine Höchstzahl, und keine Sandbox hat ein Limit, wie lange sie lebt. Ein Fork macht bis zu 100 Kopien in einem Aufruf, so viele, wie der Server der Sandbox Platz hat, und eine Sandbox öffnet bis zu 20 öffentliche Ports.

**Wie funktioniert die Abrechnung?**

Der Monatspreis eines Tarifs ist enthaltener Verbrauch. Eine laufende Sandbox wird sekundengenau zum Preis ihrer Größe abgerechnet, jeder Lauf auf eine Sekunde aufgerundet, mindestens 10 s; eine pausierte zu 30 % davon; eine gestoppte nach den GiB, die ihre eigenen Daten belegen. Erstellen, Forken und Starten kosten nichts. Verbrauch über den Tarif hinaus zahlt ein Guthaben, das du auflädst, von 10 bis 1.000 $, und das nie verfällt.

Sind beide aufgebraucht, werden laufende und pausierte Sandboxes gestoppt, und nichts Neues startet, bis Geld eingeht; gelöscht wird nichts.

**Was ist anders als bei E2B?**

Beide führen jede Sandbox in einer Firecracker-MicroVM aus, und beide behalten RAM und Prozesse, wenn eine Sandbox pausiert. 2 vCPU und 4 GiB kosten im Betrieb hier 0,018 $ pro Stunde und bei E2B 0,1656 $; E2B berechnet pausiert nichts, wir 30 %. E2B hat einen kostenlosen Hobby-Tarif mit einmalig 100 $ Guthaben; unsere Tarife beginnen bei 20 $ im Monat, komplett als Verbrauch. Sandboxes haben hier einfaches SSH und laufen in der EU; E2B läuft in den USA, außer du fragst nach seinem EU-Cluster. Die Zahlen von E2B stammen von seinen eigenen Seiten am 21. November 2026.

**Gibt es eine kostenlose Testphase?**

Ja: 7 Tage mit 1 $ Verbrauch, 4 vCPUs gleichzeitig und Größen bis DEFAULT, das sind 55 Stunden einer laufenden SMALL-Sandbox. Eine Karte ist nötig, und die erste Zahlung für den Tarif kommt, wenn die Testphase endet.

## Gib deinem Agenten einen Computer in 0,15 s

[Kostenlose Testphase starten](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Vorlagen](https://pethost.dev/de/templates/)
- [Über uns](https://pethost.dev/about/)
- [Doku](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/de/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [AGB](https://pethost.dev/terms/)
- [Datenschutz](https://pethost.dev/privacy/)
- [Erstattung](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Datenbanken

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

Agent Sandboxes

- [Sandboxes](https://pethost.dev/de/sandboxes/)
- [Preise](https://pethost.dev/de/sandboxes/#pricing)
- [Doku](https://pethost.dev/de/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Vergleiche

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

Alternativen

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