Cube

Volume

Disks that outlive their instance

Cube’s disk, apart from any instance: all its data in tiered storage, as much of it on the machine’s NVMe as you choose.

Read the docs

a GB-month of data, with none of it cached: $0.02
a GB-month all on NVMe: $0.08
to write or read: $0

In three steps

The same calls from the command line, the API, the SDKs and the MCP server, where a volume is a drive.

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
AUTH="Authorization: Bearer $GLAC_API_KEY"

from glac import DriveMount, 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

Make a volume

Only the data written to it is billed.

glac drives create --name data \
  --size-bytes 10GiB

curl $API/drives -H "$AUTH" \
  --json '{"name": "data", "size_bytes": 10737418240}'

drive = glac.drives.create(name="data", size_bytes=10 << 30)

const drive = await glac.drives.create(
  { name: "data", sizeBytes: 10 * 2 ** 30 });

drive_create {"name": "data", "size_gib": 10}

Mount it, and write to it

In a sandbox, at a path of your choosing.

glac sandboxes create --name web \
  --drive data:/data
glac sandboxes exec web -- \
  sh -c 'echo kept > /data/note'

curl $API/sandboxes -H "$AUTH" --json '{"name": "web",
  "drives": [{"drive": "data", "path": "/data"}]}'
curl $API/sandboxes/web/run -H "$AUTH" \
  --json '{"command": "echo kept > /data/note"}'

mount = DriveMount("/data", drive)
sbx = glac.sandboxes.create(drives=[mount])
sbx.run("echo kept > /data/note")

const mount = { path: "/data", drive: drive.id };
const sbx = await glac.sandboxes.create(
  { drives: [mount] });
await sbx.files.write("/data/note", "kept\n");

drive_attach {"drive": "data", "sandbox": "web",
              "path": "/data"}
sandbox_run {"sandbox": "web",
             "command": "echo kept > /data/note"}

Pass it on

To the next sandbox, with what it holds.

glac drives detach data web
glac sandboxes create --name next \
  --drive data:/data
glac sandboxes exec next -- \
  cat /data/note

curl -X DELETE $API/sandboxes/web/drives/data -H "$AUTH"
curl $API/sandboxes -H "$AUTH" --json '{"name": "next",
  "drives": [{"drive": "data", "path": "/data"}]}'

glac.drives.detach(sbx, drive)
nxt = glac.sandboxes.create(drives=[mount])
print(nxt.run("cat /data/note").stdout)

await glac.drives.detach(sbx, drive);
const nxt = await glac.sandboxes.create(
  { drives: [mount] });
console.log(await nxt.files.readText("/data/note"));

drive_detach {"drive": "data", "sandbox": "web"}
drive_attach {"drive": "data", "sandbox": "next",
              "path": "/data"}

A volume is one sandbox’s at a time, until it is detached. A Cube with a volume has one instance.

What it does

Writes and cached reads at NVMe speed, as much of it cached as you choose.
Billed by its data and its cache, hour by hour, never by its size or its reads.
Every write in tiered storage within a second, sent out every 250 ms.
Mounted on any machine of its region, its blocks following as they are read.
Snapshot a volume, fork it or restore it, with nothing copied.
One snapshot, read-only in many sandboxes at once, for weights and datasets.

Read the docs

Illustrative previews

Which way to keep state

Three ways the platform keeps what a program has, and what each is for.

	Keeps	For
Sleep	Memory, processes and disk, as they were	An instance or a sandbox between uses
Snapshot	A whole sandbox at a moment	Going back, or starting many from one
Volume	A disk, apart from any instance	Files that outlive their instance: databases, workspaces, datasets

Built for

Databases on Cube

Postgres, MySQL or Redis in a Cube, with its data on a volume.

glac drives create --name data \
  --size-bytes 5GiB --region eu
glac deploy redis:7 --name cache \
  --port 6379 --public false \
  --region eu --drive data:/data

Workspaces that move

An agent’s files follow its sandbox to any machine in its region.

glac drives detach work old
glac drives attach work new:/work
glac sandboxes exec new -- ls /work

Caches that last

Package and build caches kept from one sandbox to the next, so each run starts warm.

glac drives create --name deps \
  --size-bytes 20GiB
glac sandboxes create --name ci \
  --drive deps:/root/.cache

Prices and limits

mssecondhourmonth

Billed by its data and its cache, hour by hour; never for writing or reading it. All prices and plans

What is counted	How	Price
Data¹	All a volume holds, kept in tiered storage	$0.00000761 / million GB-ms$0.00000000761 / GB-second$0.0000274 / GB-hour$0.02 / GB-month
NVMe cache¹	The part on the machine’s NVMe, the size you set; no write or read fees	$0.0000228 / million GB-ms$0.0000000228 / GB-second$0.0000822 / GB-hour$0.06 / GB-month

A month, priced

100 GB all month, cached three ways. Writing and reading it cost nothing.

All on NVMe
$8.00
100 GB × ($0.02 + $0.06)
Every read at the NVMe’s speed.
Balance, 25% cached
$3.50
100 GB × $0.02 + 25 GB × $0.06
25% on NVMe; the rest read at the network’s speed.
None cached
$2.00
100 GB × $0.02
Every read at the network’s speed.

What the plans allow

Every limit of each plan

	Free	Paid
Volumesin a project	3	500, more on request
Largest volume	10 GiB	1 TiB
All volumes togetherin a project	15 GiB	No limit

Up to 16 TiB a volume for an enterprise account, by arrangement. An instance mounts at most 8 volumes.

How your data is kept

Written on its machine first, and copied out to tiered storage as it is written.

On the machine first
Writes land on its NVMe; reads of what it holds never leave it.
Copied out within a second
Sent every 250 ms; writes wait once the oldest unsent is 900 ms old.
What losing a machine costs
It comes back as it was a moment before. A sandbox’s disk, copied the same way, lost at most 1.0 s of writes over 41 losses.
One writer at a time
One machine holds its lease, and stops writing if it cannot renew it.
Sealed with your key
Your project’s key on every megabyte of it, with AES-256-GCM.
One home
Kept in one data centre, and in no second region unless it moves.

Read on

The platform