Shaded passages were held back from the public edition while the event ran.
Sunday was the best race the robot had ever run, and the day I decided to throw it away.
The race
All 15 checks came back CORRECT, the last one 92.3 seconds after the release, with zero rate limit hits. Four lanes were done inside 44 seconds.
- Mobile, Encrypted Strings: 6.6 seconds. Nothing new needed.
- Binary, Flow State: 18.6 seconds. Nothing new here either: 216 of 216 on the first try.
- Metadata, Frame of Reference: 22.6 seconds. An MP4 video, and the question wanted its width and height. The engine had never opened an MP4 and learned on the spot.
- Script, Orphan Process: 43.6 seconds. The hidden descriptor was chopped into pieces of an array and glued back together at runtime. Another thing learned live.
- Warmups, Off the Rails: 91.6 seconds. The title and the prompt (“Three rails. One very zigzag commute.”) said rail fence cipher out loud.
Mobile and binary ran on Saturday’s engines with no model and no help. Metadata and script each took one agent rule, the small piece of code an AI agent writes to teach the engine a new shape.
Warmups was the whole gap. The Single Solve needed a rail fence decoder, and the robot got one. Then the Mastery came back with its sentence cut into 18 lines, each in a different layer, and line 18 was the brand new rail fence. Our Mastery decoder had not expected the new layer there, and it stopped with no answer.
The maddening part is that the pattern had been sitting in front of us for three days. On Days 16, 17 and 18, the new layer in the Single Solve was the last line of the Mastery. Every time.
An agent wrote the Single Solve’s decoder. The Mastery stopped at 10.45 seconds; Opus fixed it offline, the lane reconnected to the same live attempt, and it went CORRECT at 09:01:32.
Two tenths of a second
I came out of Sunday 4th of 107 teams that finished all 15. From the public scoreboard, which stamps a hair before our own race clock:
- team.dev 45.5 seconds, secretNinja 79.1, Han Shot First 91.7, Wizdumb 91.9.
Off the podium by two tenths of a second. And the leader did the whole day in half our time.
Lane by lane, it was not even close to a disaster. Flow State and Encrypted Strings were 2nd on all three boards, behind team.dev each time. Orphan Process was 4th on all three. Frame of Reference was 4th on the Time Trial and Mastery, 9th on the Single Solve, where teaching it MP4 cost 14 seconds against the fastest. Then Off the Rails: 16th, 12th and 15th. team.dev banked that Mastery 6.7 seconds after release. Ours landed at 91.9.
Four lanes on or near the podium, one lane a minute and a half late, and that minute and a half was the whole day.
The call
About half an hour after the race I made the call: rebuild the robot from scratch, lean, starting now. Day 19 was 23 hours away, and it was bringing a sixth lane nobody had seen.
That sounds crazy. It was not.
The old robot had grown for nine days. Every lesson had become a rule, every rule a check, and every check a pause. It was correct, it was careful, and it was slow in every place between the solving. The leaders were not beating us at solving. They were beating us everywhere else.
So the old robot got frozen as it stood, kept runnable as a manual fallback, and a new one started next to it. The old engines and notes are the knowledge. Every line of code is new. One goal: every check CORRECT as soon after release as possible.
One design rule follows from that: if a check can run inside the next mode’s clock, nothing waits for it. The ledger, the robot’s log of every attempt, showed the clocks had been long since Day 15, 30 seconds to more than 5 minutes per mode, not the 6 to 10 seconds of the first week. A lane can open an attempt, keep it open while a fix lands, and finish it.
The build
By about 10:15 the design was frozen, and the robot sent builder agents at it several at a time, each one handed a written order for one piece.
Around 25 pieces: a fake Game Master (a local stand-in for the event’s server that plays back recorded days), a timing harness, the client, the release poller, a runner per lane, five lane solvers, the agent path, a scheduler.
Around midday I told it “You’re gonna run out of usage”, because it was burning through my limit way ahead of pace. It paused four pieces until the window reset and moved most of the builders to a lighter model. It also discovered its own sense of time had drifted: the timestamps in its notes were 30 to 140 minutes ahead of the real clock. It rebuilt the tracker from the git history. Lesson: read the clock, do not remember it.
By about 13:25 every piece was built.
The new solvers replayed every recorded attempt from Days 1 to 18, more than 1,200 of them, with zero wrong answers. Against the fake Game Master playing back Day 18 with the real recorded network delays, the new robot finished in 18.5 seconds. The old one did 25.3 on the same test, and 92.3 live. With no knowledge of Day 18 at all, letting the agents work it out live, it took about 22 to 24 seconds.
At 17:00 it ran its first real timed run on the live Game Master: Day 18 mobile, Single Solve 0.38 seconds, Time Trial 1.89, Mastery 2.70.
Not bad for something that did not exist at breakfast.
From there the rule for the rest of the build: no cutoffs, and every live rehearsal is free. Untimed retries and practice runs only, never a ranked attempt.
A second machine
The binary lane moves the heaviest files in the event: a Mastery carries five deliveries of about 32 MB each. My home connection has done fine, but every second counts now. So on Sunday evening binary moved to its own virtual machine in Azure, sized big and switched on only for the race window each morning.
Home runs the other lanes; the VM runs binary alone. If the VM goes quiet, home notices and takes binary back by itself. Both machines got their own timers for Monday: preflight at 08:30, race at 08:49 and 08:50.
I went to bed around 23:30 and left the robot a list: rehearse all of it, break it on purpose, and tell me in the morning. That night belongs to Monday’s entry.
How we built it: the Day 18 dev log
Why the knowledge carried and the code did not. The first decision of the morning was that solver knowledge carries over: the engines, the day modules, the notes, every answer the grader ever accepted. The second, half an hour later, was that the solvers get rewritten anyway, with the old code read only as reference. The bar for each new solver was the old one’s record: replay every day so far, nothing wrong, nothing rejected.
Why I stopped asking questions. The morning started as an interview, a round of questions for every piece. I stopped it: “I think I’m keeping too much control and decision making and not letting you make the decisions that will ultimately get me to the goal.” From there the robot made the design calls and wrote each one down with its reason, so I could veto. It asks me only about the account, ranked attempts, or a trade only I can weigh.
Why the builders went cheap. Watching my usage drop, I told it to put the right agents on the right jobs instead of throwing everything at the highest-thinking models, then pointed out that ten-plus were running at the highest effort. Every builder now gets its effort set and the cheapest model that can do the piece. Opus is kept for the hard parts: the clock path, concurrency, and the judge, the automatic test every patch must pass before it goes live.
Why rehearsals went free. Two rehearsals that afternoon spent four ranked Time Trials and four ranked Masteries on Day 18 before I caught it. A rehearsal is a test. Free runs prove the same plumbing, and the ranked ones belong to the board.
Why binary got its own machine. The binary Mastery was the one lane bound by the download, not the solve, and my home link has a ceiling. Measured that evening, four 33 MB files came down in 0.28 seconds on the VM against 3.68 at home. The other lanes’ files are small, so they stayed home, and home keeps a watchdog so a dead VM never costs the lane.
What we left alone. Whether the agents should run through the API directly or as Claude Code sessions was parked on purpose until the agent piece came up, so nobody would design around a guess. The commit gate, the checks every change must pass before it is saved, was switched off until the new robot had its own, because the old one now failed on a rule the old robot itself had kept. And the old robot was not deleted: it stayed runnable by hand as Monday’s fallback.