Zum Inhalt springen

Verwaltete Anwendungen

Sandbox

Ein eigener Computer für jeden Agenten

Eine microVM, die dein Code oder dein Agent über die API steuert. Führe Befehle aus, öffne ein Terminal, sichere sie komplett und forke sie; im Leerlauf schläft sie.

Zur Doku

Sandbox in Zahlen

schnellere CPU als der Median der Anbieter1
68%
zum Aufwecken einer Sandbox2
3.5 ms
für einen Snapshot einer laufenden Sandbox2
32 ms

In drei Schritten

Dieselben Aufrufe über die Kommandozeile, die API, die SDKs und den MCP-Server.

Bevor du anfängst

Speichere deinen API-Schlüssel in GLAC_API_KEY.

curl -fsSL https://glac.ai/install.sh | sh
export GLAC_API_KEY=ak_...
API=https://api.glac.ai/v1/sandboxes
AUTH="Authorization: Bearer $GLAC_API_KEY"
from glac import Glac
glac = Glac()
import { Glac } from "glac";
const glac = new Glac();
# give your agent the tools (Claude Code here)
claude mcp add glac -e GLAC_API_KEY=ak_... -- npx glac-mcp
  1. Erstellen

    Eine eigene Maschine aus einem beliebigen Image.

    glac sandboxes create --name web \
      --image python:3.12
    curl $API -H "$AUTH" \
      --json '{"name": "web", "image": "python:3.12"}'
    sbx = glac.sandboxes.create(name="web", image="python:3.12")
    const sbx = await glac.sandboxes.create(
      { name: "web", image: "python:3.12" });
    # no call of its own: the first sandbox_run
    # that names "web" makes it, from the image
  2. Darin ausführen

    Befehle und Dateien, so lange sie dauern.

    glac sandboxes exec web -- \
      pip install pandas
    curl $API/web/run -H "$AUTH" \
      --json '{"command": "pip install pandas"}'
    print(sbx.run("pip install pandas").stdout)
    console.log((await sbx.run("pip install pandas")).stdout);
    sandbox_run {"sandbox": "web", "image": "python:3.12",
                 "command": "pip install pandas"}
  3. Komplett sichern und forken

    Arbeitsspeicher, Prozesse und Festplatte, in Kopien, die von dort aus weiterlaufen.

    glac sandboxes snapshots create web \
      --name ready
    glac sandboxes fork web --count 16
    curl $API/web/snapshots -H "$AUTH" \
      --json '{"name": "ready"}'
    curl $API/web/fork -H "$AUTH" --json '{"count": 16}'
    snap = sbx.snapshot(name="ready")
    copies = sbx.fork(16)
    const snap = await sbx.snapshot({ name: "ready" });
    const copies = await sbx.fork(16);
    sandbox_snapshot {"sandbox": "web", "name": "ready"}
    sandbox_fork {"sandbox": "web", "count": 16}

Ihr Name funktioniert überall, wo auch ihre ID funktioniert. Einen Aufruf zum Wecken gibt es nicht: Alles, was eine schlafende Sandbox anspricht, weckt sie.

Funktionen

  • Ein Terminal, ein Link zu jedem Port oder SSH, alles über einen Agenten in ihr.

  • Snapshots im laufenden Betrieb, Zurücksetzen an Ort und Stelle oder Forks mit bis zu 64 Kopien.

  • Einmal gebootet, und jede Kopie läuft bereits.

  • Secrets, die dein Code nie zu sehen bekommt: Sie werden erst auf dem Weg nach draußen eingesetzt.

  • Jedes OCI-Image oder unseres, mit fünf Sprachen und fertig eingerichteten Coding-Agenten.

  • Schläft nach 30 Sekunden Leerlauf mit allem, was darin ist; ein Befehl weckt sie.

Zur Doku

Beispielhafte Vorschauen

Einsatzbereiche

  • Code-Interpreter

    Führe den Code aus, den ein Modell schreibt; seine Variablen bleiben zwischen den Aufrufen erhalten.

    from glac import CODE_INTERPRETER
    sbx = glac.sandboxes.create(
        image=CODE_INTERPRETER)
    sbx.run_code("x = 1")
    print(sbx.run_code("x + 1").text)
  • Coding-Agenten

    Claude Code und andere Agenten, jeder in einer eigenen Maschine.

    from glac import AGENTS
    env = {"ANTHROPIC_API_KEY": "..."}
    sbx = glac.sandboxes.create(
        image=AGENTS, env=env)
    sbx.agent("claude").prompt(
        "Make the failing tests pass")
  • Viele Wege ausprobieren

    Forke eine Sandbox mitten in der Aufgabe und lass jede Kopie etwas anderes probieren.

    patches = ["a", "b", "c"]
    copies = sbx.fork(len(patches))
    for copy, p in zip(copies, patches):
        cmd = f"git apply {p}.patch"
        r = copy.run(cmd + " && pytest")
        print(p, r.exit_code)

