Docs

Questa pagina non è ancora tradotta in italiano: eccola in inglese.

Glac runs OCI images in Firecracker microVMs: each instance is a microVM of its own, which sleeps when it is idle and wakes when something needs it. Cube runs images as services at an address of their own, each one a Cube (an app, in the API), whose instances sleep when no requests come; its Volumes (Drives, in the API) are disks that outlive the instances that use them. The Managed Applications run on Cube: Sandbox, machines for AI agents to run commands in, and Browser and Database, not open yet. Start with getting a key; the platform’s pages say how Compute, regions, addresses, projects, logs, pricing and limits work, and each product has an overview, a quickstart and the pages that say how it behaves.

Start

• Get started: Make an account and an API key, install the glac command line or an SDK, and take a first step with each product.

Platform

• Compute: What every product runs on. Any OCI image, each instance a Firecracker microVM of its own; instances with a key or without, when an instance sleeps and what wakes it, and how Cube and Sandbox sit on it.
• Regions: The three regions, na, eu and ap; where sandboxes, Cubes and Drives are made; what happens when a region cannot take something; and how traffic is priced by region.
• Addresses: The addresses of Cubes, sandbox links and your own domains, through the proxy in front of the platform (TLS, DDoS protection, caching) or direct to it, and the proxy’s limits.
• Networking: How traffic reaches a sandbox or a Cube and how it leaves. Addresses through the proxy and direct, SSH, the project’s private network, a sandbox’s own IPv6 address and the ports open at it, network rules, and what is billed.
• Projects and keys: An account pays, has members and is mailed its notices at a verified address; its projects hold everything else. API keys belong to one project and have scopes; tokens open one sandbox; the console signs people in.
• Logs, metrics and traces: A Cube’s log in one stream (what its instances print, one line per request, what the platform did), its metrics, the platform’s span of each request, and their export to any OpenTelemetry receiver.
• Pricing and plans: The two plans, Free and Paid, what each includes, the one price list every product is billed by (traffic by region and Drives among it), and how the balance, top-ups, auto reload and spend limits work.
• Limits: What each plan lets an account have at once and keep, how fast it may make things, and the limits of the API itself.
• Raising a limit: Which of a plan’s limits we raise for one account on request, and how to ask.

Cube

• Cube: Run any OCI image as a Cube, a service at its own address (an app, in the API). Instances start when requests come and sleep when they stop; every deploy is a version you can roll back to.
• Cube quickstart: Deploy an image as a Cube, change it, look at its log and roll it back, with the glac command line, the Python SDK or the console.
• Deploys and versions: Every deploy of an app makes a version, which takes the traffic once it is built and ready. What a version is made of, what happens when one fails, and how to roll back.
• Instances and scaling: An app’s instances start when requests come, sleep when they stop, and are deleted after a while asleep. How many there are, where they run, and how to keep work going after a response.
• Keyed instances: One instance of an app per key (a user, a session, a tenant), made the first time the key is seen and kept with its memory and disk for every later request with the same key.
• Addresses and protocols: A Cube’s default address under glac.run, your own domains, Cubes with no address on the internet, and the protocols that reach an instance.
• Services and Compose: Every app is a service of its project. Services find each other on the project’s private network, share variables, deploy together, keep data on a Drive, and can be imported from a Compose file.

Sandbox

• Sandbox: A machine of its own for each AI agent, user or job, made from any OCI image in milliseconds. Run commands, read and write files, open a terminal; it sleeps when idle and wakes with its processes running.
• Sandbox quickstart: Make a sandbox, run commands in it, copy files, open one of its ports, snapshot and fork it, with the glac command line, the Python SDK or the console.
• Commands, files and terminals: Making a sandbox from any image, running commands and reading their output, reading and writing files, and terminals.
• Sleep and wake: When a sandbox goes to sleep, what wakes it, how a program inside keeps it awake or is told before it sleeps, restarts, and deletion after a long sleep.
• Snapshots and forks: A snapshot saves a running sandbox’s memory, processes and disk; a sandbox can go back to one, start from one, or fork into copies that each go on from this moment.
• Links, tokens and SSH: Links to a sandbox’s ports that are their own credential, public ports, tokens that open one sandbox for a while, and SSH with your own keys.
• Network rules and secrets: What a sandbox may reach on the internet, which requests it may send to a host, and secrets added to its requests on the way out so the code inside never holds them.

