for the people with the clipboards

Frankenstein in 30 seconds.

TL;DR for judges

What it is
AI agents rebuild a lost game's source code from the cartridge. It's for game preservation groups and rights holders, because 87% of classic US games are critically endangered and their code is gone.
What's proven
A piece only counts if it's byte-identical: the compiler turns the agents' C into the original's exact bytes. Put back into Doom, the rebuilt game has the same checksum.
The numbers
166 of Doom's 568 game functions are back, proven exact. That's 4.62% of the code by size, because the crew starts with the small ones.
Try it
Press Enter at our table and watch two agents recover a function live. Then play Doom on the controller, or scan the QR code to play it on your phone.
Not done yet
Doomguy's face (1,164 bytes) isn't recovered, and the habit library hasn't beaten noise on unseen code. Both are said plainly below.

how to read this page

Every track, criterion by criterion.

Each card quotes the track's criteria, then answers them one row at a time. Every row ends with the file its number came from.

  • MATCH proved by the compiler
  • name? our guess
  • REPLAY a recorded real run, played faster
  • STATIC FACE code not recovered yet
  • like this our notes

the event

Round one

Overall

Lost games, rebuilt and proven.

judged on

  • Technical Demo 35%
  • Implementation Difficulty 30%
  • Impact Potential 20%
  • Creativity 15%

Source: the organizers' brief, recorded in DECISIONS.md. Round two weights them equally.

Technical Demo 35%
You press Enter, two agents dig live, and the compiler stamps each MATCH in 0.1 to 0.2 seconds. DEMO_SCRIPT.md
Implementation Difficulty 30%
Agents must write C that compiles to Doom's exact bytes at -O3, past a referee, a fake detector and a full ROM rebuild we built today. lab/
Impact Potential 20%
87% of classic US games are critically endangered, and source code is what lets a game be fixed and ported again. VGHF and SPN, 2023
Creativity 15%
A lab where agents lie and the referee can't be fooled; play the game, and Snap rebuilds what's on your screen first. Play to recover
Progress so far
166 of 568 game functions are back (4.62% of the code bytes), every one proved by the compiler, and the rebuilt game keeps its checksum. see the meter
show proof

REBUILD Doom, put back together from the agents' C

originald936259bcbe48b5ce5d8be4d5ffe935c1eece8b2

rebuiltd936259bcbe48b5ce5d8be4d5ffe935c1eece8b2

6 functions from the agents' own compiled C · 562 from the original build · method object-splice

same 40 characters: not similar, identical

From the build.rom event in crew/exports/doom_r12, 13:36.

Problem statement 1 of 3

Software Archaeology

Only the cartridge survived. The C comes back.

judged on

  • reconstruct software from imperfect evidence

Source: the event page, cerebralvalley.ai.

Evidence, not memory
Agents see only anonymous ids and the game's machine code as text; the real source is locked away as the answer key. crew/guard.py
A scrambled patient
We made 11 small edits to our Doom build, and from memory alone Muse compiled 0 of 20 Doom functions. DECISIONS 13:28
Proved instruction by instruction
Each candidate compiles in a locked-down container and must match the original instruction for instruction. lab/README.md
Spliced back in, same checksum
The recovered functions go back into the ROM, next to the original code for the rest, and its SHA-1 checksum stays identical. see the rebuild
And it can change again
We edited one recovered function, fn_0801C130, so its graphics should draw 4 pixels higher; the referee confirms the other 567 are unchanged, and the emulator check is next. lab/demo/hud_shift
Not done yet
The crew wins on small functions; Doomguy's 1,164-byte face got 2 attempts and a best of 0.7%. crew/STATUS.md
show proof

MATCH one held-out function, start to finish

fn_08013CA4.cdoom_r12 · 2 attempts

void fn_08013CA4(void)
{
    fn_08019244();
    fn_0801D8A4(2, 3);
    fn_0801D5E8(*(int *)(data_030064C4 + 0x878));
    *(int *)(data_030064C4 + 0x878) = 0;
    *(int *)(data_030064C4 + 0x880) = 0;
    *(int *)(data_030064C4 + 0x87c) = 0;
}
  • MATCH byte-identical to the original
  • 2 LABS Snap and Gemini found no fake
  • SHA-1 identical with it spliced in
  • reset_global_state? Muse's guess at a name
From crew/exports/doom_r12: recovered/fn_08013CA4.c, events.jsonl and names.json. Declarations trimmed.

Problem statement 2 of 3

Trust but Verify

Agents lie. The referee doesn't.

judged on

  • verify what other agents ship before it merges

Source: the event page, cerebralvalley.ai.

