Use case · Evals & RL

Set up once. Fork for every rollout.

Prepare an environment, then fork the running VM, memory included, into as many identical copies as your eval or RL run needs. Pay per second for each copy, and half price in the EU night window.

  • Fork with memory < 2 s (target)
  • Batch −50%
  • Per-second billing, $0 while paused
  • Full VM: root, Docker, own kernel

Why fork beats re-provisioning

Most eval harnesses spend more time building the environment than running the task: cloning repos, installing dependencies, warming caches, starting services. Fork copies a VM that already did all of that.

< 2 S · TARGET

Fork a running VM

Copies disk and RAM, so services are already running and caches are warm in every child. Children are independent VMs: changes in one do not affect the others.

IDENTICAL START STATE

Reproducible rollouts

Every rollout starts from the same memory snapshot: same processes, same files, same seeds you set before forking.

FIRECRACKER · OWN KERNEL

Safe for model-written code

Each child is a microVM with its own kernel, network namespace and cgroup limits. Docker works inside, so SWE-style tasks can run their own containers.

−50% · 22:00–07:00 CET

Batch pricing

Jobs started in the EU night window, or flagged priority: "batch" at any time, are billed at half price. Batch jobs may wait in a queue.

PER SECOND

Pay for the rollout, not the fleet

A 6-minute rollout costs 6 minutes. Pause the parent between runs at $0 compute; its snapshot is kept free for 30 days.

SCREENSHOT < 300 MS · TARGET

Computer-use evals

The desktop template gives each copy an XFCE desktop with screenshot and input APIs for agents that operate GUIs.

Sketch

One prepared parent, N forked rollouts

One call forks up to 50 children from a single capture of the parent (more on request). Admission is all or nothing: either every child starts or none is created. Add priority: "batch" to queue them at the batch rate. Shown with the TypeScript SDK as documented in the docs; the API is in private beta and may change.

import { Client } from "@dormo/sdk";
const client = new Client();

// 1. Prepare the environment once
const base = await client.sandboxes.create({ size: "default", priority: "batch" });
await base.exec({ command: "git clone https://github.com/acme/repo && cd repo && make deps" });

// 2. Fork it, memory included: 32 rollouts in one call, all or nothing
const children = await base.fork({ count: 32, labels: { run: "eval-17" }, ttl_seconds: 3600 });
const results = await Promise.all(children.map(async (child, i) => {
  try {
    return await child.exec({ command: tasks[i].command, timeout_seconds: 600 });
  } finally {
    await child.delete();   // billing for this copy stops here
  }
}));

// 3. Keep the base for the next run at $0 compute
await base.pause();

Worked example: 2,000 rollouts of 6 minutes

200 VM-hours of default (4 vCPU / 8 GB) per run. Compute only, at list prices.

Compute cost of 200 VM-hours of 4 vCPU / 8 GB
OptionPrice / hCost per run
Dormo, batch (−50%)$0.015$3.00
Dormo, on demand$0.030$6.00
E2B / Daytona list price$0.331$66.20
Modal list price$0.760$152.00

Competitor prices: on-demand list prices for 4 vCPU / 8 GB per hour per battleships.dev, as of 2026-10-14; check E2B, Daytona and Modal before deciding. Excludes environment setup time, which fork avoids on our side but which we do not model here. Modal and Daytona offer GPUs; we do not.

Run your own usage export

Harness integrations

Many eval and agent harnesses already have pluggable sandbox backends. We plan to contribute Dormo backends to OpenHands, Harbor (Terminal-Bench) and SWE-ReX. None of them has shipped yet. If you use one of these, or another harness, tell us in the waitlist form so we build the right one first.

Is fork a copy-on-write clone or a full copy?

The child starts from the parent's memory and disk snapshot and then diverges independently. Implementation details and measured fork times will be published with the beta; < 2 s is our target.

How many forks can run at once?

Concurrency depends on the plan: 2 VMs on Free, 10 on Starter, 1,000+ on Team. One fork call creates up to 50 children; larger runs: talk to us.

When does the batch discount apply?

To jobs started between 22:00 and 07:00 CET, or to jobs created with priority: "batch" at any time. Batch jobs may be queued until capacity is free.

Do you have GPUs?

No. Dormo VMs are CPU-only. Keep inference with your model provider and run the environment with us.