Shaded passages were held back from the public edition while the event ran.
Before bed on Friday I changed how I wanted the robot to think about every run. There is no such thing as a wasted run any more. The only number that counts is the time from the 09:00 release to all 15 checks CORRECT.
Around one in the morning I also switched on the agent race: ten AI agents, a cheap, fast pair per lane, waiting for Day 17. When a lane meets something its code cannot read, both agents race to write the fix, and the first one that works wins.
The good part
Four lanes were done in 33 seconds.
- Script, Fetch Quest: 13.7 seconds. 1,139 of 1,139 on the first try, five seconds in, with no new code at all.
- Mobile, Name Collapse: 25.7 seconds. A new encoding where each piece of data says which position it belongs in. There was no reader for it, so one got written live.
- Metadata, Hear Me Out: 30.7 seconds. A WAV audio file, a format the engine had never opened. The question wanted the audio codec, which lives in a small chunk in the file’s header.
- Warmups, Bacon Bits: 32.7 seconds. A Baconian cipher, a two-letter alphabet where every group of five letters is a small binary number, stacked over hex. My Day 16 notes had predicted exactly this kind of alphabet. We just had not built it yet.
Three of those four needed brand new code, and all three had it in about 20 seconds.
That was Friday’s agent race doing exactly what it was built for, on its first morning live.
Each of the three was turned by the Sonnet agent’s first rule file, the small piece of code an agent writes to teach the engine a new shape. Script needed nothing: Friday’s engine read it as it stood.
The bad part
The binary lane, Decoder Ring, banked 193 of its 204 answers on the first try, 7.6 seconds in. Then it hit a question called hcfg_storage, which asked for an “exact artifact-derived value” describing how the config blob was stored.
No file in the challenge held that value. Not one. We read every byte and found nothing to derive it from.
So the robot did the only thing left. It guessed wordings and let the grader judge. About 250 wrong answers later, between 6.7 and 532.7 seconds after release, it found the two the grader wanted: raw_const_array and raw_hcfg_section.
It was the Opus agent that found them. Then it got worse before it got better. The winning rule still listed five already-rejected words ahead of the right one, so the Time Trial walked through six rounds of answers. The Mastery’s safety check replayed the rule, saw the rejected words, and refused to run it. Fixing that cost about 37 seconds.
The Mastery itself was the best part of the lane: five 32 MB deliveries, 1,014 of 1,020 questions right on the first pass, and the last six (section-name formats no Time Trial had shown) fixed while the clock ran. One ranked attempt, about 93 seconds from start to CORRECT.
The robot wrote a ticket for the gap, a short report of the question, the file and what it had tried, in 136 milliseconds. An agent fixed the rule, and the lane reconnected to the same live attempt and finished it. No second attempt, no retry.
The last check landed at 675.2 seconds. Four lanes in 33 seconds, and one lane twenty times slower than the next.
First place, at the time
Here is the thing, though. When I checked the standings after the run, we were in first place at the time. I do not think we were the only team that ran into that question.
That afternoon Huntress reissued the challenge. The hcfg_storage question became a fixed set of choices with published rules for picking one. The robot ran six training Time Trials on the new version, and every one came back CORRECT on the first round with zero rejections.
Guessing is not the first choice
That question started the most useful argument I had with the robot all week.
My first reaction was that guessing is not the first choice. Read the file first. If the file genuinely cannot hold the answer, that is probably a bug in the challenge, and the robot should say so instead of quietly memorizing a vocabulary of random words.
By the evening I had thought about what that means under a race clock, and I turned it around. I told the robot, “I want it to guess and not just stop and notify.” A guesser that gives up politely is just a slower way to lose.
So both halves stand. Derive from the file first. When the file cannot hold the answer, say so, then guess as wide as it takes.
In the robot that means a possible challenge bug is a heads-up on my phone, never a stop. It guesses with no cap and no waiting on me, and it never abandons the lane. A word found that way gets recorded as “the grader accepted it, it cannot be derived”, never as a lesson for tomorrow. The “what if” replay on Saturday’s own fixes said Day 17 would have been about 74 seconds instead of 675.
The speed round
With every check banked, Saturday evening was the first speed round: go back to boards where we could still gain and run them again. The Hall of Fame keeps each team’s best time on every timed board, so a rerun can only help. We made about 33 ranked runs, and every one was CORRECT on its first round. The new first places:
- Native Library Secrets (Day 15 mobile): 1st on the Time Trial at 0.262 seconds, and 1st on the Mastery at 0.357.
- Crumb Trail (Day 15 script): 1st on the Time Trial and the Mastery.
- JNI Boundary (Day 16 mobile): 1st on the Time Trial at 0.312 seconds, up from 6th.
- Decoder Ring, the Day 17 binary with the broken question: 1st on the Time Trial at 1.539 seconds, up from 7th.
Across all 170 board slots so far, the robot held 28 first places, 22 seconds and 21 thirds.
One week earlier I was 38th of 38 on a warmups board, typing answers by hand.
Getting ready for the web
Day 19 brings a lane nobody has seen yet: web, which means files plus a live target to poke at. We started on it that day.
The robot built a web lane agent and a way to reach targets only from inside an isolated network namespace on my machine, recording every response so it can be replayed later. The event’s VPN profile went in too, after one snag: the newest OpenVPN lost its tunnel the moment it moved into the namespace, until we switched off its kernel offload. As it turned out, nothing needed it. The web targets are plain public HTTPS.
By the end of Saturday the robot was set for Day 18: preflight 9 of 9, the offline rehearsal of Day 17 finished all 15 checks in 20.5 seconds, and the 08:55 timer was armed.
Fourteen days to go.
How we built it: the Day 17 dev log
Why rule mode went on at one in the morning. The drills on the night-before code had the agent race finishing Days 16 and 15 in 54.6 and 65.5 seconds. That was enough for me. Around 01:05 I said to run Day 17 with tickets and rule files switched on, and the robot spent the rest of the night reviewing it start to finish. The rollback was one line long: switch the rules off and race the old way.
Why the first try stops early. In rule mode an agent can only start once a ticket exists, and a first try that walks every guess on its list delays the ticket. So the first try walks at most four candidates per question, then writes the ticket. On metadata that brought the ticket from about 16 seconds to about 4.
Why rejected words go last. The Mastery refusal was the robot’s own safety check doing its job: a rule that lists words the grader already rejected looks broken. The fix went in the rule wrapper, not the check. Any word the grader has refused now ranks last, so the right one leads.
How the guessing rule changed twice in a day. At lunch it was: derive first, flag a possible challenge bug, then one last round of at most 20 guesses per question. By early evening the flag became a report, never a stop, and the lane was never abandoned. By 20:44 I had dropped the cap entirely.
Why the change rule. After Saturday I asked to hear about every change before it landed, with a veto. Later that day I made it standing: no veto needed for a change that helps and adds no blockers and no slowdowns. Everything still went through the full gate, the checks every change must pass before it is saved, one change per commit.
Why Bacon went into the engine. The agent’s Bacon rule patched the shared warmups engine at import, and that broke two tests. So at day close the decoder was folded into the engine properly and the rule deleted. Only the hex form had shown up, so the A-to-Z variant waited.
Why build alphabets nobody asked for. Overnight, with my go, the warmups engine got ten alphabets before any challenge used them. Each new layer had cost us an agent loop on race day. Building them the night before costs nothing on the clock.
Why the speed round kept no reserve. Every check mark was already earned, so a miss could only cost board time we did not have yet. One thing it showed: the Mastery reruns did not beat their race-day times, so reruns alone may not move those boards.