---
title: "Sandbox für Code-Ausführung durch KI-Agenten · Pethost"
description: "Führ den Code deines Modells in einer Firecracker-Sandbox aus: Befehle, die auf einen Port warten, gestreamte Ausgabe, exakte Datei-Edits, Terminal im Browser."
---

[Agent Sandboxes](https://pethost.dev/de/sandboxes/) Befehle, Dateien und ein Terminal

# Eine Sandbox für Code-Ausführung durch KI-Agenten

Dein Modell schreibt Code, eine Sandbox führt ihn aus, und die Ausgabe kommt im selben Aufruf zurück. Befehle, Dateien und Terminals sind eine API, beantwortet vom Server, auf dem die Sandbox läuft, nicht vom Panel.

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.

## Code-Ausführung in einem Aufruf

Jede Sandbox ist eine Firecracker-MicroVM mit eigenem Linux-Kernel und Root-Zugriff, in etwa 0,15 s aus unserer Vorlage `base` gestartet: Ubuntu 24.04 mit Build-Tools, Python 3, Node.js 22 und Docker. `run_command` führt einen Befehl über `bash -lc` als `user` aus, der sudo hat, oder als root, in jedem Verzeichnis, das du nennst. Der Aufruf wartet bis zu 45 Sekunden auf das Ende des Befehls und antwortet mit seinem Exit-Code und den letzten 32 KiB von stdout und stderr.

Drei Felder ändern, worauf der Aufruf wartet:

- `wait_for_port` antwortet, sobald etwas auf einem Port lauscht, während der Befehl weiterläuft: `npm run dev` und 5173.
- `wait_seconds=0` antwortet, sobald der Befehl gestartet ist. `get_command` wartet erneut auf ihn, und `watch_command` streamt seine Ausgabe, erst die letzten 64 KiB, dann live.
- `timeout_seconds` beendet einen Befehl, der zu lange läuft. Ohne das beendet ihn nur `stop_command`: SIGTERM, dann SIGKILL 10 s später.

Jede Antwort sagt, wie viele Bytes der Befehl geschrieben hat; gib sie zurück, und die nächste Antwort enthält nur das Neue. Mit einer `request_id` führt eine Wiederholung innerhalb von 24 Stunden nichts erneut aus und antwortet, was der erste Aufruf getan hat. `list_commands` zeigt, was gerade läuft, auch über SSH getippte Befehle, und die letzten 100 beendeten bleiben erhalten.

Python

CLI

```
from pethost.sandboxes import FileChange, Sandboxes, TextEdit

sandboxes = Sandboxes()  # liest PETHOST_TOKEN
box = sandboxes.create_sandbox()
code = "x = 1\nprint(x * 42)\n"
sandboxes.write_files(box.sandbox_id, changes=[FileChange(path="app.py", text=code)])
out = sandboxes.run_command(box.sandbox_id, command="python3 app.py", timeout_seconds=30)
print(out.exit_code, out.stdout)  # 0 42

edit = TextEdit(old_text="x = 1", new_text="x = 2")
sandboxes.write_files(box.sandbox_id, changes=[FileChange(path="app.py", edit=edit)])
server = sandboxes.run_command(box.sandbox_id, command="python3 -m http.server 8000",
                               wait_for_port=8000)
print(server.state.name)  # RUNNING: Die Antwort kam, sobald Port 8000 lauschte
```

```
pethost sandbox new --name tests --size small
pethost sandbox cp ./app tests:/home/user/app
pethost sandbox run tests --cwd /home/user/app -- python3 -m unittest
pethost sandbox open tests --terminal
```

## Dateien: Batches und exakte Edits

`write_files` nimmt eine Liste von Änderungen und führt sie der Reihe nach aus: Text oder Bytes einer Datei schreiben, Text ersetzen, der genau einmal darin vorkommt, verschieben, löschen, ein Verzeichnis anlegen, Rechte setzen. Fehlende übergeordnete Verzeichnisse werden angelegt. Es hält bei der ersten Änderung an, die fehlschlägt, und sagt, welche, mit einem Grund, auf den dein Code reagieren kann, etwa dass der zu ersetzende Text fehlt. So landet ein Edit nur dort, wo sein Text steht. Ein Request trägt bis zu 17 MiB.

`read_file` liest bis zu 1 MiB ab jedem Offset, `list_files` listet ein Verzeichnis so tief, wie du willst, und `watch_files` streamt jede Änderung darunter. Eine Datei jeder Größe geht über einen Link von `create_link`: Eine Download-URL schickt die Datei, oder ein Verzeichnis als .tar; eine Upload-URL nimmt ein PUT an. Jede funktioniert einmal.

## Ein Terminal im Browser

`create_link` mit einem Terminal liefert eine Seite, die bash ausführt oder einen Befehl wie `claude`, und einen WebSocket unter derselben URL, der seine Bytes trägt, für ein Terminal in deinem eigenen Produkt. Ein Link gilt standardmäßig eine Stunde und höchstens einen Tag.

## Was darin läuft

Docker läuft in jeder Sandbox: `dockerd` startet bei der ersten Verbindung zu seinem Socket und hält Images auf der Disk der Sandbox, also überstehen sie einen Stopp, und eine Vorlage nimmt sie mit. Den Rest holst du mit sudo über apt.

Aufrufe gehen direkt an den Server der Sandbox, den das SDK für dich findet. Der erste Befehl nach dem Erstellen antwortet in 29 bis 48 ms. Auf einem Server mit 74 Sandboxes, die jede ein JavaScript-Projekt bauten und zwischen den Builds warteten, wie ein Agent es tut, dauerte ein trivialer Befehl 6 ms (28 ms im 95. Perzentil).

## Grenzen und Preise

| Was | Grenze |
| --- | --- |
| Gleichzeitige Aufrufe pro Sandbox | 64; ein `write_files` zählt als 16 |
| Ein Request | 1 MiB; `write_files` 17 MiB |
| Eine Antwort | etwa 64 KiB; `read_file` 1 MiB; jede Größe über einen Link |
| Ausgabe in einer Antwort | die letzten 32 KiB von stdout und von stderr |

Befehle, Dateien und Links haben keinen eigenen Preis: Du zahlst die Sekunden, in denen die Sandbox läuft, von 0,018 $ pro Stunde für SMALL (2 vCPU, 4 GiB) bis 0,144 $ für XLARGE (16 vCPU, 32 GiB), jeder Lauf auf eine Sekunde aufgerundet, mindestens 10 s. Nach 5 min Leerlauf pausiert sie zu 30 % davon. [So funktioniert die sekundengenaue Abrechnung](https://pethost.dev/de/sandboxes/per-second-billing/).

## Im Vergleich

Am 21. November 2026 berechnete E2B für eine Sandbox mit 2 vCPU und 4 GiB 0,1656 $ pro Stunde, Daytona ebenso; SMALL bei Pethost, dieselbe Größe, kostet 0,018 $. Bei E2B dauerten Sitzungen im Tarif Hobby bis zu 1 Stunde und bei Pro bis zu 24 Stunden, bei Vercel Sandbox 45 Minuten bei Hobby und 24 Stunden bei Pro. Eine Pethost-Sandbox hat kein Limit, wie lange sie lebt.

[Doku lesen](https://pethost.dev/de/docs/sandboxes/commands-and-files/)

## Fragen

**Welche Sprachen kann eine Sandbox für Code-Ausführung ausführen?**

Alles, was unter Linux läuft. Python 3 und Node.js 22 sind installiert, Docker läuft, und apt installiert den Rest. Speichere eine Sandbox mit deinen Tools als [Vorlage](https://pethost.dev/de/sandboxes/templates/), und neue Sandboxes starten damit.

**Wie lange kann ein Befehl laufen?**

So lange er braucht: Ein Aufruf wartet bis zu 45 Sekunden, dann liest oder streamst du seine Ausgabe. Nach 5 min Leerlauf pausiert eine Sandbox mit dem Befehl im RAM, und er macht beim nächsten Aufruf weiter. Ein Befehl, der mit `keep_awake` gestartet wurde, läuft durch, ebenso einer, dem du mit `watch_command` folgst.

**Kommt der Code ins Internet?**

Ja, über TCP: Standardmäßig darf sich eine Sandbox überallhin verbinden. Eine [Egress-Allowlist](https://pethost.dev/de/sandboxes/egress-allowlist/) beschränkt das auf die Domains, IPs und Ports, die du nennst. Kein UDP verlässt eine Sandbox.

**Wie bewege ich große Dateien?**

Über einen Download- oder Upload-Link, in jeder Größe, oder mit scp über [SSH](https://pethost.dev/de/sandboxes/ssh/).

## Verwandte Funktionen

- [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 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/)

## 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/)
