AI Agents Decompiled a First-Person Shooter, Burning 500 Billion Tokens

The author of the momo5502.com blog has published a report on an experiment in which AI agents decompiled a first-person shooter. The final counter is right in the headline: about 500 billion tokens. The post, dated October 9, 2026, collected 69 points and 54 comments on Hacker News. The task usually takes reverse engineers months of manual work, and this is one of the clearest public measurements of how much compute goes into getting a result.

Limitation: the summary available to us does not include the game's name, the number of recovered functions, or the share of code that matched the original. Those figures appear only in the post itself, so any comparison with other projects should rely on it. Below, we look at what follows from the format of the experiment itself.

Why decompilation suits agents

Most agentic tasks suffer from one problem: it's unclear how to check the result. Here, verification is built into the process. The agent writes C or C++ code, compiles it, and compares the output with the original machine code. If the assembly or the function's behavior matches, the step counts. If it doesn't, the agent gets a diff and tries again.

This loop fits modern coding agents well. They have the tools: a disassembler, a compiler, a test runner. They also get a clear success signal. Communities that manually reconstruct console game source code down to a byte-for-byte match have long worked along roughly these lines. What's new is the attempt to hand the routine work to models.

A first-person shooter adds difficulty. It means thousands of functions, optimized math, vector and physics code, and many quirks specific to a particular compiler. The compiler may have unrolled loops or inlined functions so heavily that the original code structure is almost impossible to guess.

What 500 billion tokens means

At this scale, economics matters more than a polished demo. The agent rereads its context at every step: the disassembly listing, previous attempts, compiler output. Most tokens go to repeated input context, not to new code.

Rough editorial estimate, not the author's data. At a price of $0.1 to $1 per million tokens (depending on the share of cached context and the model chosen), 500 billion tokens would come to roughly $50–500 thousand at API list prices. The actual sum depends on the pricing plan, subscriptions, and local models. Even so, the order of magnitude shows this is a project with its own budget, not an evening experiment.

What the source tells us:

• Consumption: about 500 billion tokens
• Task: decompiling a first-person shooter with agents
• Publication date: October 9, 2026
• Hacker News reaction: 69 points, 54 comments
• Not disclosed in the summary: the game's name, the number of functions, the match percentage, the models used

What to check before repeating this

First: define the success metric before you start. A byte-for-byte match, equivalent behavior, and code readability produce different results at different costs. An agent told to "just make it work" will produce code that isn't fit for maintenance.

Second: limit the context. If every step drags the entire previous log along, cost grows faster than progress. Compact notes on discovered structures and signatures, which the agent passes between sessions, work well.

Third: count not only tokens but also the cost of each accepted function. That figure shows where the agent beats a human and where it's cheaper to sit down and work through the code by hand.

Finally, the legal side. Decompiling a commercial game runs into copyright and license terms. The boundaries for personal research and interoperability differ from those for publishing the result. Before releasing recovered code, consult a lawyer.