Browser

Not open to accounts yet: these pages say how it works as it is built.

• Browser: Hosted Chromium sessions that Playwright, Puppeteer or any other client of the Chrome DevTools Protocol drives from outside. A session is awake while a client is connected, and sleeps with its pages when the last one leaves.
• Sessions: The calls of /v1/browsers, what a session is made with and what it has, names that find a session again, when it is awake and asleep, new addresses, and its network.
• Live view and profiles: Watching a session’s page live, and an address of it for people who may only look; a session’s profile, its cookies and storage, kept by the platform and loaded into new sessions.

Drive

• Drive: Disks of a project that outlive the sandboxes and Cubes that use them. One sandbox writes a Drive at a time; it is copied to its region’s object store as it is written, so any machine of the region can mount it.
• Drive quickstart: Make a Drive, write to it from one sandbox, and read it from the next, with the glac command line, the Python SDK or the console.
• How Drives work: Mounting a Drive in a sandbox or a Cube, the one writer it has, where it is kept, what is billed, and what a project may keep.
• Drive snapshots and forks: A snapshot keeps a Drive as it was at one moment, as a version in its region’s object store, without copying it. The Drive can be restored to it, a new Drive forked from it, and any number of sandboxes can mount it read-only.
• Shared volumes and backups: Volumes are the disks underneath Drives. A shared volume is a file system several sandboxes of one machine mount at once; backups copy a volume into the object store, and a new volume can be made from one.

Database

Not open to accounts yet: these pages say how it works as it is built.

• Database: Managed Postgres (16, 17 or 18) for a project, on its private network, that sleeps when nothing asks anything of it and wakes with a connection. Made of a Cube’s stateful service and a Drive, which the database changes alone.
• PostgreSQL: What a database runs: PostgreSQL 16, 17 or 18 with pgvector, PostGIS, TimescaleDB, pg_cron and more, the extensions its owner may create, the roles, how a new database begins, and the settings the platform keeps.

Tools

• The glac command line: One executable for every product of Glac (Cube, Sandbox, Drive) and for the project, its secrets and its bill, for people at a terminal, scripts in CI and coding agents.
• Python SDK: The Python SDK, one client with a namespace for each product (Cube, Sandbox, Drive) and the platform’s own calls. Standard library only, Python 3.9 and later.
• TypeScript SDK: The TypeScript SDK of Glac, one client with a namespace for each product (Cube, Sandbox, Drive), for Node 23.6 and later, with no dependencies (fetch, WebSocket and node:crypto).
• Go SDK: The Go SDK, one client with a field for each product (Cube, Sandbox, Drive). Standard library only, Go 1.21 and later; context first, errors as values, functional options.
• Rust SDK: One client, with a namespace for each product (Cube, Sandbox, Drive) and the platform’s own calls on the client itself. Blocking calls that return Result, chained options, four dependencies and no async runtime.
• Java SDK: The Java SDK, one client with a namespace for each product (Cube, Sandbox, Drive) and the platform’s own calls. Java 17 and later, on the JDK’s own java.net.http, with no dependencies.
• MCP server: Give an AI agent Glac’s products as tools, Cubes to deploy and sandboxes to work in, in Claude Code, Claude Desktop, Cursor or any Model Context Protocol client.

Reference

• API reference: every call of the API, by product, with its fields and its answers.
• Errors: The shape of every error, where its docs_url leads, and what to do about the refusals that send you here (a plan’s cap, a project’s Drives and volumes, an account on hold, a locked user) and a few others about money.