DrumsBench

Research notes / 2026-10-25

What Drums is, and what it is not

The hypothesis as written on 2026-10-15, the narrowed form of 2026-10-23, what a valid rollout is, and the list of things we are not claiming.

Drums is a question, not a product. The question is whether many computer-use training attempts can share one running computer, each with its own private state, at a lower cost per useful attempt than giving each one its own virtual machine. We do not know the answer. This note states the question precisely so that the rest of the site can be checked against it.

one virtual machine per attemptdrums: one shared runtimestateappsOSkernelVM 1stateappsOSkernelVM 2…stateappsOSkernelVM Neach attempt boots a computer:N x (kernel + OS + apps + state)a VM reset restores a disk andmemory image (tens of seconds,gigabytes per attempt)ABCD…Nprivate state capsule per attemptone running OS+ initialized appsone runtime, N private states:(kernel + OS + apps) + N x statereset = swap the capsule state(copy-on-write; base untouched)scoped state, not a security boundary
One booted operating system and one set of initialised applications, shared by many attempts, each with private state. This is the idea under test, not a system that exists.

The hypothesis, 2026-10-15 form

This is how the baseline document stated it:

Many computer-use RL environments can share one already-booted operating system and application runtime, each with private copy-on-write state, at a lower end-to-end cost per valid rollout than one virtual machine per environment, with zero observed cross-contamination between environments, measured next to a positive control that fired.

The same document opened with a framing we keep:

The need for many interactive environments is real in published systems. The case that Drums must exist is not established. Shared runtimes are already research prior art; microVMs already have sharing and reclamation paths; cheap Linux sandboxes and synthetic environments set a harder competitive bar. The missing number is end-to-end cost per verified useful rollout, including inference, failures and integration work.

The hypothesis, 2026-10-23 narrowed form

After a full read of the papers in the prior-art map (see prior art), we withdrew every claim that a mechanism was new. The current statement has three parts.

PartStatementStatus
Withdrawn"VM-free desktop" and "shared runtime plus copy-on-write branching, including a mid-trajectory fork" are published mechanisms (CUA-Lite, CUA-Sandbox). Drums claims neither as new.withdrawn
NarrowedA licensed, runnable integration (VM-free desktop, private state capsules, an RL-training socket) with better measured economics than the strongest runnable baseline. An engineering-and-evidence claim, not an invention claim.narrowed, defensible position, unmeasured
Candidate betDesktop state branching integrated into training: rollouts served from a branch that shares an executed prefix. The mechanism is published; its training-integrated economics are untested in every source we reviewed.candidate bet, hypothesis not finding

The macOS form of the same bet (experiment 1, designed 2026-10-20) is narrower still: on one Mac Studio, how many independent environments run with no VMs, at what cost per valid rollout, with zero observed cross-contamination, next to the same number from one Linux VM on the same Mac running N virtual displays. The fallback answer is written into the design in advance: "macOS N_max = 0 on build X, reason Y; Linux on the same Mac gives N." See desktop isolation on macOS.

Isolation and sharing pull in opposite directions. The bet is that a scoped boundary (files, clipboard, display, input, preferences) is enough for training correctness while the kernel, the window server and the application code stay shared. Nothing on this site shows that yet.

What "valid rollout" means

A rollout is one attempt at one task by an agent in one environment, from reset to final state. A rollout is valid when all of the following hold:

  1. The reset was verified before the first action: the work tree matched the golden manifest, the clipboard was empty, no leftover application was running.
  2. Every action was applied under the correct generation number. An action from a stale generation was refused, and the log shows it was never applied.
  3. Nothing timed out.
  4. The verifier ran and returned a result.
  5. Every isolation check that was active during the rollout stayed clean.

A verifier that says "task not done" is a task failure, and the rollout is still valid. An environment that could not be used (dirty tree, black screenshot, stale generation applied, verifier unreachable, a contamination event) is an environment failure: it gets its own line in the record, with a reason, and it is never scored as reward zero. See the rollout loop for why that distinction is the whole point.

VM per attemptattempt Aattempt Bstateappsown OSown kernelstateappsown OSown kernelhardware + hypervisorper attempt: 4 layersisolation boundary:hardware-virtualizedcontainer per attemptattempt Aattempt Bstateappsown rootfsstateappsown rootfsshared kernelper attempt: 3 layersisolation boundary:kernel namespacesshared runtimeattempt Aattempt Bstatestateinitialized apps sharedown OS userland, sharedshared kernelper attempt: 1 layerisolation boundary:scoped private state(not a security boundary)white strips are built again for every attempt; grey strips exist once on the host
Three ways to give an attempt a computer. One VM each duplicates the kernel and every application; a container shares the kernel; a shared runtime also shares the initialised applications. Each step down shares more and isolates less. Which step the workload can afford is the empirical question.

What we are not claiming