Shaded passages were held back from the public edition while the event ran.
Wednesday was seven challenges and 21 checks. The last one went CORRECT at 262.0 seconds after the 09:00 release: 2nd on the day, behind crash at 230.5, with _blackb3ard third at 348.1. Six of the seven were done inside 87 seconds, and we didn’t lose a single ranked attempt all day.
The seventh is the one I’ll remember. On the binary challenge, Family Resemblance, we had the Single Solve in at 141.9 seconds. crash had theirs at 204.3. We were 62 seconds ahead on the hardest challenge of the day. Then crash finished its Time Trial and Mastery in 26 seconds, and ours took two minutes.
09:00
Seven challenges dropped. In the order they finished:
- Back in Sixteen (warmups): a blob turned backwards and written in hexadecimal. All three modes by 8.2 seconds.
- Protocol Reconstruction (mobile): rebuild the protocol an app speaks to its backend, nonces and ordering rules included. All three by 8.7, first blood on every one.
- Out of Order (script): 1,703 questions about a zip of scripts themed on a cloud infrastructure timeline. All three by 14.7.
- Where It All Began (metadata): a raw disk image, and what its partition table says. All three by 27.6, first blood on the Single Solve and the Mastery.
- Fail Open Friday (web): an access check that says yes when it can’t read the question. All three by 53.6, first blood on every one.
- If a Breach Falls in a Log (web): an operation the audit log never records. All three by 86.1, first blood on the Single Solve and the Mastery.
- Family Resemblance (binary): a zip of 26 compiled programs and nearly 400 questions drawn from almost every binary day so far. Single Solve at 141.9, Time Trial at 212.3, Mastery at 262.0.
Ten first bloods out of 21. Warmups, mobile and script went through on the first try with the code the robot went to bed with. Metadata met a format it had never seen and had a reader for it inside 16 seconds. Both web challenges were new techniques, answered by hand on the Single Solve and carried into the timed modes. “By hand” here means a hand agent: an AI agent that works the question directly and sends the answer, instead of writing code.
Family Resemblance
Family Resemblance was a reunion. Every question came from a family the robot had met before: symbol counts, section counts, packer keys, which language runtime built a program. Mixed in were false friends, like an ELF question about a slot that actually held a Windows executable.
The robot’s own code answered about 377 of the 392 Single Solve questions straight away. The hand agents answered the rest one value at a time, and that’s where the minute went. A hand answer is a value, not a method. It’s right for the file in front of it and useless for the next file of the same kind, so every new file in the Time Trial and Mastery reopened the same questions from scratch.
crash, as far as we can tell from their times, carried a method. We carried a pile of answers.
Binary races on our cloud VM, a second copy of the robot on a machine closer to the download servers, so the VM was the first suspect. It wasn’t, or only by seconds. The big server delays hit home and the VM alike, and the real cost was agents:
| Phase | Agents | Downloads and server |
|---|---|---|
| Single Solve, 143 s | about 125 s | 8.5 s download, a 35 s resend |
| Time Trial, 63 s | about 50 s | 7 s download, one call dropped at 29 s |
| Mastery, 36 s | about 15 s | 14 s start call |
The home racer’s engine left exactly the same 31 questions open as the VM’s, so racing binary from home would have changed nothing.
An accident settled a worry along the way. At +128 seconds, home’s watchdog decided the VM’s binary lane had stalled (its state file hadn’t changed in 121 seconds while it was busy taking hand answers) and started a second binary racer at home. Both machines raced the same attempts to the end. No extra ranked attempt was spent, neither stepped on the other, and the 09:00 minute carried 319 calls with zero 429s, the server’s “slow down” refusal. When binary moved to the VM, the fear had been that two racers on one identity would trip the server’s limits. They don’t.
All race long I’d felt disconnected, like we couldn’t control or help what was happening out on the VM. Binary doesn’t need any particular network, so I asked why we couldn’t race it from both machines at once. Moving binary to the VM entirely had been the robot’s idea; I had wanted it in both places from the start. Once the numbers came back, I was sure. So that’s what we did.
The record
From the public scoreboard, Day 28, all 21 checks:
- Wizdumb 262.0 seconds, 2nd on the day. crash 230.5, _blackb3ard 348.1.
- First blood on 10 of 21 boards: every mode of Protocol Reconstruction and Fail Open Friday, plus the Single Solves and Masteries of Where It All Began and If a Breach Falls in a Log.
- 2nd overall, up from 4th, with crash the only team ahead.
The speed boards were a weak spot: no firsts, a 2nd on the Out of Order Mastery, and 3rds on the Out of Order Time Trial and both web Masteries. The Family Resemblance Time Trial sits 38th, because the hand answers that won us the Single Solve can’t be fast.
Show your work
Late that morning I had the idea that ran the rest of the day. So many of our solves were coming from the hand agents. What if they showed their work, as a patch, so the next solve didn’t have to start over?
That was exactly the gap. Now the hand agent writes down how it got every answer, as a small derive(path) function, and the moment the grader accepts one, a second worker, the deriver, turns that method into a patch (a small piece of code that teaches the solver the new shape). The judge, the automatic test every patch passes before it goes live, treats the accepted value as the truth, and a patch that reproduces it goes straight into the live solver. The next mode starts with the method, not just the value.
I was firm about how the deriver starts: with its own brief that tells it what’s going on and carries everything about the current challenge inline, so it never wastes a second getting its bearings. The Mastery must never have to wait for it to start from zero. Derivers spawn on every accepted Single Solve or Time Trial hand answer (never a Mastery one), run on Sonnet 5.5 with 120 seconds to work, and have no cap beyond a runaway guard. They landed through the full commit gate and an Opus review, which caught one real bug: the family match never fired on Mastery question ids.
Then we drilled it, free and live, on Family Resemblance. Before derivers, the Mastery took 55.9 seconds; with them, 30.6, and of 27 derivers in that run, 18 went live (median 24.3 seconds), 9 found the work already covered and none failed. Running the whole lane on the mock (a local stand-in for the event server that replays recorded days), with only what the robot knew before Day 28, Single Solve to Mastery went from 120.1 seconds to 55.0. Put the morning’s own Single Solve in front of that and it comes to about 197.8 seconds against crash’s 230.5. One run, so an estimate, not a result.
No waiting without a reason
In the afternoon I found something I didn’t like. The new code held the hand agent back while a deriver worked. I couldn’t see why we would ever stop a solver from solving, and once it was explained I had it taken out. Then I made it a rule: anything on the race path that holds or waits without a designed purpose, signed off by an advisor, comes to me.
Every wait got listed and put in front of me, and I picked: one gone, one set to zero, one changed to a short backoff, one moved to the back of the queue, and the rest kept, each with its reason written next to it.
Devastate the competition
Late in the afternoon the numbers finally added up in my head, and they didn’t add up well. We had been a minute ahead of crash on the binary Single Solve and still couldn’t turn it into a Time Trial and Mastery inside crash’s time. I asked straight out whether this was the shape the robot had in mind when it called derivers “the big one”.
It wasn’t. The drill said the new code would have beaten crash, but by a margin one run can’t promise. So I said what I’d wanted from the start. We were putting limits on ourselves, the robot more than me, when a few more agents working in a split loop could give us the best of both worlds. “I don’t want to just win tomorrows race. I want to devastate the competition!”
What followed was a design argument that ran until about 22:30, and it was the most useful stretch of the day. I wrote out how I understood the whole pipeline (solvers, hand agents, patch agents, derivers, judges) and asked to be told where I was wrong, because I was losing the picture. The drill had already shown where it jammed: the judges. One run had 46 of them going at once, and 22 crashed when a baseline file was deleted out from under them. As much as I love running things in parallel, we had to be prudent.
We landed on a shape. The hand agents should be directors, not hand agents: each lane gets a director with a live plan of the methods a challenge needs, and a shared pool of warm workers takes those methods on, with derivers as overflow and tickets as the safety net. At 22:28 I took the careful option for the morning, the waste fixes alone, and asked for the full plan system, directors and all, to be built overnight anyway, through an advisor review and an adversarial one, so we could see where it stood by 6 AM.
The waste fixes landed for Day 29. The plan system got built, but the overnight drills that should have judged it stalled, most likely on usage limits, and were thrown out. It never met a live agent.
Three days
A minute’s lead on the hardest challenge, and second place anyway. The robot’s helpers were answering questions when they should have been teaching the robot to answer them. That’s fixed now: an accepted answer turns into code on its own, before the next mode needs it.
Three days left, and one team between us and the top of the board.
How we built it: the Day 28 dev log
Spare lanes stay. On Tuesday night, after the organizer’s build screenshot (six categories, so no new lane before Day 31), I wondered whether to strip out the spare lanes, the standby tracks we keep warm for a challenge with no lane of its own. I left them in, in case a lane fails dramatically and we need to pick up with a warm set of agents.
The chart that confused me. A table showed home ahead on every step but the VM first on every mode. The answer was the accidental takeover: home’s racer only started at +128 seconds, so it was faster per step and still behind on the clock. Same evidence, two readings, and the reason the drills are scored from a fixed start.
Counting time once. I wanted every drilled day listed as estimated against actual, and a drill that fakes the Single Solve so the timed modes start from a real hand answer. An earlier estimate that added the morning’s server time back onto the mock counted that time twice, and was corrected.
The cap. For how long a deriver’s ticket should hold, I asked for the average time a patch takes to write, plus 25%. I don’t care about ranked time in the race; the overall clock is always running. It became 1.25 times the median derive time, about 29 to 36 seconds.
No limits on derivers. Their whole advantage is that they spawn on demand and get us ahead without slowing anything down, so nothing caps them now but a runaway guard. They spawn only from Single Solve and Time Trial answers, never a Mastery’s.
Batching isn’t the lever. I asked why we couldn’t batch more answers per call. The Mastery already sent 385 to 4,680 answers per call; its 82 single answers were agent answers, and the submits overlapped.