Naar de inhoud

Beheerde Applicaties

Sandbox

Een eigen computer voor elke agent

Een microVM die je code of je agent via de API aanstuurt. Voer commando’s uit, open een terminal, sla hem in zijn geheel op en fork hem; als er niets te doen is, slaapt hij.

Lees de docs

Sandbox in cijfers

snellere CPU dan de mediaan van de aanbieders1
68%
om een sandbox te wekken2
3.5 ms
om een snapshot te maken van een draaiende sandbox2
32 ms

In drie stappen

Dezelfde aanroepen vanaf de opdrachtregel, de API, de SDK’s en de MCP-server.

Voordat je begint

Zet je API-sleutel 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. Maak er een

    Een eigen machine, vanuit welk image dan ook.

    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. Werk erin

    Commando’s en bestanden, zo lang als nodig.

    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. Sla hem in zijn geheel op en fork hem

    Geheugen, processen en schijf, in kopieën die vanaf daar verdergaan.

    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}

Zijn naam werkt overal waar zijn id werkt. Er is geen aanroep om te wekken: alles waarvoor een slapende sandbox nodig is, wekt hem.

Wat het doet

  • Een terminal, een link naar een poort naar keuze, of SSH, allemaal via een agent binnenin.

  • Maak een snapshot terwijl hij draait, zet hem ter plekke terug, of fork tot 64 kopieën.

  • Eén keer opgestart, en in elke kopie draait alles al.

  • Geheimen die je code nooit in handen heeft: ze worden onderweg naar buiten ingevoegd.

  • Elk OCI-image, of het onze, met vijf talen en codeeragents kant-en-klaar.

  • In slaap na 30 seconden inactiviteit, met alles erin; een commando wekt hem.

Lees de docs

Illustratieve voorbeelden

Gebouwd voor

  • Code-interpreters

    Draai de code die een model schrijft; de variabelen blijven tussen aanroepen bewaard.

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

    Claude Code en andere agents, elk in een eigen machine.

    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")
  • Veel aanpakken proberen

    Fork een sandbox midden in een taak en laat elke kopie iets anders proberen.

    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)

Prijzen en limieten

Afgerekend op de resources van Kubus die het gebruikt, zoals elk product. Alle prijzen en abonnementen

Wat geteld wordtHoePrijs
CPUActieve CPU-tijd, per milliseconde$0.01 / miljoen CPU-ms$0.00001 / CPU-seconde$0.036 / CPU-uur$26.28 / CPU-maand
GeheugenBezet, per milliseconde, in stappen van 128 MiB$0.00222 / miljoen GiB-ms$0.00000222 / GiB-seconde$0.008 / GiB-uur$5.84 / GiB-maand
VerzoekenPer verzoek naar een Kubus of via een sandboxlink$0.30 / miljoen
Uitgaand verkeerNA · EUPer GB vanuit Noord-Amerika en Europa$0.004 / GB
Uitgaand verkeerAPACPer GB vanuit Azië-Pacific$0.01 / GB
In slaap bewaard3Wat slapende instanties bewaren, en snapshots$0.00000761 / miljoen GB-ms$0.00000000761 / GB-seconde$0.0000274 / GB-uur$0.02 / GB-maand

Bereken een maand

Een echte workload, en wat een maand ervan kost met Betaald en met Gratis.

Een agent bouwt software en brengt die uit, op een eigen machine, werkdag na werkdag.

Een maand van 30 dagen, met alleen deze workload op het account. Bronnen

Een maand met Betaald

$356.97

$0.16 per sessie

  • CPU8.6 mld. CPU-ms$86.17
  • Geheugen29K GiB-uur$228.80
  • Opgeslagen data2 000 GB-maanden$40.00
  • Uitgaand verkeer300 GB$1.20
Verbruik tegen de lijstprijzen
$356.17
Inbegrepen bij Betaald
−$4.20
Abonnementsgeld van Betaald
$5.00

Meer dan Gratis toestaat: de grootte van de instantie, CPU, geheugen, opgeslagen data en uitgaand verkeer.

Op grootte afgerekend, voor elke seconde wakker10.4× meer

Glac$356.17

Op grootte$3,702.00

Wat de abonnementen toestaan

Alle limieten per abonnement
GratisBetaald
Grootste sandbox2 vCPU’s, 4 GiB8 vCPU’s, 16 GiB
Tegelijk wakkersandboxen en instanties van Kubussen5500
Slapend bewaard2010 000
Aangemaakt per minuut10600
Aangemaakt per uurdoor één project20010 000

Los van elkaar

Hij draait wat een model heeft geschreven, dus elke sandbox is een eigen machine, alleen bereikbaar op de manieren die jij toestaat.

Beveiliging
  • Een eigen microVM

    Een Firecracker-microVM met een eigen kernel, opgestart vanuit je image.

  • Een jail eromheen

    Een lege root, een gebruiker zonder rechten, eigen limieten.

  • Bereikbaar via de API

    Commando’s en bestanden gaan via een agent binnenin; hij heeft geen openbaar IPv4-adres.

  • Links die de sleutel zijn

    Een ondertekende link opent één poort; verander het geheim en elke oude link werkt niet meer.

  • Geheimen die hij nooit in handen heeft

    Op weg naar buiten in de verzoeken ingevoegd, alleen voor de hosts waarvoor ze bedoeld zijn.

  • Versleuteld met jouw sleutel

    Zijn schijf, zijn geheugen tijdens de slaap en zijn snapshots, voordat ze de machine verlaten.

Lees verder

Het platform