Runtimes

Glue runs commands through a CommandExecutor + Workspace abstraction chosen at startup by the RuntimeFactory. Today that's your host shell, an ephemeral Docker container, or one of three cloud sandboxes — Daytona, Sprites (Fly.io), or Modal.

Canonical source: docs/reference/runtime-capabilities.yaml.

The ladder

host → Docker → Daytona / Sprites / Modal

• Host shipping — fastest; uses your tools, your env.
• Docker shipping — ephemeral containers for risky or messy work. Sandbox polish is experimental.
• Daytona shipping — clean REST API; per-sandbox toolbox URL discovered automatically; US + EU regions.
• Sprites shipping — persistent Fly.io sandbox driven via the sprite CLI; auto-sleeps when idle, resumes by name.
• Modal shipping — Modal sandbox via an embedded Python sidecar; sandbox auto-terminates on a configurable timeout to cap billing.

Capability matrix

What each runtime can do today. Cloud-provided browsers + session artifacts are tracked separately.

Runtime	command_capture	command_streaming	background_jobs	filesystem_read	filesystem_write	mount_host_paths	browser_cdp	artifacts	secrets	snapshots	internet	gpu
host shipping Runs in your shell on your machine.	✓	✓	✓	✓	✓	✓	◐	✓	—	—	✓	✓
docker shipping Ephemeral container; workspace mounted in.	✓	✓	◐	✓	✓	✓	◐	✓	—	—	✓	◐
daytona shipping REST API; workspace bootstrapped via git clone into /workspace.	✓	✓	✓	✓	✓	—	◌	◌	—	✓	✓	◌
sprites shipping Persistent Fly.io sprite via `sprite` CLI; auto-sleeps when idle.	✓	✓	✓	✓	✓	—	◌	◌	—	✓	✓	◌
modal shipping Modal sandbox via embedded Python sidecar; capped by sandbox_timeout_seconds.	✓	✓	✓	✓	✓	—	◌	◌	—	—	✓	◌

✓ yes◐ partial◌ planned— no

Choosing a runtime

• Default to host. Fastest feedback loop, direct access to your tools.
• Switch to Docker when you're about to run code you haven't audited — third-party dependency installs, generated scripts, anything grabbing network resources you don't recognize. The container goes away when the session ends.
• Reach for a cloud runtime when the work shouldn't touch your host at all — scraping at volume, suspicious artifacts, long-running agent jobs, or workflows that need to keep state between sessions:
  • Daytona — clean REST API, fast to spin up, persistent FS, US + EU regions, snapshot-based. Best general-purpose cloud sandbox.
  • Sprites — persistent Fly.io VM. Resumes by name; auto-sleeps when idle so you only pay for active wall-clock. Great when one named sandbox should outlive several glue sessions.
  • Modal — runs inside a real Modal App, so you can reuse the same image and Python deps your other Modal functions use. Sandbox auto-terminates on sandbox_timeout_seconds — cheap insurance against runaway billing.

Configuring runtimes

Pick a runtime with runtime: in ~/.glue/config.yaml, then add the matching per-runtime block. GLUE_RUNTIME and per-adapter env vars override config values.

Docker

~/.glue/config.yaml — Docker

runtime: docker
docker:
  enabled: true
  image: ubuntu:24.04
  shell: sh
  fallback_to_host: true
  mounts:
    - /abs/path/to/workspace

fallback_to_host: true keeps the session usable if Docker isn't running locally — the executor drops back to host with a visible notice instead of failing.

Docker sandbox guide →

Daytona

~/.glue/config.yaml — Daytona

runtime: daytona
daytona:
  api_key: env:DAYTONA_API_KEY
  # api_base_url: https://app-eu.daytona.io/api   # EU region; defaults to US
  # snapshot: my-snapshot-id                       # org default if omitted

Set DAYTONA_API_KEY in your environment. Glue calls the control plane to create a sandbox, discovers the per-sandbox toolboxProxyUrl from the create response, and uses it for every exec / FS call after that.

Daytona guide →

Sprites

~/.glue/config.yaml — Sprites

runtime: sprites
sprites:
  # sprite_name: my-sandbox      # reuse a named sprite across sessions
  # delete_on_close: false       # keep the sprite after the session (auto-sleeps)

Requires the sprite CLI on $PATH and sprite login once. Glue generates a unique sprite name per session unless sprite_name is set.

Sprites guide →

Modal

~/.glue/config.yaml — Modal

runtime: modal
modal:
  app_name: glue
  # image: python:3.12-slim
  sandbox_timeout_seconds: 1800

Requires modal on $PATH, the Python modal package importable, and modal token set run once. The sandbox auto-terminates after sandbox_timeout_seconds even if glue exits uncleanly — caps runaway billing.

Modal guide →