yoloAI

Sandbox-Ausführungsumgebung für KI-Codierungsagenten. Keine Berechtigungsmüdigkeit, keine Anmeldedaten in der Sandbox, keine Änderungen an deinem Projekt, bis du sie genehmigst.

KI-Codierungsagenten funktionieren am besten ohne Sicherheitsvorkehrungen, und das ist eine schlechte Art, sie auf deinem echten Rechner auszuführen. yoloAI gibt dem Agenten eine Wegwerf-Sandbox, in der er alles bearbeiten und alles ausführen kann, unbeaufsichtigt. Dein Projekt, deine Anmeldedaten und dein Netzwerk bleiben unter deiner Kontrolle. Wenn der Agent fertig ist, überprüfe den Diff und übernimm, was du behalten möchtest.

Du                          Sandbox                        Dein Projekt
 │                              │                                │
 ├─ yoloai new fix-bug .        ├─ Sandbox-Kopie des Projekts    │
 │                              │                                │
 ├─ << deine Eingabeaufforderung(en) >>  ├─ Agent arbeitet frei  │
 │                              │  (keine Berechtigungsabfragen) │
 │                              │                                │
 ├─ yoloai diff fix-bug         ├─ zeigt, was sich geändert hat  │
 │                              │                                │
 ├─ yoloai apply fix-bug        │                                ├─ Patches angewendet
 │  (du wählst aus, welche)     │                                │
 │                              │                                │
 ├─ yoloai destroy fix-bug      ├─ zerstört die Sandbox          │

Warum?

Berechtigungsabfragen existieren, weil Agenten Fehler machen. Nach der hundertsten Genehmigen/Ablehnen-Abfrage liest du sie nicht mehr, und --dangerously-skip-permissions ist nur einen verwirrten Agenten von einem sehr schlechten Tag entfernt. yoloAI verkleinert den Schadensradius, bis die Abfragen unnötig sind:

• Deine Dateien sind sicher. Der Agent arbeitet an einer isolierten Kopie deines Projekts. diff zeigt genau, was sich geändert hat, apply patcht dein echtes Projekt unter Beibehaltung einzelner Commits, und deine Originale ändern sich nie, bis du sie anwendest.
• Deine Geheimnisse sind sicher. Die Sandbox startet aus einer minimalen, lokal erstellten Umgebung; Host-Umgebungsvariablen bleiben auf dem Host. Anmeldedaten kommen als schreibgeschützte Datei-Mounts, niemals als Umgebungsvariablen. Wo Credential-Brokering gilt (Claude, Gemini und Codex heute, standardmäßig aktiviert), bleibt der API-Schlüssel vollständig host-seitig: Ein lokaler Proxy injiziert ihn auf dem Weg zum Anbieter, sodass selbst ein vollständig kompromittierter Agent nichts exfiltrieren kann.
• Dein Netzwerk gehört dir. --network-isolated beschränkt den ausgehenden Datenverkehr auf die API-Endpunkte des Agenten plus von dir erlaubte Domains. --network-none entfernt das Netzwerk vollständig.
• Dein Rechner ist isoliert. Wähle dein Komfortniveau, von Linux-Namespaces über gVisor bis hin zu Hardware-VMs.

Siehe Sicherheit für das vollständige Modell, einschließlich ehrlicher Einschränkungen.

Installation

Vorgefertigtes Binärpaket (empfohlen)

Lade das Archiv für deine Plattform vom neuesten Release herunter, extrahiere die yoloai-Binärdatei und lege sie auf deinen PATH:

# Linux x86-64 (ersetze bei Bedarf durch linux_arm64 / darwin_amd64 / darwin_arm64).
# Setze VERSION auf das Tag, das auf der oben verlinkten Release-Seite angezeigt wird, ohne
# das führende "v" — z. B. VERSION=1.2.3 für Tag v1.2.3.
VERSION=X.Y.Z
curl -fsSL "https://github.com/kstenerud/yoloai/releases/download/v${VERSION}/yoloai_${VERSION}_linux_amd64.tar.gz" \
  | tar -xz yoloai
