Drums

Our first real training run on Drums

Eight hours, one model, one task family, every desktop ours. What it learned, what broke, and what the number does and does not mean.

November 17, 2026

Until now we had measured Drums as an environment: how much memory a desktop takes, how fast it resets, how many fit on a server. Those are environment numbers. This post is about the other half: whether a model actually gets better when it trains on our desktops. We ran that test the way a customer would, wrote down the pass mark before we started, and are reporting what we got.

What we did

We took a public 27-billion-parameter model (Qwen3.5-27B) and a public training toolkit (prime-rl), and trained the model with reinforcement learning for eight hours of GPU time. The task family was one we wrote ourselves: “collect every file whose name starts with a given prefix from a folder tree into a new folder, renaming each copy”. A generator makes versions of it with different prefixes, trees, target folders and renaming rules, and a checker looks at the files afterwards and says pass or fail.

The model trained on 64 versions. We held back 32 other versions, made from a different seed and checked for zero overlap with the training ones, and never showed them to the model during training. Every desktop the model touched, about 9,000 attempts in all, ran on one Drums worker host.

Before launching we froze the plan: what counts as success, which 32 versions decide the result, the statistics, and the budget. One look at the result, no re-rolling.

The result

Success rateBefore trainingAfter training
32 held-out versions, 6 tries each0.541.00 (192 of 192)
64 training versions, 2 tries each0.601.00 (128 of 128)

On the versions it had never seen, the model went from solving about half to solving all of them. The paired difference is +0.46 with a 95% confidence interval of 0.38 to 0.55, which clears the pass mark we set (an interval that excludes zero) by a wide margin.

The model also changed how it works. Before training, a typical attempt used 15 turns, the maximum we allowed, and took 161 seconds. After training, a typical attempt used 8 turns and took 62 seconds.

What this does and does not show

It shows that the whole loop works end to end for a real job: public weights, a public trainer, our task factory and checker, our desktops. And it shows the model generalised within the task family rather than memorising 64 examples.

It does not show that a model trained on Drums learns faster or cheaper than on anything else: there was no comparison arm. It does not show transfer to other apps or other task families: this was one family in one app, one run, one seed. And a perfect score on versions of a task the model had already saturated is not evidence about hard tasks. The environment results from October and this training result are two separate claims, and we intend to keep them separate.

What went wrong

The fine print

Full-parameter GRPO, learning rate 3e-6, groups of 8, 128 samples per step, eight H200 GPUs (six training, two serving), temperature 0.8 throughout. Success is the checker's verdict on the files; attempts where the desktop or the task itself failed are not counted as episodes. The statistic is a paired bootstrap over the 32 held-out versions, 10,000 resamples. The whole run, including the evaluations and the host, cost about 500 dollars at list prices. The frozen pre-registration, every evaluation record, the analysis script and the training config are on bench.drums.run; the run log and the audit of our own product (37 findings) are internal for now.

Talk to us