Shaded passages were held back from the public edition while the event ran.
Friday we were 20th. On Saturday our last check of 21 went CORRECT 81.3 seconds after the release, faster than anyone, and we were 1st overall again.
Nothing heroic happened overnight. We fixed what broke on Friday, and on Saturday it held. That is the whole trick, and it is less glamorous than it sounds.
09:00
Seven challenges dropped, and they fell in this order:
- Web of Lies (script): all three modes by 11.0 seconds. Friday this lane took 29 minutes.
- Event Horizon (metadata): a Windows event log, asking how many records it held. 17.6.
- Spot the Difference (binary): 26.1.
- Emulator Alibi (mobile): 32.9.
- String Theory (warmups): the newest layer was netstrings. 40.0.
- Fetch Quest (web): a server-side request forgery. 51.5.
- The API Has Opinions (web): 81.3.
No batch bounced. Zero 429s. The watcher, the AI session that watches the race live and can step in, never had to lift a finger. And most of the slowest challenge’s time was spent waiting on the Game Master, the event’s API, to build its targets, not on anything the robot did.
Three lanes still needed the agents. Event Horizon came first: the robot had no EVTX reader, so the Single Solve opened a ticket, the short report the robot writes when it can’t answer. An agent’s patch, a small fix the running lane picks up without restarting, went live, and the challenge was CORRECT 13 seconds later.
On Emulator Alibi, Mastery delivery 7 hid its answer in a second DEX file, assets/payload.dex, loaded at runtime through InMemoryDexClassLoader and called by reflection. The static interpreter stopped at the asset read, so the winning answer came from the hand agent, an AI agent that works the question directly and answers that one attempt.
String Theory was the one place we lost time to our own code. An agent wrote the netstring decoder at 09:00:11 for the Single Solve ticket. The judge, the automatic test every patch must pass, refused it as “no gain”, because the Single Solve was already accepted and no later ticket existed to try it against. The Mastery’s 118 blobs then spent 25.1 seconds hunting for the unknown layer before their ticket opened at 09:00:30, and the same decoder went live at 09:00:40. Without that stall the warmups Mastery would have taken about 9 or 10 seconds instead of 34.6. It wasn’t the critical path, but it was ours to lose.
The API Has Opinions spent 58 of its 81 seconds inside the Game Master’s start calls, which return only once a fresh target is built: 16.7, 15.2 and 26.3 seconds for the three modes, where Fetch Quest’s built in 2.4 to 4.1. Each mode starts only after the one before it is CORRECT, so there is no overlapping those waits from our side. Binary raced from the VM again, our second copy of the robot on a cloud machine closer to the download servers.
By about twenty past nine it was plain we were well ahead of the field, as long as nothing got stuck the way Friday had. Nothing did.
The record
From the public scoreboard at 09:10, Day 24, all 21 checks:
- Wizdumb 81.3 seconds, 1st of the 16 teams finished by then.
- OscarsWorld 155.9, team.dev 227.1.
- First blood on 10 of 21 boards (the first team to solve a board): all three on both web challenges, plus the Single Solve and Time Trial on String Theory and on Emulator Alibi.
- 1st on five timed boards: both Event Horizon boards, both The API Has Opinions boards, and the Emulator Alibi Time Trial. 2nd on the Web of Lies and Fetch Quest Masteries.
Nobody banked Saturday’s last flag before we did, which puts us 1st overall on 1,370 points, one day after finishing 20th.
Did Friday’s fixes actually help, or did we just get an easier day? The mock, our local stand-in for the event server, can answer that. We ran the same Day 24 records with agents off and only the code different. The code that raced Friday got 5 of 15 file-lane checks on the first try. The code that raced Saturday got 10 of 15. The difference was the script lane’s Time Trial and Mastery (without Friday’s fold, the after-race step that turns patches into permanent solver code, they would have opened 2,016 tickets), the binary Time Trial and Mastery, and the mobile Time Trial. The submitter’s new safety nets never triggered, which is exactly what you want from a safety net.
The one weak spot at 09:10 was String Theory’s Mastery, 7th at 34.550 seconds, and that one was on us. By the afternoon it was 1st.
The afternoon
The fold was in by 10:12, one commit per lane: a real EVTX reader that walks the records instead of trusting the header’s count, a netstring layer for warmups, the mobile interpreter following a secondary DEX load all the way through, and two new web techniques with nothing hard-coded. The mock proof came back clean, 15 of 15 file-lane checks CORRECT on the first try with no tickets, and a free live web run with agents off solved both web Time Trials and Masteries on its own, the Masteries in 3.5 and 4.9 seconds.
Then the warmups fix. Once three sibling Mastery blobs have failed at the same layer, the rest skip that search and the ticket opens at once. On the mock, Mastery attempt to ticket went from 22.3 seconds to 3.1. In a live free run with agents on, the ticket opened at 3.2 seconds and the Mastery went CORRECT at 17.0, with the agents writing the decoder from scratch.
The question that shaped that fix was mine: what happens if the organizers wrap every Mastery blob differently? It is the kind of thing “I wouldn’t put it past the event organizers to throw at us.”
I also asked whether some universal change would have sped up the slow lanes, and said plainly I didn’t want to go deep if the answer was no, or too complex to beat a hand solve. The hand solvers are there as “a fail safe should we encounter anything that is way way way out of bounds.”
The speed runs
Every Time Trial and Mastery also has a speed board in the Hall of Fame, ranked by each team’s best single run. After the race those were the places left to win, so the afternoon went to reruns: 92 ranked attempts across the boards where we weren’t already 1st.
By the end of the day, from the public speed boards:
- String Theory: 1st on both, 0.252 and 0.221 seconds. That is the Mastery that was 7th in the morning.
- Event Horizon, Web of Lies and Emulator Alibi: 1st on both boards each.
- The API Has Opinions: Time Trial 1st, Mastery 2nd at 2.507, behind FC’s 2.080.
- Fetch Quest: Time Trial 1st, Mastery 4th, with that pool now spent.
- Spot the Difference: 3rd on both, against team.dev and Zwesty.
That is 1st on 10 of the day’s 14 boards. Across all 24 days, 253 boards now carry times, and we hold 16 firsts, 16 seconds and 27 thirds.
The reruns ran from a separate worktree on the day’s code, ranked clocks, agents off, so anything the robot couldn’t do alone showed up as a miss instead of being patched over. Six Masteries came back accepted instead of CORRECT, and that was the useful part: two first-try gaps on fresh variants, both folded before the evening.
On String Theory, one blob decoded to the slug with a short numeric tail stuck on the end. The slug now goes out as a ranked candidate, never a certain answer, until the grader has confirmed that shape. On Emulator Alibi, two older deliveries hid their answer in native code, a nativeShare function inside the app’s bundled libarena.so, and a third reached its class by name through Class.forName. The interpreter now steps through the x86-64 function statically and follows the reflection, and three free live Mastery runs with agents off came back CORRECT, the native delivery accepted each time.
Spot the Difference stopped where it is because binary reruns from the house were slower than the VM’s race-day times. Its 43 Time Trial and 9 Mastery attempts are saved for the VM tomorrow, after Day 25’s challenges are done.
Seven days to go.
How we built it: the Day 24 dev log
Why nothing changed at 08:31. Half an hour before the release, the Game Master’s API spec changed: the lane filter took long and short aliases, and web start gained a view option that opens an unscored practice copy of a solved target. The preflight flagged it as a notice, as designed. Every name the robot uses still answered live and the challenge ids hadn’t changed, so we left it. An edit to the release poller, the part that watches for the 09:00 drop, 13 minutes before the race could not get its tests and a rehearsal, and the VM had already pulled its code, so the two machines would have raced different versions. view is noted as a free source of web practice targets.
Why the warmups fix is a sibling count, not a re-judge. My first question after the race was why we didn’t try a decoder we already had on the Mastery. The judge only re-checks a refused patch against tickets that exist, and an earlier review had ruled out holding refused patches to promote later, because a held copy can go stale or go live twice. The first design was a re-judge when a new ticket opens. But the real gap was the 25 seconds before the ticket existed. Make the ticket open in 3 seconds and the existing retarget picks up an early patch on its own. The re-judge waits until a patch is ever refused with no later ticket again.
Why three siblings, and only failed ones. “Blob 1 failed at this layer, so skip it on the rest” broke on my mixed-wrapping question: if every blob used a different layer the engine already knows, skipping would stop finding them. So the memo counts only siblings whose search failed at that layer, there’s a test with mixed known layers that still solves, it takes three failures so one odd blob can’t shut the search, and it clears the moment a patch teaches a new layer.
Why the slowest challenge was left alone. The API Has Opinions was the last check, but its time was the server building targets, and our own work on it ranks 1st on both its timed boards. Nothing of ours to cut.
Why speed runs at all. The race decides Day 31, and a 0.2-second Time Trial doesn’t move the race. But the speed boards are where the strongest teams show what their solvers can do, and I wanted to make sure we were within a margin of error of them. A ranked replay with agents off is also the honest test of whether the morning’s folds hold, and it found two gaps the mock had missed.
How we got the boards. The speed boards sit behind the event login. I started on a bookmarklet to save them, and while testing it we found the Game Master serves the same Hall of Fame boards from a public speed-scoreboard endpoint, every board for every day, no login. That fed a new Speed tab on our race page (position counter, places by day, top performers, our pace against theirs, a snapshot each refresh), and the repo’s leaderboard notes, hand-pasted from my screenshots until now, are generated from the same data.
What got caught on the way. The release predictor guessed line 24 of the warmups recipe from the Single Solve and guessed wrong, a coincidental match on the per-character netstring; it was reverted and the fold set the line from the decoder. The fold tool also refused to run until 09:30, because a live run’s start record carried no release time. That got its own fix.