sudo install yoloai /usr/local/bin/

Jedes Archiv enthält außerdem Shell-Vervollständigungen, die LICENSE und das Änderungsprotokoll. Releases sind mit cosign signiert (checksums.txt) und tragen GitHub-Build-Herkunftsnachweise (gh attestation verify yoloai_… --repo kstenerud/yoloai). Debian/RPM-Pakete sind ebenfalls jedem Release beigefügt.

Homebrew (macOS / Linux)

brew install --cask kstenerud/tap/yoloai

Mit go install

# Neuestes Release
go install github.com/kstenerud/yoloai/cmd/yoloai@latest

# Neueste Entwicklungsversion (instabil)
go install github.com/kstenerud/yoloai/cmd/yoloai@main

Erfordert Go 1.26+. Die Binärdatei wird in $GOPATH/bin platziert (normalerweise ~/go/bin).

Aus dem Quellcode

git clone https://github.com/kstenerud/yoloai.git
cd yoloai
git checkout "$(git describe --tags --abbrev=0)"   # neuestes Release-Tag; oder auf main bleiben für die Entwicklungsversion
make build
sudo install yoloai /usr/local/bin/

Es ist eine einzelne Go-Binärdatei ohne Laufzeitabhängigkeiten außer deinem gewählten Backend. Beim ersten Start erstellt yoloAI sein Basis-Image und erstellt ~/.yoloai/ (oder das Verzeichnis, das du mit --data-dir angibst).

Schnellstart

Nicht-interaktiv

# Authentifizieren (yoloAI erkennt vorhandene Anmeldedaten automatisch)
export ANTHROPIC_API_KEY=sk-ant-...   # Claude Code
export GEMINI_API_KEY=...             # Gemini CLI
# Oder lass es einfach deine bereits authentifizierte Sitzung übernehmen

# 1. Sandbox starten. Der Agent beginnt sofort zu arbeiten, wenn du eine Eingabeaufforderung angibst
yoloai new fix-bug ./my-project --prompt "fix the failing tests"

# 2. Sehen, was der Agent geändert hat
yoloai diff fix-bug

# 3. Die guten Teile auf dein echtes Projekt anwenden
yoloai apply fix-bug

# 4. Sandbox verwerfen
yoloai destroy fix-bug

Interaktiv

yoloai new exploration ./my-project -a
# Du bist im Agenten, der in tmux in der Sandbox läuft.
#   Strg-B, D zum Trennen.
#   yoloai attach exploration zum erneuten Verbinden.

Iterieren

Für längere Sitzungen arbeite in einer Schleife: Sage dem Agenten, er soll während der Arbeit committen, und führe yoloai apply von einem anderen Terminal aus, wann immer du die fertigen Commits in dein echtes Projekt übernehmen möchtest. Jedes Apply übernimmt nur die neuen Commits seit dem letzten. Wenn du mit dem Ergebnis zufrieden bist, pushe wie gewohnt und zerstöre die Sandbox. Siehe den Nutzungsleitfaden für den vollständigen Arbeitsablauf.

Demo

Erstellen einer Sandbox, Auffordern des Agenten und Anwenden der Ergebnisse:

https://github.com/user-attachments/assets/9d6740b4-a34e-4253-82ec-cb0e4c7a8bd9

Funktionen

Sandboxing

• Sechs Backends: Docker, Podman, containerd (Kata), Apple Container, Tart und Seatbelt. Läuft auf Linux, macOS und Windows (WSL2).
• Wählbare Isolationsstärke pro Sandbox, von runc über gVisor bis zu Kata-VMs (QEMU oder Firecracker).
• Netzwerkrichtlinie pro Sandbox: offen, Whitelist oder keine.
• Minimale Umgebung in der Sandbox. Alles vom Host ist ein explizites Opt-in (--env, --dir).
• Ressourcenlimits (--cpus, --memory) und Portweiterleitung (--port).
• Günstige Workdir-Kopien: Ganzbaum-Klone auf macOS (APFS clonefile), Datei-Reflinks auf Linux-Dateisystemen, die sie unterstützen (btrfs, XFS). Dateisysteme ohne Reflink (ext4) erhalten eine normale Kopie.
• .gitignore wird berücksichtigt: Alles, was ignoriert wird, wird NICHT in die Sandbox kopiert (Sicherheitspraxis für Entwicklungsanmeldedaten auf der Festplatte).

