Yes, but not autonomously and not with a general-purpose success rate. In an October 2026 project account, developer Maurice Heumann says a team using coding agents reconstructed a commercial game’s behavior in readable C++, with 99% of functions present and 83% matching the original byte-for-byte under a custom verification harness. That is strong evidence for an intensely instrumented reverse-engineering project—not proof that agents can recreate any game from source code on their own.
What “recreate a game from its source code” can mean
The question combines several different tasks that are often treated as one. Rebuilding a game when you already have its original source repository is mainly a software-maintenance and porting problem: an agent can inspect source, build scripts, assets, tests and documentation, then implement missing or changed pieces. Reconstructing a game from a compiled executable is different. The agent must infer function boundaries, types, data structures and behavior from machine code and runtime evidence. That is reverse engineering, even if the end product is readable source.
As an Amazon Associate I earn from qualifying purchases.
The best-known 2026 example concerns the second task. Heumann’s October 9, 2026 account describes roughly three months spent turning a compiled commercial game into readable C++ that compiled and reproduced the game’s behavior. The project post does not name the title. Tom’s Hardware identified it as Call of Duty: Modern Warfare 2 (2009), so that identification should be attributed to the secondary report rather than to Heumann’s own post.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
That distinction matters when interpreting the headline result. A source-available game gives an agent the program’s intended abstractions and names; a binary gives it instructions, data and clues. The latter is much closer to decompilation and compatibility reconstruction than to ordinary game development.
#1 Best Overall
What the 2026 reconstruction actually involved
A fleet of agents, not a single prompt
Heumann says the team used Claude Code and Codex command-line agents, organized work as GitHub issues by translation unit, shared messages through a common communication channel and sent CI notifications as changes were checked. They began with four agents and later expanded to a larger fleet. The number and model mix changed during the project.
The account estimates that the work consumed 600–700 billion tokens. That figure is explicitly approximate because some session logs were lost; it is not an audited usage total or a reliable cost estimate. The important point is the scale of orchestration: agents were assigned bounded units of work and repeatedly fed machine-checkable feedback rather than being asked to “rewrite the game” in one pass.
Specialist inspection tools
The team used Hex-Rays’ ida-mcp interface to inspect disassembly and decompilation output. Such a tool exposes information an ordinary source-code assistant does not have: control flow, call relationships, inferred variables, references and the compiler’s machine-level output. Agents could then translate a unit, compile it and compare the result with the original instead of relying only on whether the code looked plausible.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsEarly milestones were deceptive
At first, the reconstruction appeared successful. The game launched, showed a menu and loaded maps. Those milestones demonstrate that enough code and data paths exist to reach a playable state, but they do not demonstrate semantic equivalence. Heumann reports that function signatures, types and structure layouts were often wrong, while logic could be invented, omitted or subtly changed.
An agent acting as a reviewer did not reliably catch those deviations. Heumann explains the underlying problem in a sentence that became a central lesson of the project: “We never properly defined ‘correctness’.” A reviewer can debate whether code looks reasonable; it cannot consistently detect an invisible mismatch when no objective oracle has been specified.
How the verification harness changed the result
Compiling with the original toolchain
The team switched to the compiler used for the original game and built a verifier that compared object-code functions produced from the reconstructed C++ with the corresponding functions in the original executable. This made the compiler’s output, rather than a human judgment, the primary feedback signal.
Handling relocations correctly
Raw byte comparison has a technical trap: relocation addresses can differ even when the instruction and referenced object are correct. The verifier therefore excluded relocation bytes from a direct comparison and checked the referenced symbol and offset instead. The account also says the system checked data and types, not only instruction bytes.
Continuous regression checks
Recorded comparisons were rerun in CI. A change that fixed one translation unit but altered another could therefore be detected quickly. This is a different workflow from asking an agent to inspect a diff and declare it safe: each accepted change had to survive a repeatable comparison against the original.
Heumann summarizes the practical lesson as follows: “A reliable verification harness that delivers an objective PASS or FAIL signal is the best feedback an agent can get.” That is his project takeaway, not a universal law that every game task must use byte equality. For a game with a different compiler, platform or rendering pipeline, another oracle—behavioral tests, replay traces, network protocols or visual checks—may be more appropriate.
What the reported 99% and 83% figures mean
| Figure | What it describes | How to interpret it |
|---|---|---|
| 99% of functions present | Functions in this reconstruction that Heumann says were represented in the rebuilt code | A coverage claim for one project, not a general agent completion rate |
| 83% byte-exact | Functions whose compiled output matched the original under the project’s comparison method | A compiler- and harness-specific equivalence result, not a score for recreating arbitrary games |
| 600–700 billion estimated tokens | Approximate aggregate usage reported by Heumann, with missing session logs | Not an audited measurement and not a defensible standalone cost figure |
Heumann also says the game ran with all original features present and that the remaining unmatched functions were believed to be semantically correct after repeated revision. Those are claims from the project author. The available accounts do not show an independent group reproducing the result or auditing every function.
Byte equality is unusually strong evidence for the portions it covers, but it is not automatically the right acceptance test for a new game. Two source implementations can be behaviorally identical while compiling to different instructions. Conversely, matching bytes in a function does not prove that an untested interaction among systems, assets, timing and networking is correct. The metric is powerful because its scope is explicit, not because it answers every definition of “recreated.”
What other evaluations tell us—and what they do not
Several 2026 evaluations provide useful context, but they measure different inputs and outcomes. Their scores cannot be placed on one leaderboard.
| Evaluation | Input and scope | Reported result | What it does not measure |
|---|---|---|---|
| GameCraft-Bench | Agents create 2D games in Godot from specifications | Strongest listed configuration: 68.44 overall, with separate mechanics, depth, visuals and art scores | Unity, Unreal, 3D games, multiplayer, large-scale physics, long production workflows or subjective fun |
| GameEngineBench | 110 scoped native C++ tasks in Unreal Engine 5 projects drawn from nine repositories | Strongest reported pass@1: 55.5%; 31 tasks were unsolved by every tested configuration | Whole-game reconstruction from a binary or source tree |
| GameReplica | Black-box replication from screenshots and action input, with no source code or documentation, across 125 tasks in 25 games and five difficulty levels | Top model: 71.6%; other evaluated models: 4.0–42.9% | It found visual-fidelity scores stronger than implementation and rule consistency, so resemblance did not guarantee recovered rules |
| Retrobench | Raw MIPS assembly for N64-era functions; agents write C compiled with the original IDO compiler | Success requires byte-for-byte machine-code matching | It is a narrow function-level reverse-engineering benchmark, not a whole-game test |
GameCraft-Bench asks whether an agent can turn a written specification into a small 2D Godot game. GameEngineBench asks whether it can make bounded changes inside an existing Unreal project. GameReplica asks whether it can imitate black-box behavior and appearance without internals. Retrobench asks whether a function can be reconstructed to a strict compiler oracle. Heumann’s project combines a much larger scope with binary inspection, a custom toolchain and a long-running human-managed process.
How to compare an agent game-reconstruction claim
Before accepting a percentage, align five dimensions:
- Input access: Was the agent given a source repository, a compiled executable, assembly, a text specification, screenshots or only action traces?
- Scope: Does the result cover one function, a set of engine tasks, a playable slice or the whole game?
- Correctness measure: Is success defined by visual similarity, behavior tests, pass@1, replay consistency or byte matching?
- Human and tool support: Were specialists, reverse-engineering tools, prompts, reviewers, task tracking and verification harnesses involved?
- External validation: Is the number an author’s account, a benchmark evaluation or an independently reproduced result?
A 71.6% black-box replication score and an 83% byte-exact decompilation result are not competing estimates of “AI game ability.” They answer different questions under different evidence standards. Reporting them without these qualifiers creates a misleading impression of progress.
Rank #4
What a credible reconstruction workflow looks like
If you have lawful access to a game’s source or executable and want to test agents, the 2026 case suggests a process rather than a magic prompt.
1. Define the acceptance test first
Decide what “recreated” means before assigning work. For source-based maintenance, that might be a clean build, automated tests and deterministic replays. For binary reconstruction, it could be compiler-output comparisons, selected behavior traces or both. Include platform, compiler, build flags and tolerated differences in the definition.
2. Establish a baseline
Record which menus, maps, modes, save paths and tools work in the original. Capture representative inputs and outputs so a later failure can be localized. A game that merely starts is too weak a baseline to diagnose systemic differences.
3. Partition the project
Break work into translation units or other bounded components with explicit dependencies. Issue-based tracking lets several agents work in parallel while preserving ownership and review history. Keep an inventory of functions and data types so “present” means something auditable.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →4. Give agents the right inspection context
Source agents need build scripts, headers, tests and asset formats. Binary agents need disassembly, decompiler output, call graphs, symbol references and runtime observations. A coding model cannot infer unavailable evidence simply because it is given more prose.
Best Value
5. Compile and check every change
Run the target compiler and verifier after each bounded change. For relocation-sensitive binaries, compare symbols and offsets rather than treating every address byte as significant. Store results so regressions are visible in CI rather than discovered after a large merge.
6. Review failures by category
Separate missing functions, wrong signatures, incorrect structure layouts, invented logic, data mismatches and environment-specific differences. This prevents a visual or launch success from masking a deeper semantic failure.
7. Require independent validation
Have someone who did not author the reconstruction run the recorded tests and inspect the comparison coverage. An author’s claim can be valuable evidence while still falling short of an external audit.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteCommon failure modes
- “It launches, so it is correct.” Startup proves only that one execution path works. Add subsystem coverage and repeatable behavior checks.
- “The reviewer agent will catch it.” Review without a defined oracle cannot reliably detect plausible but wrong types, layouts or logic. Turn disagreements into executable checks.
- “A high visual score proves the rules were recovered.” GameReplica’s results show visual fidelity can exceed implementation and rule consistency. Test state transitions, collisions, timing and edge cases separately.
- “Byte matching is always the goal.” It is ideal for a decompilation target built with a known compiler, but unnecessary or counterproductive when behavior is the actual product requirement.
- “Token volume predicts success.” The 600–700 billion figure is approximate and project-specific. More tokens cannot substitute for correct decomposition, tooling and verification.
So, can agents recreate a game from source code?
For a game whose source is genuinely available, agents can help implement, port and test substantial portions, but Heumann’s October 2026 account’s strongest evidence is not a simple source-to-source demonstration. It is a three-month, human-orchestrated decompilation effort in which agents worked with specialist tooling and a strict verification harness.
That effort reportedly reached 99% function coverage and 83% byte-exact output for the checked reconstruction, while preserving the game’s features according to its author. The result is significant because it shows agents contributing to a long, instrumented reverse-engineering pipeline. It does not show that a single agent can take an arbitrary game and independently recreate it, nor that benchmark scores for 2D generation, scoped engine edits or screenshot imitation answer the same question.
The practical answer is therefore conditional: AI coding agents can be part of a credible game-recreation workflow when humans define the scope, supply the right evidence, divide the work and enforce objective tests. Without those controls, a convincing launch screen or visual imitation can conceal incorrect game logic.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
