Build and test environments, booted in 10 ms
Pack a large environment into a template once. Boot any number of copies in under 10 ms, inject your code as a ROM, run, then scale to zero and resume exactly where it stopped.
Includes $50 in usage credits. No card required.
Pack the environments your team needs:
Use cases
Built for CI owners, test-infra teams, and agent developers.
CI builds
Give every commit a warm machine. The template already holds your toolchain, caches, and daemons, so the first compile starts immediately.
Test fleets
Shard a suite across a thousand copies of the same snapshot. Identical baselines mean a flake is a flake, not dirty state.
Agents and RL
Fork rollouts from one memory image with the same starting state, pause episodes at storage cost, and resume them in 10 ms.
Each environment is a full VM snapshot with memory included. Changes persist while it runs and reset when you boot a fresh copy from the template.
Pack, boot, inject, run, resume
The heavy thing happens once. Everything after that is milliseconds.
Snapshot the whole VM, memory included: toolchains, caches, services, warmed daemons.
Restore plus copy-on-write, not a boot sequence. A thousand copies, same latency as one.
Your checkout or test shard arrives as a ROM, a read-only bundle mounted into the running machine.
A real machine with a real Docker daemon. Logs stream and persist, exec sessions reconnect.
Kill it, or scale to zero and pay storage. Resume returns the same machine, processes intact.
Templates hold the weight, ROMs carry the change
Templates
the heavy thing, made onceA template is a full VM snapshot: filesystem, memory, running processes. 30 GiB of toolchain boots as fast as an empty VM, because nothing initializes. It is already initialized. Build one from a Dockerfile, a compose stack, or a live machine you set up by hand.
ROMs
the changing thing, made per runA ROM is a read-only, content-addressed bundle: your checkout, a dependency delta, a test shard, a config. It mounts into a booted template in milliseconds and is cached forever by hash. Same code, same ROM, no rebuild.
templates × ROMs = one warm base, thousands of variants
Pack the environments your team needs
Thousands of distinct templates per org. Every one resumes to the exact state you packed.
pnpm store, turbo cache, and playwright browsers, warm.
Gradle daemon running, dependency cache primed.
target/ primed, sccache hot, clippy ready.
CUDA 12.8, venv resolved, datasets staged on disk.
SDK 35, emulator snapshot booted, Gradle warm.
Chromium, Firefox, and WebKit with video capture.
Postgres 16 seeded, fixtures loaded, migrations run.
3-node k3s with Helm charts installed and images pulled.
These are examples. Any Dockerfile, compose stack, or live machine can become a template.
Let your CI set itself up
Three commands: pack, boot, resume. Everything is scriptable and everything returns machine-readable state.
Get $50 in free usage
No card required. $20 arrives on sign up and the remaining $30 when your first template is packed.
$ numinous template pack ./build-env --name node-monorepo ok: tpl_9f2 packed (18.4 GiB, memory included) $ numinous boot tpl_9f2 --rom git@abc123 --count 512 ok: 512 environments ready in 9.4 ms (p99) $ numinous suspend env_7bd ok: suspended · $0/hr compute · state retained $ numinous resume env_7bd ok: resumed in 8.1 ms · processes intact
Priced like hardware
Per-second billing on published rates. Everything is non-preemptible: your environment is never evicted, migrated, or throttled mid-run.
per vCPU-hour, billed per second
per GiB-hour, up to 256 GiB per environment
visible capacity, reservable ahead of a sweep
seconds lost to provider errors are never billed
H100 and H200 at market rate, exact SKU, never interruptible
per GiB-month, content-addressed and deduplicated
per GiB, free to your own in-region S3 bucket
per GiB-month of captured state
No preemptible tier, no spot evictions, no multipliers. One rate, one lane, always yours.