AI Agents Decompiled a Shooter in Three Months, Burning Up to 700 Billion Tokens

A group of enthusiasts spent three months steering AI agents that decompiled a popular first-person shooter and rebuilt its code in C++. According to the project's author, 99% of functions were recovered, 83% of them match the original byte for byte, and the game runs without noticeable bugs. The author estimates the cost at 600–700 billion tokens. He described the project on Habr, and the story centers on agent orchestration, not on the game itself.

Accuracy as a Requirement

The goal was an exact, stable reconstruction, not a demonstration that agents are capable of such work. The difference is fundamental. When you only need something that behaves similarly, an agent can produce plausible code, and there is nothing to check it against. When you need code comparable to the original at the byte level, every function gets an unambiguous verdict: it matches or it doesn't.

This is the author's main thesis: without objective, automated verification, this approach does not work. An agent whose output is judged by eye or by another neural network piles up errors over weeks and confidently heads in the wrong direction. A compiler and a byte-for-byte comparison don't argue and don't get tired.

The Scale in Numbers

Here is what follows from the stated figures. 600–700 billion tokens over three months, or roughly 90 days, works out to 6.7–7.8 billion tokens per day. Per second, that averages 77–90 thousand tokens, around the clock. A human cannot sustain that pace under any conditions. It is only reachable with many agents running in parallel, and they need infrastructure: task queues, environment isolation, cost tracking, automatic restarts.

The project's final numbers:

• duration: about three months;
• cost: 600–700 billion tokens (the author's estimate);
• functions recovered: 99%;
• byte-for-byte match with the original: 83% of recovered functions, or about 82% of all functions;
• result: the game launches and runs without noticeable bugs.

About 17% of functions remain that did not match byte for byte. Some of them may behave identically but compile differently. For a project whose goal is accuracy, this is an area for further work.

The Human Role

The author stresses that people from the community directed the agents. Here, autonomy does not mean the absence of oversight. It means a human sets the boundaries and watches the metrics instead of reading every line. The author covers the details of the tooling and settings in the original article. We rely only on its introductory section and do not speculate about implementation details.

What to Take Away

First: pick tasks where a machine can verify the result. Decompilation with byte-for-byte comparison, code migration with a test suite, and optimization against a benchmark all belong to this class. Tasks like "make it look nice" do not.

Second: budget tokens as a line item. Hundreds of billions of tokens are a financial planning question, not a weekend experiment.

Third: measure the success rate by functions, modules, or tests, not by gut feeling. A metric like "83% matched" tells you whether to launch the next round of agent work or to bring in a human for the remaining tail.

Fourth: check the legal side. Decompiling commercial software depends on the license and the jurisdiction, and technical feasibility does not settle that question.