Pular para o conteúdo

Aplicações Gerenciadas

Sandbox

Um computador próprio para cada agente

Uma microVM que o seu código ou o seu agente controla pela API. Execute comandos, abra um terminal, salve-a inteira e faça fork dela; quando fica ociosa, ela dorme.

Leia a documentação

O Sandbox em números

CPU mais rápida que a mediana dos provedores1
68%
para acordar um sandbox2
3.5 ms
para fazer snapshot de um sandbox em execução2
32 ms

Em três passos

As mesmas chamadas pela linha de comando, pela API, pelos SDKs e pelo servidor MCP.

Antes de começar

Coloque sua chave de API em 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. Crie um

    Uma máquina própria, a partir de qualquer imagem.

    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. Execute nele

    Comandos e arquivos, pelo tempo que levarem.

    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. Salve-o inteiro e faça fork

    Memória, processos e disco, em cópias que seguem dali em diante.

    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}

O nome dele funciona em qualquer lugar onde o ID funciona. Não existe chamada para acordar: qualquer coisa que precise de um sandbox adormecido o acorda.

O que ele faz

  • Um terminal, um link para qualquer porta ou SSH, tudo por meio de um agente dentro dele.

  • Faça snapshot com ele rodando, restaure no próprio sandbox ou faça fork de até 64 cópias.

  • Iniciado uma vez, já rodando em cada cópia.

  • Segredos que o seu código nunca guarda: eles são inseridos na saída.

  • Qualquer imagem OCI, ou a nossa, com cinco linguagens e agentes de programação prontos.

  • Dorme após 30 segundos ocioso, com tudo dentro; um comando o acorda.

Leia a documentação

Prévias ilustrativas

Feito para

  • Interpretadores de código

    Execute o código que um modelo escreve, com as variáveis mantidas entre as chamadas.

    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 programação

    Claude Code e outros agentes, cada um em uma máquina própria.

    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")
  • Testando vários caminhos

    Faça fork de um sandbox no meio da tarefa e deixe cada cópia tentar algo diferente.

    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)

Preços e limites

Cobrado pelos recursos do Cubo que usa, como todos os produtos. Todos os preços e planos

O que é medidoComoPreço
CPUTempo de CPU ocupada, por milissegundo$0.01 / milhão de ms de CPU$0.00001 / segundo de CPU$0.036 / hora de CPU$26.28 / mês de CPU
MemóriaReservada, por milissegundo, em incrementos de 128 MiB$0.00222 / milhão de GiB-ms$0.00000222 / GiB-segundo$0.008 / GiB-hora$5.84 / GiB-mês
RequisiçõesPor requisição para um Cubo ou pelo link de um sandbox$0.30 / milhão
Tráfego de saídaNA · EUPor GB que sai da América do Norte e da Europa$0.004 / GB
Tráfego de saídaAPACPor GB que sai da Ásia-Pacífico$0.01 / GB
Guardado enquanto dorme3O que as instâncias adormecidas guardam, e os snapshots$0.00000761 / milhão de GB-ms$0.00000000761 / GB-segundo$0.0000274 / GB-hora$0.02 / GB-mês

Estime o custo de um mês

Uma carga de trabalho real e quanto o mês dela custa no Pago e no Gratuito.

Um agente constrói e entrega software na própria máquina, um dia de trabalho por vez.

Um mês de 30 dias, só com esta carga de trabalho na conta. Fontes

Um mês no Pago

$356.97

$0.16 por sessão

  • CPU8.6 bi de ms de CPU$86.17
  • Memória29 mil GiB-h$228.80
  • Dados armazenados2 000 GB-meses$40.00
  • Tráfego de saída300 GB$1.20
Uso a preços de tabela
$356.17
Incluído no Pago
−$4.20
Mensalidade do Pago
$5.00

Além do que o Gratuito permite: o tamanho da instância, CPU, memória, dados armazenados e tráfego de saída.

Cobrado pelo tamanho, por segundo acordado10.4× mais

Glac$356.17

Por tamanho$3,702.00

O que os planos permitem

Todos os limites de cada plano
GratuitoPago
Maior sandbox2 vCPUs, 4 GiB8 vCPUs, 16 GiB
Acordadas ao mesmo tempoinstâncias de Cubos e sandboxes5500
Mantidos adormecidos2010 000
Criados em um minuto10600
Criados em uma horapor um projeto20010 000

Isolamento

Ele executa o que um modelo escreveu; por isso, cada um é uma máquina própria, acessível só pelos caminhos que você liberar.

Segurança
  • Uma microVM própria

    Uma microVM Firecracker com kernel próprio, iniciada a partir da sua imagem.

  • Uma jail em volta

    Uma raiz vazia, um usuário sem privilégios, limites próprios.

  • Acesso pela API

    Comandos e arquivos passam por um agente dentro dele; ele não tem endereço IPv4 público.

  • Links que são a chave

    Um link assinado abre uma porta; troque o segredo e todos os links antigos param de funcionar.

  • Segredos que ele nunca guarda

    Inseridos nas requisições dele na saída, só para os hosts a que se destinam.

  • Criptografado com a sua chave

    O disco, a memória enquanto dorme e os snapshots, antes de saírem da máquina.

Saiba mais

A plataforma