Saltar al contenido

Aplicaciones administradas

Sandbox

Una computadora propia para cada agente

Una microVM que tu código o tu agente controla a través de la API. Ejecuta comandos, abre una terminal, guárdala entera y bifúrcala; si queda inactiva, se duerme.

Lee la documentación

Sandbox en cifras

CPU más rápida que la mediana de los proveedores1
68%
en despertar un sandbox2
3.5 ms
en hacer una instantánea de un sandbox en ejecución2
32 ms

En tres pasos

Las mismas llamadas desde la línea de comandos, la API, los SDK y el servidor MCP.

Antes de empezar

Pon tu clave de API en 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. Crea uno

    Una máquina propia, desde cualquier imagen.

    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. Ejecuta en él

    Comandos y archivos, durante el tiempo que haga falta.

    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. Guárdalo entero y bifúrcalo

    Memoria, procesos y disco, en copias que siguen desde ahí.

    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}

Su nombre sirve dondequiera que sirva su ID. No hay llamada para despertarlo: lo que necesite un sandbox dormido lo despierta.

Qué hace

  • Una terminal, un enlace a cualquier puerto o SSH, todo a través de un agente dentro de él.

  • Haz una instantánea mientras se ejecuta, vuelve a ella en el mismo sandbox o bifúrcalo en hasta 64 copias.

  • Arrancado una vez, ya en ejecución en cada copia.

  • Secretos que tu código nunca tiene: se insertan a la salida.

  • Cualquier imagen OCI, o la nuestra, con cinco lenguajes y agentes de programación listos.

  • Se duerme tras 30 segundos de inactividad, con todo lo que contiene; un comando lo despierta.

Lee la documentación

Vistas previas ilustrativas

Pensado para

  • Intérpretes de código

    Ejecuta el código que escribe un modelo, con sus variables guardadas entre llamadas.

    from glac import CODE_INTERPRETER
    sbx = glac.sandboxes.create(
        image=CODE_INTERPRETER)
    sbx.run_code("x = 1")
    print(sbx.run_code("x + 1").text)
  • Agentes de programación

    Claude Code y otros agentes, cada uno en su propia máquina.

    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")
  • Probar muchos caminos

    Bifurca un sandbox a mitad de tarea y deja que cada copia pruebe algo distinto.

    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)

Precios y límites

Facturado por los recursos de Cubo que usa, como todos los productos. Todos los precios y planes

Qué se cuentaCómoPrecio
CPUTiempo de CPU en uso, por milisegundo$0.01 / millón de ms de CPU$0.00001 / segundo de CPU$0.036 / hora de CPU$26.28 / mes de CPU
MemoriaReservada, por milisegundo, en incrementos de 128 MiB$0.00222 / millón de GiB-ms$0.00000222 / GiB-segundo$0.008 / GiB-hora$5.84 / GiB-mes
SolicitudesPor solicitud a un Cubo o a través del enlace de un sandbox$0.30 / millón
Tráfico de salidaNA · EUPor GB que sale de Norteamérica y Europa$0.004 / GB
Tráfico de salidaAPACPor GB que sale de Asia-Pacífico$0.01 / GB
Guardado en reposo3Lo que guardan las instancias dormidas, y las instantáneas$0.00000761 / millón de GB-ms$0.00000000761 / GB-segundo$0.0000274 / GB-hora$0.02 / GB-mes

Calcula un mes de uso

Una carga de trabajo real y lo que cuesta su mes en el plan de pago y en el plan Gratis.

Un agente crea y publica software en su propia máquina, jornada a jornada.

Un mes de 30 días, con solo esta carga de trabajo en la cuenta. Fuentes

Un mes en el plan de pago

$356.97

$0.16 por sesión

  • CPU8617 M de ms de CPU$86.17
  • Memoria29 mil GiB-h$228.80
  • Datos guardados2 000 GB-meses$40.00
  • Tráfico de salida300 GB$1.20
Uso a precios de lista
$356.17
Incluido en el plan de pago
−$4.20
Cuota del plan de pago
$5.00

Por encima de lo que permite el plan Gratis: el tamaño de la instancia, CPU, memoria, datos guardados y tráfico de salida.

Facturado por tamaño, por cada segundo despierto10.4× más

Glac$356.17

Por tamaño$3,702.00

Lo que permiten los planes

Todos los límites de cada plan
GratisDe pago
Sandbox más grande2 vCPU, 4 GiB8 vCPU, 16 GiB
Despiertas a la vezsandboxes e instancias de Cubos5500
Guardados mientras duermen2010 000
Creados en un minuto10600
Creados en una horapor un proyecto20010 000

Aislado

Ejecuta lo que escribió un modelo, así que cada uno es una máquina propia, accesible solo por las vías que tú le des.

Seguridad
  • Una microVM propia

    Una microVM de Firecracker con su propio kernel, arrancada desde tu imagen.

  • Una jaula a su alrededor

    Una raíz vacía, un usuario sin privilegios, sus propios límites.

  • Accesible a través de la API

    Los comandos y los archivos pasan por un agente dentro de él; no tiene dirección IPv4 pública.

  • Enlaces que son la llave

    Un enlace firmado abre un puerto; cambia el secreto y todos los enlaces anteriores dejan de funcionar.

  • Secretos que nunca tiene

    Se insertan en sus solicitudes a la salida, solo hacia los hosts a los que van destinados.

  • Cifrado con tu clave

    Su disco, su memoria mientras duerme y sus instantáneas, antes de que salgan de la máquina.

Sigue leyendo

La plataforma