Aller au contenu

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.

Lire la documentation

Bac à sable en chiffres

CPU plus rapide que chez le fournisseur médian1
68%
pour réveiller un bac à sable2
3.5 ms
pour prendre un instantané d’un bac à sable en marche2
32 ms

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-mcp
  1. Créez-en un

    Une machine dédiée, depuis n’importe quelle 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. Exécutez-y vos commandes

    Commandes et fichiers, aussi longtemps qu’il le faut.

    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. 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 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}

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.

Lire la documentation

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éCommentPrix
CPUTemps CPU actif, à la milliseconde$0.01 / million de ms CPU$0.00001 / seconde CPU$0.036 / heure CPU$26.28 / mois CPU
MémoireRé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êtesPar requête vers un Cube ou via un lien de bac à sable$0.30 / million
Trafic sortantNA · EUPar GB sortant d’Amérique du Nord et d’Europe$0.004 / GB
Trafic sortantAPACPar GB sortant d’Asie-Pacifique$0.01 / GB
En sommeil3Ce 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.

Un mois de 30 jours, cette charge de travail seule sur le compte. Sources

Un mois avec le forfait Payant

$356.97

$0.16 par session

  • CPU8.6 Md de ms CPU$86.17
  • Mémoire29 k GiB-h$228.80
  • Données stockées2 000 GB-mois$40.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
GratuitPayant
Plus grand bac à sable2 vCPU, 4 GiB8 vCPU, 16 GiB
Éveillés en même tempsbacs à sable et instances de Cubes5500
Conservés en sommeil2010 000
Créés par minute10600
Créés par heuredans un même projet20010 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

La plateforme