Preise und Limits

Abgerechnet nach den Würfel-Ressourcen, die es nutzt, wie jedes Produkt. Alle Preise und Tarife

Was gezählt wirdZählweisePreis
CPUAktive CPU-Zeit, auf die Millisekunde genau$0.01 / Million CPU-Millisekunden$0.00001 / CPU-Sekunde$0.036 / CPU-Stunde$26.28 / CPU-Monat
ArbeitsspeicherBelegt, auf die Millisekunde genau, in Schritten von 128 MiB$0.00222 / Million GiB-Millisekunden$0.00000222 / GiB-Sekunde$0.008 / GiB-Stunde$5.84 / GiB-Monat
AnfragenPro Anfrage an einen Würfel oder über einen Sandbox-Link$0.30 / Million
Ausgehender TrafficNA · EUPro GB aus Nordamerika und Europa$0.004 / GB
Ausgehender TrafficAPACPro GB aus Asien-Pazifik$0.01 / GB
Gespeicherter Zustand3Was schlafende Instanzen behalten, sowie Snapshots$0.00000761 / Million GB-Millisekunden$0.00000000761 / GB-Sekunde$0.0000274 / GB-Stunde$0.02 / GB-Monat

Monatskosten schätzen

Ein echter Workload und was ein Monat davon im Bezahltarif und im Gratistarif kostet.

Ein Agent baut Software auf seiner eigenen Maschine und liefert sie aus, einen Arbeitstag nach dem anderen.

Ein Monat mit 30 Tagen, nur dieser Workload auf dem Konto. Quellen

Ein Monat im Bezahltarif

$356.97

$0.16 pro Sitzung

  • CPU8.6 Mrd. CPU-ms$86.17
  • Arbeitsspeicher28.600 GiB-h$228.80
  • Gespeicherte Daten2 000 GB-Monate$40.00
  • Ausgehender Traffic300 GB$1.20
Nutzung zu Listenpreisen
$356.17
Im Bezahltarif enthalten
−$4.20
Gebühr des Bezahltarifs
$5.00

Über den Grenzen des Gratistarifs: die Größe der Instanz, CPU, Arbeitsspeicher, gespeicherte Daten und ausgehender Traffic.

Nach Größe abgerechnet, für jede wache Sekunde10.4× mehr

Glac$356.17

Nach Größe$3,702.00

Was die Tarife erlauben

Alle Limits aller Tarife
GratistarifBezahltarif
Größte Sandbox2 vCPUs, 4 GiB8 vCPUs, 16 GiB
Gleichzeitig wachSandboxen und Würfel-Instanzen5500
Schlafend aufbewahrt2010 000
Pro Minute erstellt10600
Pro Stunde erstelltvon einem Projekt20010 000

Abgeschottet

Sie führt aus, was ein Modell geschrieben hat, darum ist jede eine eigene Maschine, nur auf den Wegen erreichbar, die du freigibst.

Sicherheit
  • Eine eigene microVM

    Eine Firecracker-microVM mit eigenem Kernel, gebootet aus deinem Image.

  • Ein Jail um sie herum

    Ein leeres Root-Dateisystem, ein Nutzer ohne Rechte, eigene Limits.

  • Erreichbar über die API

    Befehle und Dateien laufen über einen Agenten in ihr; sie hat keine öffentliche IPv4-Adresse.

  • Links, die der Schlüssel sind

    Ein signierter Link öffnet einen Port; ändere das Secret, und jeder alte Link funktioniert nicht mehr.

  • Secrets, die sie nie zu sehen bekommt

    Sie werden erst auf dem Weg nach draußen in ihre Anfragen eingesetzt, nur für die Hosts, für die sie bestimmt sind.

  • Mit deinem Schlüssel versiegelt

    Ihre Festplatte, ihr Arbeitsspeicher im Schlaf und ihre Snapshots, bevor sie die Maschine verlassen.

Weiterlesen

Die Plattform