Vai al contenuto

Applicazioni gestite

Sandbox

Un computer tutto suo per ogni agente

Una microVM che il tuo codice o il tuo agente pilota tramite l’API. Esegui comandi, apri un terminale, salvala per intero e fanne un fork; lasciata inattiva, si addormenta.

Leggi la documentazione

Sandbox in cifre

di velocità di CPU in più rispetto al provider mediano1
68%
per svegliare una sandbox2
3.5 ms
per fare lo snapshot di una sandbox in esecuzione2
32 ms

In tre passaggi

Le stesse chiamate dalla riga di comando, dall’API, dagli SDK e dal server MCP.

Prima di iniziare

Metti la tua chiave API 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. Creane una

    Una macchina tutta sua, da qualsiasi immagine.

    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. Esegui al suo interno

    Comandi e file, per tutto il tempo che serve.

    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. Salvala per intero e fanne un fork

    Memoria, processi e disco, in copie che ripartono da lì.

    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}

Il suo nome funziona ovunque funzioni il suo id. Non c’è una chiamata per svegliarla: qualunque cosa abbia bisogno di una sandbox dormiente la sveglia.

Cosa fa

  • Un terminale, un link a qualsiasi porta, o SSH, tutto tramite un agente al suo interno.

  • Fanne uno snapshot mentre gira, ripristinala sul posto o creane fino a 64 copie con un fork.

  • Avviata una volta sola, già in esecuzione in ogni copia.

  • Segreti che il tuo codice non tiene mai: vengono inseriti in uscita.

  • Qualsiasi immagine OCI, o la nostra con cinque linguaggi e agenti di programmazione pronti.

  • Si addormenta dopo 30 secondi di inattività, con tutto ciò che contiene; un comando la sveglia.

Leggi la documentazione

Anteprime illustrative

Pensato per

  • Interpreti di codice

    Esegui il codice scritto da un modello, con le sue variabili conservate tra una chiamata e l’altra.

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

    Claude Code e altri agenti, ciascuno in una macchina tutta sua.

    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")
  • Provare molte strade

    Fai un fork di una sandbox a metà lavoro e lascia che ogni copia provi qualcosa di diverso.

    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)

Prezzi e limiti

Si paga in base alle risorse di Cubo che usa, come ogni prodotto. Tutti i prezzi e i piani

Cosa viene conteggiatoCome si contaPrezzo
CPUTempo di lavoro della CPU, al millisecondo$0.01 / milione di CPU-ms$0.00001 / CPU-secondo$0.036 / CPU-ora$26.28 / CPU-mese
MemoriaRiservata, al millisecondo, a blocchi di 128 MiB$0.00222 / milione di GiB-ms$0.00000222 / GiB-secondo$0.008 / GiB-ora$5.84 / GiB-mese
RichiestePer richiesta a un Cubo o tramite il link di una sandbox$0.30 / milione
Traffico in uscitaNA · EUPer GB in uscita dal Nord America e dall’Europa$0.004 / GB
Traffico in uscitaAPACPer GB in uscita dall’Asia-Pacifico$0.01 / GB
Conservato durante il sonno3Ciò che conservano le istanze dormienti, e gli snapshot$0.00000761 / milione di GB-ms$0.00000000761 / GB-secondo$0.0000274 / GB-ora$0.02 / GB-mese

Stima il costo di un mese

Un carico di lavoro reale, e quanto costa in un mese con il piano a pagamento e con quello gratuito.

Un agente sviluppa e rilascia software sulla sua macchina, una giornata lavorativa alla volta.

Un mese di 30 giorni, con solo questo carico di lavoro sull’account. Fonti

Un mese con il piano a pagamento

$356.97

$0.16 per sessione

  • CPU8.6 Mld di CPU-ms$86.17
  • Memoria29K GiB-h$228.80
  • Dati archiviati2 000 GB-mese$40.00
  • Traffico in uscita300 GB$1.20
Utilizzo a prezzo di listino
$356.17
Incluso nel piano a pagamento
−$4.20
Canone del piano a pagamento
$5.00

Oltre i limiti del piano gratuito: la dimensione dell’istanza, CPU, memoria, dati archiviati e traffico in uscita.

Fatturazione a dimensione, per ogni secondo di veglia10.4× in più

Glac$356.17

Per dimensione$3,702.00

Cosa consentono i piani

Tutti i limiti di ogni piano
GratuitoA pagamento
Sandbox più grande2 vCPU, 4 GiB8 vCPU, 16 GiB
Sveglie contemporaneamentesandbox e istanze dei Cubi5500
Sandbox dormienti conservate2010 000
Create al minuto10600
Create all’orada un solo progetto20010 000

Isolamento

Esegue ciò che ha scritto un modello, quindi ognuna è una macchina a sé, raggiungibile solo nei modi che concedi.

Sicurezza
  • Una microVM tutta sua

    Una microVM Firecracker con il suo kernel, avviata dalla tua immagine.

  • Una jail tutt’intorno

    Una root vuota, un utente senza privilegi, limiti propri.

  • Raggiungibile tramite l’API

    Comandi e file passano da un agente al suo interno; non ha un indirizzo IPv4 pubblico.

  • Link che sono la chiave

    Un link firmato apre una porta; cambia il segreto e tutti i vecchi link smettono di funzionare.

  • Segreti che non tiene mai

    Inseriti nelle sue richieste in uscita, solo verso gli host a cui sono destinati.

  • Sigillato con la tua chiave

    Il suo disco, la sua memoria mentre dorme e i suoi snapshot, prima che lascino la macchina.

Per saperne di più

La piattaforma