Anmeldedaten

• Erkennt deine vorhandenen Agenten-Anmeldungen automatisch: API-Schlüssel, Abonnement-Anmeldedaten, macOS-Schlüsselbund.
• Credential-Brokering hält den API-Schlüssel host-seitig (Claude, Gemini und Codex heute); Aider- und OpenCode-Anmeldedaten werden als schreibgeschützte Datei-Mounts bereitgestellt.

Arbeitsablauf

• Kopieren/Diff/Anwenden mit git, das sandbox-seitig läuft, sodass Repos mit Filtern und Hooks korrekt funktionieren.
• Wende auf deine Weise an: Commits wiedergeben (Standard), zu einem einzelnen Patch squashen, .patch-Dateien exportieren, Commits per Ref auswählen oder zuerst --dry-run.
• Vollständiger Lebenszyklus: erstellen, anhängen, stoppen, neu starten, warten, klonen, zurücksetzen, zerstören. Der Agentenzustand überlebt Stopps und Neustarts.
• Headless-Einmalausführungen für Skripte und CI: yoloai run --prompt ... --rm, mit --json-Ausgabe bei jedem Befehl.
• Wenn der Agent beendet wird, fällt sein tmux-Bereich auf eine Shell zurück, damit du die Sandbox inspizieren kannst.

Integration

• Claude Code, Codex, Gemini CLI, Aider und OpenCode integriert, plus ein shell-Modus für alles andere.
• VS Code: Am Container anhängen oder einen Remote-Tunnel aus der Sandbox öffnen (--vscode-tunnel).
• MCP in beide Richtungen: yoloai mcp serve lässt einen äußeren Agenten Sandboxes als Werkzeuge steuern; yoloai mcp proxy führt MCP-Server in einer Sandbox aus.
• Profile: projektspezifische Images und Standardwerte (Dockerfile + Konfiguration, mit Vererbung).
• Erweiterungen: Füge eigene Unterbefehle als YAML-umhüllte Shell-Skripte hinzu (yoloai x).
• Einbettbar: Die CLI ist eine dünne Schicht über einer öffentlichen Go-API.
• Einzelne statische Binärdatei. Der Zustand liegt in ~/.yoloai/ (verschiebbar mit --data-dir).

Unterstützte Infrastruktur

Sandbox-Backends

Hinweis: Tart bietet eine vollständige macOS-VM und ermöglicht dir, Simulatoren in der Sandbox auszuführen.

Isolationsmodi

Optional das OCI-Runtime für stärkere Isolation aufrüsten. gVisor-Modi sind auf docker und podman verfügbar; die VM-Modi kommen mit dem containerd-Backend.

# gVisor für alle neuen Sandboxes verwenden
yoloai config set isolation container-enhanced

# Oder pro Sandbox
yoloai new task . --isolation container-enhanced

Agenten

Verwende yoloai system agents, um verfügbare Agenten aufzulisten.

Mehr erfahren

• Nutzungsleitfaden: Befehle, Flags, Workdir-Modi, Konfiguration, Sicherheit
• Roadmap: Geplante Funktionen
• Architektur: Code-Navigation für Mitwirkende

Status

Öffentliche Beta. Der Kernarbeitsablauf ist stabil und wird täglich genutzt; Schnittstellen können sich zwischen 0.x-Releases noch ändern, und jede bahnbrechende Änderung ist in BREAKING-CHANGES dokumentiert. Feedback ist willkommen.

Lizenz

MIT