The Modern Warfare 2 decompilation project has reached a wild milestone

Call of Duty: Modern Warfare 2 is being pulled apart and rebuilt in C++ with the help of AI coding agents. Not in a quick demo, either. The project has been running for weeks, produced almost 7,000 commits and consumed close to 200 billion AI tokens. The goal is fairly simple to describe, even if the work isn’t. Take the compiled 2009 PC game, work backwards from the machine code and recreate its logic as readable C++. Four AI agents are doing much of that work in parallel, backed by reverse-engineering tools, automated testing and a fairly traditional Git workflow. After roughly a month, they’ve reconstructed more than a third of the functions identified in the executable. That’s a lot of code.

Modern Warfare 2 is a sizeable target

Infinity Ward developed Call of Duty: Modern Warfare 2, with Activision releasing it in November 2009 for PC, Xbox 360 and PlayStation 3. It followed Call of Duty 4: Modern Warfare and included the campaign, competitive multiplayer and the two-player Special Ops mode.

The PC release runs on Infinity Ward’s IW 4.0 engine. Underneath the finished game sits a large native codebase covering graphics, networking, gameplay systems, platform features, menus, audio and plenty of supporting libraries.

Decompiling it means turning compiled instructions back into C++ that behaves like the original program.

That doesn’t mean simply asking an AI model to rewrite the whole game. The job has to be split into thousands of smaller pieces. Functions need to be identified, understood, converted, checked and then fitted back into a working codebase.

Four AI agents are working at once

The project uses four agents through Claude Code. Three handle decompilation work. A fourth reviews commits.

The agents don’t work in isolation. They share the same repository, pick up tasks through GitHub issues and use tools including IDA Pro and Ghidra to inspect the original executable. Debug symbols and other reference information also help them work out what individual functions are supposed to do.

Once an agent finishes a piece of work, it pushes the result into the repository. Automated checks then test whether the new code still builds and whether anything obvious has broken. It’s closer to running a small software team than firing off a few prompts.

Around 5,600 functions have been rebuilt

The numbers show just how large the job is. After about four weeks, 5,588 functions had been decompiled out of 16,324 identified functions. That’s roughly 34 per cent. The raw percentage doesn’t tell the whole story, though. The total also includes third-party libraries, runtime code and other pieces that may not need to be recreated individually. So the meaningful portion of the game’s own code could be further along than the headline figure suggests.

The reconstructed project can already launch. Playing the game is another matter. Maps don’t yet load properly, and several major systems still need work before the rebuilt version can run through normal gameplay. So it’s working software, but not a working Modern Warfare 2 replacement yet.

The token count is enormous

The most eye-catching figure is the amount of AI usage. The agents have consumed about 199.8 billion tokens. That number makes sense once you look at how the project operates. Multiple agents are running for long periods, repeatedly reading code, checking context, generating implementations, reviewing changes and responding to new problems.

A task like this doesn’t resemble asking a coding assistant to write a function or fix a bug. The agents have to keep operating across thousands of related tasks while the repository changes around them. That’s where some of the more interesting problems appear.

Long-running AI agents don’t always stay on track

One early problem was progress tracking. The project initially stored status information in one large document. Over time, that file grew beyond 10 MB. Feeding something that large back into an AI model becomes expensive and awkward, so the workflow moved toward individual GitHub issues instead. There are also behavioural problems.

Agents tend to favour smaller jobs. Give them a neat, contained function and they’ll usually get moving. Give them a much larger subsystem and they’re more likely to postpone it or break focus. They also don’t always follow the intended workflow. For example, agents may repeatedly run tests locally even when the continuous integration system is already handling those checks. None of this is catastrophic. It just means autonomous doesn’t mean unattended.

Context becomes a problem over time

AI models can only keep so much information active at once. During long sessions, earlier context has to be compressed or summarised. That creates another issue: instructions can lose importance.

The project compensates by feeding key rules back to the agents after context gets compacted. That helps, but maintaining priorities across weeks of work remains harder than maintaining them during a short coding session.

The team also found that giving the agents too many goals at once caused trouble. Originally, they were expected to decompile code while also modernising the C++ and improving portability. In practice, those jobs competed with each other. The workflow changed. First, recreate the original program. Clean it up later.

The project is still far from finished

At roughly 34 per cent of the identified functions, there’s still plenty left to do. Major parts of the game aren’t operational, and launching the executable is very different from successfully running maps, gameplay and networking. Still, the project already shows what happens when AI coding agents are used on a software job that lasts weeks instead of minutes.

They can produce a huge amount of code. They can work in parallel. They can use established reverse-engineering tools and fit into normal development workflows. But they also need structure.

Tasks have to stay manageable. Context has to be controlled. Reviews still matter. And when the project becomes complicated, the agents can make some of the same awkward choices you’d expect from a very busy development team. Only with a much larger token bill.