REA reverse engineering agent: design, cases, and limits

REA is a TypeScript and Node.js project, managed as a Turbo monorepo and tested with Vitest. It does not include its own decompiler. It is an MCP server: a standard interface layer that turns existing desktop tools, Ghidra, IDA, Hopper, JADX, into functions an agent can call directly.

The growth numbers explain the attention. The repository went from about 15,000 stars to more than 230,000 during the first week of October, according to reporting on the surge, and it stood at 398,202 stars on October 27, 2026, by direct count. The reason is the ratio of cost to value: one setup command delivers an entire reverse-engineering toolchain to any agent that speaks MCP.

If you are new to the project, start from the two companion guides on this site, linked below: the REA MCP setup tutorial covers installation and common fixes, and How REA works explains the investigation workflow in depth.

Three barriers kept this work manual for years, and they compound each other.

The tools had no common interface. Ghidra, Hopper and IDA are GUI desktop applications with no shared programming surface. An agent that wanted to analyze a binary had to either avoid the tools or use glue code written per tool.

The process left no record. A serious reverse-engineering result is a chain of evidence: which function sits at which address, who calls it, what the decompiler produced. Traditionally only the conclusion survived, in the analyst's head or a final report. An agent that reports conclusions without evidence cannot be trusted or checked.

Experience did not transfer. A senior analyst's method, search strings first, follow cross-references next, verify suspicious points in the disassembly, lives in that analyst's habits. It could not be written into the tools or reused by another analyst's agent.

Reverse engineering is not a compute problem. It is an orchestration problem: a fixed investigation sequence that someone has to standardize before an agent can run it. The sequence is open the binary, search strings, follow cross-references, read the call graph, decompile, then rebuild the feature. What is not fixed is the steering: the agent decides what to search for next, which reference to follow, which function to enter, and when to drop back to the assembly to verify.

You ask a question such as "how is this search feature implemented". REA queries and traces the target and returns findings with their evidence attached. The agent then explains the behavior, writes tests, or reconstructs the implementation. That standardization of the investigation flow is the specific thing REA contributed.

The bridge directory wraps each vendor tool behind the same MCP tool interface. Hopper, Ghidra and IDA keep their own APIs and startup behavior; the agent sees one consistent surface. Engines are selected and tuned through environment variables:

Adding an engine means adding a bridge implementation, not rewriting the interface above it. That single decision is why a small project could cover decades of accumulated decompiler quality instead of competing with it.

The second split is between static analysis and runtime capture. Static work, JavaScript, .NET and APK parsing, reads files without running them. Runtime work, process behavior and Frida-based verification, interacts with the live target. The target matrix is wide:

REA's result contract requires each analysis result to ship with its evidence and its limitations. The agent does not receive "this function handles audio panning". It receives: the function sits at address X, it is called by Y, here is the decompiled pseudocode Z, and here is the confidence boundary W of that conclusion. A finding without this trail would be unusable in engineering terms, because nobody could replay or challenge it. Evidence is what makes an agent's reverse-engineering output reviewable at all.

One command does three things: it registers the MCP server, installs the workflow instructions that teach the agent the investigation method, and backs up your existing configuration.

After a restart, the agent has the investigation capability. Official support covers Claude Code, Codex, Cursor, Gemini CLI and Grok Build; other MCP-capable clients can register the server manually. Step-by-step installation, including the common failure modes, is in the REA MCP tutorial linked below.

The documented cases are the strongest argument that this works, because each one can be checked.

DX-Ball, byte-level sound algorithm restoration. From the compiled x86 binary of the 1996 ball game, the agent recovered the stereo panning functions and rewrote them in C. The rewrite passed all 3,205 original test cases, and 63 compiled bytes matched the original exactly. This is the flagship demonstration that a result was not "looks similar" but verified identical.

Notion, the clipboard call chain end to end. Starting from the clipboard API in the Electron renderer process, the investigation passed through the preload scripts and IPC channel and reached the main process, recovering the full data format and message payloads of Notion's rich-text clipboard. A classic three-layer Electron trace.

Touhou TH04, bullet angle math from 16-bit assembly. From a PC-98 game, the agent recovered two bullet-angle calculations, fixed-angle and aimed, and cross-checked the reconstruction against output from period-correct compilers. Useful ground for modders and game-preservation work.

Sony Sound Connect, a standalone feature extraction. With a Samsung S24 Ultra attached, a developer had Codex analyze Sony's official Android app and trace the Wind Noise Reduction feature, then ship an independent app that toggles the setting directly. The closest case so far to commercial feature extraction.

A commercial shooter, 99% of functions rebuilt. A dozen agents working in parallel rebuilt 99% of a commercial shooting game's functions as C++, with 83% of the compiled output byte-identical to the original program. One honesty note: this case ran on Hex-Rays' official MCP rather than REA, but it belongs to the same wave and shows what parallel agent reversing can reach.

Smaller community reports tell the same story from another angle: one developer reversed his own home IoT software to computer control in under 12 hours, another traced his own television, a third reverse engineered his Xiaomi body-fat scale and open-sourced a dashboard for it. None of these authors were professional reverse engineers. They were developers who knew what to ask.

Agent-driven investigations like these run long and spend tokens fast, and the Multi-Model Coding Plan puts Kimi K3.1 Pro, including High Speed, alongside DeepSeek and GLM so your REA sessions keep a capable model behind them.

The barrier that actually fell is the professional one. Reverse engineering used to demand fluency in several esoteric tools plus years of accumulated judgment about where to look. REA moves the entry requirement to knowing what to ask and how to check the answer.

Three situations still stop it.

Commercial hardening. Heavily obfuscated code, anti-debugging tricks and virtualizer-based packers remain the decompiler engines' own limit, and no bridge fixes that. Agents stall on such targets today.

Kernel-level work. Drivers and kernel logic need deeper dynamic debugging than REA's static-first route covers.

Authorization. REA states its scope as legal research, education, interoperability and software preservation, on software you own or are authorized to inspect. The community cases follow that line: own television, own scale, own firmware.

The practical rule: if the job is understanding how a feature works in a target you may examine, REA fits. If the job is defeating commercial protection or touching DRM, REA cannot do it and should not be pointed at it.