Reverse engineering, the practice of figuring out how a program works by examining it directly, has traditionally required deep manual work: disassembling binaries, tracing function calls, and reconstructing logic by hand. A new project called REA (Reverse – Engineer Anything) aims to hand that process to AI coding agents, giving them the instrumentation needed to inspect running software and explain, modify, or rebuild its behavior. The project matters because it reframes reverse engineering not as a specialist skill but as a task a coding assistant can perform on request, with a human simply asking the right question.

What REA actually does

REA is installed as a toolset connected to an existing coding agent via a setup command (npx rea-agents@latest setup). Once connected, the agent gains the ability to inspect a target program, whether that is a desktop application, a browser-based game, or a web page, and read its underlying logic. According to the source material, REA can attach to a live process through a local debugging connection, pull loaded source files, and let the agent trace how specific features are implemented.

The flagship example used to demonstrate REA is a deceptively simple question: why does Windows Calculator return 220 when you compute 200 + 10%? Without REA, answering this requires manually inspecting instruction branches, identifying which operator IDs correspond to which jumps, and tracing stored values through helper functions, a slow process of labeling branches and checking which value gets divided or multiplied. With REA, the agent is simply asked to inspect Windows Calculator and explain the discrepancy, and it returns the answer directly: after a plus sign, the percent button takes a percentage of the first number rather than the second.

From explanation to reconstruction

REA’s stated goal goes beyond explanation. The project describes three levels of understanding a feature well enough to explain it, change it, or rebuild it. In the Calculator example, the agent doesn’t stop at describing the percent button’s behavior after addition; it also recovers the separate rule used after multiplication, where the percentage is applied relative to both input values, and then builds a small working calculator that reproduces both rules.

A second demonstration applies the same approach to a browser game, specifically a Chromium-derived dinosaur runner. Here REA inspects the live JavaScript through a local debugging connection, retrieves the game’s index.js source, and extracts the function that governs increasing speed over time. In a controlled test with obstacles and automatic scheduling disabled, the inspected game’s speed reportedly reached 10.0 after 4,000 update cycles and 13.0 after 10,000, following a rule where speed starts at 6 and increases by 0.001 per update, capped at 13. The agent then used that recovered rule to build a separate, smaller teaching implementation with adjustable speed, keeping the original game’s drawing and collision logic as a simplified version for illustration.

How this differs from traditional reverse engineering tools

Conventional reverse engineering tooling, disassemblers, decompilers, and debuggers, gives a human expert the raw material to work with but still demands that the person do the interpretive work: labeling branches, naming operands, and connecting code paths to observed behavior. REA’s pitch is that it shifts this interpretive layer onto a coding agent, which can inspect the same low-level material (instruction branches, command IDs, loaded source digests) and produce a human-readable narrative plus working code.

This is a meaningful shift in workflow rather than a new disassembly technique. The underlying inspection methods, attaching to a process, reading instruction branches, pulling live source over a debugging connection, are established practices in reverse engineering and browser development tooling. What changes is who performs the tracing and labeling step. Instead of a human reconstructing the calculation path, the agent does so and then demonstrates its understanding by rebuilding the feature from scratch, which also serves as a form of verification that the explanation is correct.

What it means in practice for developers

For developers curious about how an application or game actually implements a feature, REA offers a workflow where the heavy lifting of tracing logic is delegated to an agent that has been given direct inspection access. Trying it involves installing REA, connecting it to an existing coding agent, approving a setup plan, and restarting the agent before issuing natural-language prompts such as “Use REA to inspect this dinosaur game and show the speed rule.” For browser targets, this requires enabling a local debugging connection and supplying both the page URL and the debugging endpoint.

There are caveats worth noting. The demonstrations described rely on specific, documented versions, Windows Calculator 11.2508.4.0 x64 inspected with REA 4.1.0, and a particular Chromium-derived browser edition’s dinosaur game, so results on other versions or applications are not guaranteed to work identically. The project also frames its examples as controlled checks, such as running the game’s update function with obstacles and scheduling disabled to isolate the speed rule, which suggests that accurate reconstruction may depend on carefully scoping what is being tested. As with any tool that inspects and modifies running software, users should also be mindful of the legal and licensing terms attached to the software they are examining; the dinosaur game example is explicitly noted as BSD-licensed Chromium code.

Frequently asked questions

Does REA replace the need to understand reverse engineering concepts? Not entirely. The source material is structured to walk readers through the manual reasoning process first (identifying branches, tracing stored values) before showing how an agent automates that same reasoning, suggesting REA is meant to accelerate the process rather than make the underlying concepts irrelevant.

What kinds of programs can REA inspect? Based on the examples given, REA can connect to installed desktop applications and to browser-based pages or games through a local debugging connection, retrieving loaded source and instruction-level detail depending on the target.

Is REA only for security or RE specialists? The framing suggests otherwise: the tool is pitched at general coding agents and developers asking plain-language questions, with an option for experienced reverse engineers to skip directly to more advanced analysis guides.

Source: REA Reverse – Engineer Anything