The 31-Hour Run

Between the morning of July 4 and mid-afternoon July 5, an agent fleet took a game feature set from a design record to a green build without a human writing a line of code. It filed 17 issues in 4 minutes 45 seconds, merged 18 pull requests across two repositories, and stamped its own goal condition 65 minutes before a power cut ended the session. Nothing was reverted in the window.

This is the receipt. Every bar is one pull request, positioned by when it opened and when it merged; hover or tab through them for the detail. The green mark is the moment the goal condition was met; the dashed mark is the power cut.

The setup

The run did not start with code. It started with a document. Out of an overnight design session came a record of fifteen decisions, folded together with the seventeen answers that resolved them, and it landed on the CandyRush dev branch at 06:56 as PR #329. That record is what the whole run was measured against.

Then the plan was hardened for autonomy in three commits inside ten minutes: the autonomous-execution runbook at 07:22, the review policy at 07:30, and a draft goal command at 07:32. Before any issue was filed, an eight-agent adversarial fan-out read the drafts against the actual source and returned six corrections — each a bug the run would otherwise have built on. One refuted the boss-stall theory outright. One found that a bare director.Time = 0 cannot re-fire wave clips, so the combat loop had to route through the RebuildGraph path — which is exactly how the flagship shipped.

At 08:04:24 the filing burst began: seventeen issues, a letter-coded plan A through Q, hit GitHub in 4 minutes 45 seconds (#330–#346), carrying the repository's first milestone. The board was set, and the goal command fired.

The run, hour by hour

Every issue got the same treatment: an implementation subagent wrote the change, the orchestrator ran the full test suites against it, a reviewer graded the diff, and only then did it merge. Pull requests went in one at a time, dev green after each. The median open-to-merge cycle across the run was 40 minutes.

Times are US Eastern. Totals for the run: +16,199/−2,885 across 397 file-changes on CandyRush, plus +14 on UTools.

Through the night

Seven of the eighteen pull requests merged between 23:29 and 08:16 while the house slept — the anti-farm economy, the tier-hue difficulty meter, and three full archetypes among them. The heaviest diff of the whole run — +2,888 for the economy — opened the night shift at 23:29, and the six merges that followed before morning held cycles between 35 and 41 minutes. The loop did not slow down because no one was watching it.

The flagship, #354, merged at 19:54 the way the pre-flight fan-out said it had to: infinite-loop combat routed through Load/RebuildGraph. Earlier the run's own review of its own morning fix surfaced a startup race; it filed #352, fixed it, and merged #353 within 45 minutes. That kind of self-audit is why nothing needed reverting.

The tape

#364 merged at 14:15, the hand-off comment posted at 14:17, and the run kept the engines running for one last full pass over the exact dev tip 674f7745. At 14:50:03 the goal condition was stamped:

Net of the run: +151 EditMode tests, both failures.json empty, and working trees clean on both repositories. The two PlayMode reds the run started with were root-caused and gone by lunch on day one, never to return.

The extraction

Run mode's whole thesis is that greed has a price: stay one verse too long and the wipe takes everything. Sixty-six minutes after the goal condition was stamped, the run got to live out its own premise. The Windows event log recorded a dirty shutdown at 15:55:56 — the power went out. It stayed out for 3 hours 31 minutes, restored at 19:26:31.

The margin was 65 minutes 53 seconds. The wipe hit an empty room: every byte was already on origin, and the machine came back to clean trees on both repos. The narrowest escape was not even the stamp — the final roughly 33-minute verification pass ran until 14:50. An hour earlier and the outage kills it mid-suite. As it played out: zero loss.

What this proves

The point of the run is not that it was fast, though it was. It is that every claim in this post has a number behind it, and every number was measured rather than asserted: the cycle times come from the pull-request timestamps, the diff totals from git, the test counts from the suite output, the outage from the kernel-power event. An agent fleet can do a day and a half of real engineering unattended — and it can leave a trail clean enough that you do not have to take anyone's word for it.

All timestamps are US Eastern (UTC−4), reconstructed from git history, the GitHub API, and the Windows event log (Event 6008 / Kernel-Power 41). The CandyRush and UTools repositories are private; every figure here is measured data, not an estimate.