Applications managées
Bac à sable
Un ordinateur dédié à chaque agent
Une microVM que votre code ou votre agent pilote par l’API. Lancez des commandes, ouvrez un terminal, enregistrez-la en entier et dupliquez-la ; laissée inactive, elle s’endort.
Bac à sable en chiffres
En trois étapes
Les mêmes appels depuis la ligne de commande, l’API, les SDK et le serveur MCP.
Avant de commencer
Mettez votre clé API dans 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-mcpCréez-en un
Une machine dédiée, depuis n’importe quelle image.
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 imageExécutez-y vos commandes
Commandes et fichiers, aussi longtemps qu’il le faut.
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"}Enregistrez-le en entier, et dupliquez-le
Mémoire, processus et disque, en copies qui repartent de 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}
Son nom s’utilise partout où son identifiant est accepté. Il n’y a pas d’appel de réveil : tout ce qui a besoin d’un bac à sable endormi le réveille.
Ce qu’il fait
Un terminal, un lien vers n’importe quel port, ou SSH, le tout via un agent à l’intérieur.
Prenez un instantané sans l’arrêter, revenez-y sur place, ou dupliquez-le en 64 copies au plus.
Démarré une fois, déjà en marche dans chaque copie.
Des secrets que votre code ne détient jamais : ils sont injectés en sortie.
N’importe quelle image OCI, ou la nôtre, avec cinq langages et des agents de code prêts à l’emploi.
Endormi après 30 secondes d’inactivité, avec tout ce qu’il contient ; une commande le réveille.
Aperçus à titre d’illustration
Conçu pour
Interpréteurs de code
Exécutez le code qu’écrit un modèle, avec ses variables conservées d’un appel à l’autre.
from glac import CODE_INTERPRETER sbx = glac.sandboxes.create( image=CODE_INTERPRETER) sbx.run_code("x = 1") print(sbx.run_code("x + 1").text)Agents de code
Claude Code et d’autres agents, chacun dans sa propre 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")Explorer plusieurs pistes
Dupliquez un bac à sable en pleine tâche et laissez chaque copie essayer autre chose.
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)
Prix et limites
Facturé selon les ressources Cube qu’il utilise, comme chaque produit. Tous les prix et forfaits
| Ce qui est compté | Comment | Prix |
|---|---|---|
| CPU | Temps CPU actif, à la milliseconde | $0.01 / million de ms CPU$0.00001 / seconde CPU$0.036 / heure CPU$26.28 / mois CPU |
| Mémoire | Réservée, à la milliseconde, par paliers de 128 MiB | $0.00222 / million de GiB-ms$0.00000222 / GiB-seconde$0.008 / GiB-heure$5.84 / GiB-mois |
| Requêtes | Par requête vers un Cube ou via un lien de bac à sable | $0.30 / million |
| Trafic sortantNA · EU | Par GB sortant d’Amérique du Nord et d’Europe | $0.004 / GB |
| Trafic sortantAPAC | Par GB sortant d’Asie-Pacifique | $0.01 / GB |
| En sommeil3 | Ce que gardent les instances endormies, et les instantanés | $0.00000761 / million de GB-ms$0.00000000761 / GB-seconde$0.0000274 / GB-heure$0.02 / GB-mois |
Estimer un mois de consommation
Une vraie charge de travail, et ce que coûte son mois avec le forfait Payant ou le forfait Gratuit.
Un agent construit et livre du logiciel sur sa propre machine, une journée de travail à la fois.
Votre produit donne à chaque utilisateur un bac à sable pour une courte session.
Une application d’IA exécute de courts bouts de code pour ses utilisateurs.
Une suite de tâches, chacune traitée par un agent puis notée.
De courtes exécutions qui sollicitent leur machine, nombreuses en parallèle.
Builds et tests à chaque push.
Un mois de 30 jours, cette charge de travail seule sur le compte. Sources
Un mois avec le forfait Payant
$0.16 par session
- CPU8.6 Md de ms CPU$86.17
- Mémoire29 k GiB-h$228.80
- Requêtes$0.00
- Données stockées2 000 GB-mois$40.00
- Cache NVMe$0.00
- Trafic sortant300 GB$1.20
- Consommation aux prix catalogue
- $356.17
- Inclus dans le forfait Payant
- −$4.20
- Abonnement au forfait Payant
- $5.00
Au-delà de ce que permet le forfait Gratuit : la taille de l’instance, CPU, mémoire, données stockées et trafic sortant.
Facturé à la taille, chaque seconde d’éveil10.4 fois plus
Glac$356.17
À la taille$3,702.00
Ce que permettent les forfaits
Toutes les limites de chaque forfait| Gratuit | Payant | |
|---|---|---|
| Plus grand bac à sable | 2 vCPU, 4 GiB | 8 vCPU, 16 GiB |
| Éveillés en même tempsbacs à sable et instances de Cubes | 5 | 500 |
| Conservés en sommeil | 20 | 10 000 |
| Créés par minute | 10 | 600 |
| Créés par heuredans un même projet | 200 | 10 000 |
Isolation
Il exécute ce qu’un modèle a écrit : chacun est donc une machine à part, joignable seulement par les voies que vous ouvrez.
SécuritéSa propre microVM
Une microVM Firecracker avec son propre noyau, démarrée depuis votre image.
Une prison autour d’elle
Une racine vide, un utilisateur sans privilèges, ses propres limites.
Joignable par l’API
Commandes et fichiers passent par un agent à l’intérieur ; il n’a pas d’adresse IPv4 publique.
Des liens qui font office de clé
Un lien signé ouvre un port ; changez le secret, et tous les anciens liens cessent de fonctionner.
Des secrets qu’il ne détient jamais
Injectés dans ses requêtes en sortie, seulement vers les hôtes auxquels ils sont destinés.
Chiffré avec votre clé
Son disque, sa mémoire pendant son sommeil et ses instantanés, avant qu’ils ne quittent la machine.
Pour aller plus loin
- Bac à sableSa création, son cycle de vie, commandes et fichiers, instantanés et copies, modèles, liens, son réseau.
- Démarrage rapideUne clé, puis un bac à sable depuis la ligne de commande et depuis Python, en quelques minutes.
- Les SDKPython, TypeScript, Go, Rust et Java, avec les mêmes noms et verbes dans chacun.
- Le serveur MCPBacs à sable utilisables comme outils par Claude, Cursor ou tout client MCP.
La plateforme
Cube
- CubeToute image de conteneur devient une application qui dort entre les requêtes
- VolumesLes disques de Cube, qui survivent à leur instance
Applications managées
- BientôtNavigateurDe vrais navigateurs, pilotés par le code
- BientôtPostgres sans serveurPostgres qui s’endort au repos et se réveille dès qu’on s’y connecte
- BientôtApplications tiercesDes projets open source exécutés pour vous, puis une place de marché