Skip to content

Managed Applications

Sandbox

A computer of its own for every agent

A microVM your code or your agent drives through the API. Run commands, open a terminal, save it whole and fork it; left idle, it sleeps.

Read the docs

Sandbox in numbers

faster CPU than the median provider1
68%
to wake a sandbox2
3.5 ms
to snapshot a running sandbox2
32 ms

In three steps

The same calls from the command line, the API, the SDKs and the MCP server.

Before you start

Put your API key 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-mcp

  1. Make one

    A machine of its own, from any 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. Run in it

    Commands and files, for as long as they take.

    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. Save it whole, and fork it

    Memory, processes and disk, into copies that go on from there.

    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}

Its name works wherever its id does. There is no wake call: whatever needs a sleeping sandbox wakes it.

What it does

  • A terminal, a link to any port, or SSH, all through an agent inside it.

  • Snapshot it while it runs, go back in place, or fork up to 64 copies.

  • Booted once, already running in every copy.

  • Secrets your code never holds: they are put in on the way out.

  • Any OCI image, or ours with five languages and coding agents ready.

  • Asleep after 30 seconds idle, with everything in it; a command wakes it.

Read the docs

Illustrative previews

Built for

  • Code interpreters

    Run the code a model writes, with its variables kept between calls.

    from glac import CODE_INTERPRETER
sbx = glac.sandboxes.create(
    image=CODE_INTERPRETER)
sbx.run_code("x = 1")
print(sbx.run_code("x + 1").text)

  • Coding agents

    Claude Code and other agents, each in a machine of its own.

    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")

  • Trying many paths

    Fork a sandbox mid-task and let each copy try something different.

    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)

Prices and limits

Billed by the Cube resources it uses, as every product is. All prices and plans

What is countedHowPrice
CPUBusy CPU time, by the millisecond$0.01 / million CPU-ms$0.00001 / CPU-second$0.036 / CPU-hour$26.28 / CPU-month
MemoryHeld, by the millisecond, in 128 MiB steps$0.00222 / million GiB-ms$0.00000222 / GiB-second$0.008 / GiB-hour$5.84 / GiB-month
RequestsPer request into a Cube or through a sandbox link$0.30 / million
Traffic outNA · EUPer GB leaving North America and Europe$0.004 / GB
Traffic outAPACPer GB leaving Asia-Pacific$0.01 / GB
Kept asleep3What sleeping instances keep, and snapshots$0.00000761 / million GB-ms$0.00000000761 / GB-second$0.0000274 / GB-hour$0.02 / GB-month

Estimate a month

A real workload, and what its month comes to on Paid and on Free.

An agent builds and ships software on its own machine, a workday at a time.

A 30-day month, this workload alone on the account. Sources

A month on Paid

$356.97

$0.16 a session

  • CPU8.6B CPU-ms$86.17
  • Memory29K GiB-h$228.80
  • Data stored2,000 GB-months$40.00
  • Traffic out300 GB$1.20
Usage at the list prices
$356.17
Included in Paid
−$4.20
Paid’s fee
$5.00

Past what Free allows: the instance’s size, CPU, memory, data stored and traffic out.

Billed by size, every second awake10.4× more

Glac$356.17

By size$3,702.00

What the plans allow

Every limit of each plan
FreePaid
Largest sandbox2 vCPUs, 4 GiB8 vCPUs, 16 GiB
Awake at oncesandboxes and Cubes’ instances5500
Kept asleep2010,000
Made in a minute10600
Made in an hourby one project20010,000

Kept apart

It runs what a model wrote, so each is a machine of its own, reached only the ways you give.

Security

  • A microVM of its own

    A Firecracker microVM with its own kernel, booted from your image.

  • A jail around it

    An empty root, a user with no privileges, its own limits.

  • Reached through the API

    Commands and files go through an agent inside it; it has no public IPv4 address.

  • Links that are the key

    A signed link opens one port; change the secret and every old link stops.

  • Secrets it never holds

    Put into its requests on the way out, only to the hosts they are for.

  • Sealed with your key

    Its disk, its memory while asleep and its snapshots, before they leave the machine.

Read on

The platform

Cube

Managed Applications