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 rate | Before training | After training |
|---|---|---|
| 32 held-out versions, 6 tries each | 0.54 | 1.00 (192 of 192) |
| 64 training versions, 2 tries each | 0.60 | 1.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
- We took our own control plane down. The run drove 128 desktops through our cloud gateway, which checks every request against a small central database. The database stopped answering under that load, and for about three and a half hours our console and every gateway, including production, were unavailable. The desktops themselves were fine; training continued only by talking to the host directly. The fix is a design change, not a bigger database: the data path must stop calling the control plane at all. That work is under way.
- Six updates in eight hours. The first four optimizer steps took about 15 minutes each. Then the model got good enough that most groups of attempts all succeeded, and the training method throws those groups away because there is nothing to learn from them. Step 5 discarded 93% of attempts, step 6 discarded 98%, and the last step alone consumed about 7,900 desktop attempts. A 64-version task family is too small for eight hours of training. The next study uses a much larger pool.
- Our cloud GPU provider preempted the training container 43 minutes in. The run resumed from its last checkpoint on a different GPU type. Trained time, not wall-clock time, was the budget, so the eight hours held.
- We restarted a gateway during an evaluation. 47 attempts errored. The frozen plan said what to do with an incomplete evaluation: repeat it once in full and use the repeat. That is the number above. The first, incomplete run read 0.48 instead of 0.54.
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.