← Back to feed

Security researcher Maurice Heumann has published a detailed account of a project that used teams of AI coding agents to decompile a commercial first-person shooter from binary. Over roughly three months, the agents worked through the disassembled code function by function. The final result: about 80% of the game reconstructed, with the main menu visible and maps loadable.

The post, titled “500+ Billion Tokens Later: Letting AI Agents Decompile A First-Person Shooter,” puts a token count on what industrialised agent use looks like in practice. Five hundred billion tokens is not a figure that emerges from casual experimentation — it reflects sustained multi-agent runs, significant coordination overhead, and iterative refinement of scaffolding across the project’s timeline.

What the Agents Actually Did

Traditional decompilation tools convert compiled binaries into assembly or pseudocode. They recover structure but not intent: variable names are gone, comments are gone, high-level abstractions collapse. The resulting output is technically correct but nearly unreadable.

What Heumann’s setup attempted was a layer above that: using AI agents to interpret the assembly, reason about what each function was doing, and reconstruct plausible source code. Not just syntax recovery but semantic recovery — understanding that a block of memory operations is implementing a physics collision check, for instance, and writing it that way.

The agents managed roughly 80% of the game before the project concluded. That 80% included enough of the core runtime to launch the binary, reach the main menu, and load maps — the foundational systems. The remaining 20% likely represents the highest-complexity code: rendering pipelines, proprietary physics subsystems, or platform-specific integrations where the gap between binary and intent is hardest to bridge.

Heumann’s post notes that a significant portion of the three-month timeline went toward optimising the setup — scaffolding, prompt design, and agent coordination — rather than raw decompilation. That is a recurring pattern in complex agentic work: the infrastructure problem consumes as much time as the target problem.

The Token Economics

Five hundred billion tokens at current API prices is not cheap, but it is no longer extraordinary. At frontier model output pricing of roughly $10-20 per million tokens, and accounting for the input-heavy nature of code analysis, a sustained multi-agent run over three months at this scale runs into the tens to hundreds of thousands of dollars.

The more relevant observation is the direction of the cost curve. A project that required this level of token expenditure in October 2026 will require substantially less in two years, as model efficiency improves and caching infrastructure matures. What Heumann demonstrates is a capability threshold, not a permanent cost baseline.

The Copyright Problem

The legal analysis is less settled than the technical one. A commercial game’s source code is protected intellectual property. Decompilation for interoperability has limited legal protection in some jurisdictions under fair use or equivalent doctrines — reverse engineering to make a product compatible with another, to identify security vulnerabilities, or for research purposes.

Reconstructing 80% of a commercial title’s source code is difficult to characterise as interoperability work. The HDD Law analysis of the project describes it as “a commercial shooter, rebuilt function by function” and flags it as a test case for how existing decompilation doctrine applies when the decompiler is an AI agent rather than a human programmer reading disassembly.

The legal status of AI-assisted decompilation at this scale has not been adjudicated. Human decompilation of a game for personal research sits in an established grey zone. Agent-assisted decompilation that produces near-complete source reconstruction, at speed and at scale, sits in territory that courts have not defined.

What It Tells You About Agents in 2026

The project is not primarily a story about games. It is a demonstration of what sustained agentic work looks like on a large, ambiguous, real-world codebase — the kind of problem that does not come with a test suite and a specification.

The 80% figure is meaningful because the remaining 20% is where the hard cases live. Getting agents to handle the straightforward 80% of any large codebase is increasingly achievable. The question for the next generation of benchmarks is whether agents can handle the tail: the code that requires understanding system-level state, proprietary hardware interfaces, or deeply non-obvious implementation decisions.

Heumann’s project also documents the scaffolding overhead problem in practice. The gap between a capable frontier model and a capable agent system is still substantial — and the three months spent on setup optimisation is part of the real cost of deploying agents on hard problems.