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.
Sandbox in cifre
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-mcpCreane una
Una macchina tutta sua, da qualsiasi immagine.
glac sandboxes create --name web \ --image python:3.12curl $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 imageEsegui al suo interno
Comandi e file, per tutto il tempo che serve.
glac sandboxes exec web -- \ pip install pandascurl $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"}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 16curl $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.
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 conteggiato | Come si conta | Prezzo |
|---|---|---|
| CPU | Tempo di lavoro della CPU, al millisecondo | $0.01 / milione di CPU-ms$0.00001 / CPU-secondo$0.036 / CPU-ora$26.28 / CPU-mese |
| Memoria | Riservata, 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 |
| Richieste | Per richiesta a un Cubo o tramite il link di una sandbox | $0.30 / milione |
| Traffico in uscitaNA · EU | Per GB in uscita dal Nord America e dall’Europa | $0.004 / GB |
| Traffico in uscitaAPAC | Per GB in uscita dall’Asia-Pacifico | $0.01 / GB |
| Conservato durante il sonno3 | Ciò 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.
Il tuo prodotto dà a ogni utente una sandbox per una breve sessione.
Un’app AI esegue brevi frammenti di codice per i suoi utenti.
Una suite di task, ciascuno svolto da un agente e valutato.
Esecuzioni brevi che tengono occupata la macchina, molte alla volta.
Build e test a ogni push.
Un mese di 30 giorni, con solo questo carico di lavoro sull’account. Fonti
Un mese con il piano a pagamento
$0.16 per sessione
- CPU8.6 Mld di CPU-ms$86.17
- Memoria29K GiB-h$228.80
- Richieste$0.00
- Dati archiviati2 000 GB-mese$40.00
- Cache NVMe$0.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| Gratuito | A pagamento | |
|---|---|---|
| Sandbox più grande | 2 vCPU, 4 GiB | 8 vCPU, 16 GiB |
| Sveglie contemporaneamentesandbox e istanze dei Cubi | 5 | 500 |
| Sandbox dormienti conservate | 20 | 10 000 |
| Create al minuto | 10 | 600 |
| Create all’orada un solo progetto | 200 | 10 000 |
Isolamento
Esegue ciò che ha scritto un modello, quindi ognuna è una macchina a sé, raggiungibile solo nei modi che concedi.
SicurezzaUna 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ù
- SandboxCome crearne una, il suo ciclo di vita, comandi e file, snapshot e fork, template, link, la sua rete.
- Guida rapidaUna chiave, poi una sandbox dalla riga di comando e da Python, in pochi minuti.
- Gli SDKPython, TypeScript, Go, Rust e Java, con gli stessi nomi e verbi in ciascuno.
- Il server MCPSandbox come strumenti per Claude, Cursor o qualsiasi client MCP.
La piattaforma
Cubo
- CuboQualsiasi immagine container come app che dorme tra una richiesta e l’altra
- VolumiI dischi di Cubo, che sopravvivono alla loro istanza
Applicazioni gestite
- In arrivoBrowserBrowser veri, pilotati dal codice
- In arrivoPostgres serverlessPostgres che dorme quando è inattivo e si sveglia alla connessione
- In arrivoApp di terze partiProgetti open source gestiti per te, poi un marketplace