A claim is only a claim
Each agent stakes its claim before it sees the verdict, and the Checker re-runs the referee on every one. see a caught lie
Lies caught
In round two the Checker caught 5 real false claims, and the referee refused every one. DECISIONS 13:58
Fakes thrown out
A fake is C that matches by tricking the compiler, like a stray volatile; the easy held-out runs rejected 3 to 5 each, and none got through. crew/EXPERIMENTS.md
Two labs check what bytes can't
SubQ Snap and Gemini score every match for fakes and recited source, in parallel. see both labs
Hard to talk into anything
Pasted C compiles with no network and no keys, after we fixed an include trick that could have leaked them. SECURITY.md
show proof

FALSE CLAIM doom_r12 · fn_0801143C · attempt 5

Matched it. Pretty sure.

referee: 96.5% matchfirst difference at +0x44

expectedldr r2, [pc, #48]

gotldr r3, [r4, #76]

one instruction gave it away

FAKE

fn_0801B1F8 matched the bytes, but the Checker refused it: "volatile used to coax codegen". doom_hud01

From claim.made, verdict and fakematch.rejected events in crew/exports.

Problem statement 3 of 3

The System That Gets Better

Habits earn their place, or get retired.

judged on

  • systems that get measurably better with every run

Source: the event page, cerebralvalley.ai.

Habits, never answers
After each match the crew keeps a general lesson, never the code, and drops any habit that copies 3 lines of the answer. crew/README.md
Kept only on evidence
A habit is adopted after 3 good uses and retired after 4 bad ones; one training run adopted 3 and retired 4. see the habits
Tested on unseen code
170 of 568 game functions are held out (never trained on), and the library is frozen while they're tested. crew/EXPERIMENTS.md
Honest result
Held out, the library hasn't beaten noise: 29 vs 29 of 40 on easy code, 6 vs 6 of 20 on hard code, so we don't claim it helped. DECISIONS 14:06
show proof
Held out: Doom functions the crew never saw
RunSetupMatchedAttempts per matchCost per match
Hard: 20 functions of 57 to 200 bytes
doom_r12library on · Snap on6 / 202.00$0.536
doom_r13library off · Snap on6 / 202.17$0.547
doom_r14library on · Snap off4 / 202.25$0.822
Easy: 40 functions of 16 to 56 bytes, rerun on current code
doom_r02blibrary on · Snap on29 / 401.41$0.076
doom_r03blibrary off · Snap on29 / 401.45$0.075
doom_r04blibrary on · Snap off30 / 401.47$0.086

same model, same budget, same functions. bad results ship too.

partner tracks

Best Use of Meta Model API

Muse is Frankenstein's hands.

judged on

  • the best use of the Meta Model API
  • Muse is load-bearing, not decoration

Source: the event page names the prize; the second line is our reading.

Every line of recovered C
Six Muse Spark agents write C in a loop with the referee as their tool: write, compile, read the diff, try again. crew/digger.py
Wonder for the stubborn ones
When Snap says escalate, Muse Wonder takes over; the first Doom run used 103 Spark calls and 11 Wonder calls for $0.73. doom_r01 metrics
It also teaches and names
Muse writes the habits and guesses the function names, which we show in violet. names.json
Without it
Nothing writes the C, and the referee has nothing to judge.
Honest limit
Wonder has no public price yet, so we count it at Spark rates and mark the cost as estimated.
show proof

MATCH written by Muse, proved by the compiler

fn_0800FDFC.cdoom_r01

int fn_0800FDFC(int a, int b)
{
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    int s = a + b;
    if (b <= a) return s - (b >> 1);
    else        return s - (a >> 1);
}
  • MATCH byte-identical to the original
  • sum_of_abs_minus_half_min? Muse's guess at a name
From crew/exports/doom_r01/recovered/fn_0800FDFC.c, lightly reformatted.

Best Use of Subquadratic

SubQ Snap is its judgment.

judged on

  • Snap changes what the crew does, and it's measured

Source: our reading; no written criteria were published that we could find.

The whole game in one read
Snap reads every function's machine code in one 384K window and sets the work order; in the first run that was 1.39M tokens. doom_r01 metrics
Keep, escalate or abandon
After each miss, Snap decides where the next Muse dollar goes, in well under a second. see its calls
The fake gate
Every MATCH also needs low fake and recital odds from Snap before it's accepted. crew/checker.py
Eyes on the screen
Play the game, and Snap picks what's on screen to rebuild next, then checks a patch changed only what we said. DECISIONS 12:00
Without it
Muse digs blind, and nobody reads the whole game at once.
Honest limits
Plain-words routing is a hint, 5 to 7 times better than random. Snap on vs off was 6 vs 4 of 20 on hard code: a weak hint, not a result. DECISIONS 13:58
show proof

SNAP five real calls from doom_r12

  1. 13:23:34reviewfake odds 0.33, recital 0.00351 ms
  2. 13:24:05decideescalate to Wonder · conf 0.88380 ms
  3. 13:25:49decidekeep on Spark · conf 0.85326 ms
  4. 13:33:34decideabandon · 12% chance to match342 ms
From snap.decision events in crew/exports/doom_r12/events.jsonl, times in Pacific.

Agents That Prove Their Work

ASI:One is the front door.

judged on

  • Agents that rebuild software from binaries, keeping what's observed apart from what's inferred
  • Agents that verify before trusting
  • Agents that improve on held-out tasks

Source: the Fetch.ai brief, recorded in docs/LANE_A_LAB.md. Its required items are ticked on the right.

Registered on Agentverse
Two agents, both reachable by mailbox, so no tunnel and no open port.
  • Frankenstein Refereeagent1q088qnxafee4aug0qz4xnd9zkk4veq2r9ez07mp047u8enqhckc5w2hstx0
  • frankenstein-excavatoragent1qf4w7kmtsgv4fdyuj72nwethhjwhmdh7m3u7kqe5tgz4wyq8nmmmq5gjacp
Agent Chat Protocol
The Referee publishes its chat protocol, and verdicts come back as interactive cards. frankenstein_agent.py
Usable in ASI:One
Mention the agent in ASI:One and ask; the whole job happens in the chat, no custom front end. lab/README.md
Multi-agent, verify before trust
The Excavator runs a crew job, then asks the Referee agent and answers only with its verdict. see the log
Observed vs inferred
Every reply splits what the compiler proved from what is only a guess. AGENT_README.md
Public repo, run and test steps
run_agent.sh, run_excavator.sh and lab/tests/test_agents.py are in the repo. lab/agents/
Submission Agent
Registered with the form at submission time; it's on our checklist.
Without it
Only our team can ask, and nobody can check our claims for themselves.
Honest limits
The agents run on one teammate's laptop, so they sleep when it does. Functions with a string in their data still trip the crew. E2E_RECOVER.md
show proof

MATCH "Recover fn_08004DA8", agent to agent, 13:44

  1. a registered test agent

    Recover fn_08004DA8

  2. excavator → referee

    Asking Referee agent about fn_08004DA8

  3. referee

    Verdict for fn_08004DA8: MATCH

  4. excavator → asker

    The crew reported a match. I did not take its word for it.

Condensed from the agent logs in lab/E2E_RECOVER.md.

MongoDB

MongoDB is the memory.

judged on

  • Atlas is a real component, not a logo

Source: our reading; no written criteria were published that we could find.

One collection per habit library
Each library is its own Atlas collection, so a frozen test library can never learn from its test. crew/library.py
The run record
Every run's events and metrics are mirrored to Atlas, so runs compare with one query. crew/memory.py
Held-out runs read from Atlas
Round two's test runs loaded their frozen library straight from Atlas, and each run's metrics say so. crew/EXPERIMENTS.md
Without it
Every run starts from zero, and nothing remembers why.
Honest limit
Atlas went live at 13:05, after the first run, and better memory hasn't yet meant more held-out matches. DECISIONS 13:05
show proof

ATLAS habits judged in training run doom_r11

adopted

  • global byte-pointer base with literal-pool offsets
  • args parked in r4-r5-ip with pop-bx epilogue
  • guarded clear emits cmp-beq guard

retired

  • large offset via movs plus lsls
  • large aligned offset built with movs plus lsls
  • if-else with shared tail
  • park struct pointer in r4 across call

kept: 1 quick match in 3 uses. retired: 0 in 4.

From crew/EXPERIMENTS.md, round two.

Google Gemini

Gemini is the second opinion.

judged on

  • Gemini is used meaningfully

Source: our reading; no written criteria were published that we could find.

A different lab, on every match
When the bytes match, Gemini checks the C for fakes next to Snap, in parallel, so it adds no wait. crew/gemini.py
A vote that counts
A match is rejected if Gemini is near-certain it's a fake, or if both labs flag it. crew/README.md
It drew the lab
Every illustration on our home page was generated today with Gemini. generate_art.py
Without it
One lab's opinion on fakes, and a site with no pictures.
Honest limit
Gemini is advisory, and we haven't run Gemini on against off, so its effect isn't measured yet.
show proof

2 LABS one match, fn_08013CA4, doom_r12

SubQ Snap

fake odds0.33

recital odds0.00

351 ms

Gemini

fake odds0.00

recital odds0.00

5.75 s

ACCEPTED both under their reject lines, so the match stands

From the two snap.decision review events before fn.matched at 13:23:39.