
Some developer tools sell you a feature. REA sells you a detective.
Picture this: a competitor's desktop app has a clever sync behavior you want to understand, or a client shipped you an Electron app and the source is long gone. Historically your options were to fire up Ghidra and spend a week, or shrug. REA — short for "Reverse Engineer Anything," the MIT-licensed open-source project at morluto/rea — proposes a third option: hand the target to your AI coding agent and let it interrogate the software with real reverse-engineering tools, then report back with evidence attached.
The project exploded across Chinese developer forums this month, where it is being discussed as the missing link between AI agents and the old world of decompilers. It's not hard to see why. Star trackers recorded one of the fastest climbs GitHub has seen — crossing 100,000 stars on October 11 and 200,000 on October 13, 2026, sitting past 240,000 at the time of writing. One line is all it takes to try it: npx rea-agents setup.
REA is not a decompiler. It is a bridge. It ships as both an MCP server and a standalone CLI, so the same capability runs inside an agent session (Claude Code, Codex, Cursor, Gemini CLI, Grok Build and others, per the README) or straight from your terminal.
Under the hood, it plugs into the heavyweights professionals already use — Hopper, Ghidra, and IDA — and adds its own readers for targets those tools don't cover natively: JavaScript and Electron apps, .NET assemblies, Android APKs, websites, saved network captures, even firmware. The agent drives, the tools do the seeing, and REA structures everything into an evidence bundle: what it found, where it found it, and what it can't be sure about.
That last part is what separates it from a chatbot guessing at a hex dump. Per the project README, every conclusion comes with evidence and stated caveats, and analysis runs entirely on your own machine — the binary under inspection is never uploaded to a hosted service.
The workflow the project documents is deliberately simple:
The README illustrates the idea with case studies: tracing the clipboard bridge in Notion's Electron client, recovering a bullet-hell bullet-ring calculation from a DOS-era game, reconstructing a sound-panning helper well enough to reproduce all 63 compiled function bytes. Whether you believe every demo or not, the pattern is clear — REA is designed for "understand this feature," not "clone this app wholesale."
Here's the part that made it catch fire in developer communities. Static analysis of JavaScript and Electron apps requires no native analysis engine at all — no Ghidra install, no IDA license, no running the target application. An Electron app, as one explainer put it, is "a web app in a trench coat": minified JavaScript inside an ASAR archive, never compiled to machine code, so static analysis works fine.
One command inspects an extracted app directory and returns modules, imports, routes, IPC boundaries, and the evidence behind each finding:
npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app --json
To install the rea command for regular use:
npm install --global rea-agents
rea --help
The documented output splits into four fields: evidence, a recovered graph, limitations, and unknowns. That split — not a verdict — is the whole design philosophy. It hands your agent a map with the blank spots labeled instead of an answer that hides them.
The target list from the project README is genuinely broad:
| Target | What you get back | Requirements |
|---|---|---|
| Native binaries | Pseudocode, assembly, strings, symbols, calls | Hopper, Ghidra, or IDA |
| JavaScript / Electron | Modules, imports, routes, IPC | Node.js only — no native engine |
| .NET assemblies | Metadata, CIL instructions, declared dependencies | None (static only) |
| Android APKs | Manifest, classes, decompiled methods | Headless JADX + full JDK |
| Websites | Page structure, scripts, network observations | A Chrome-family browser |
| Saved network captures | Requests, responses, payload locations | HAR file or mitmproxy capture |
| Firmware | Extraction results, native-analysis handoffs | Binwalk / Unblob on Linux |
| SQLite databases | Tables, columns, triggers, sampled rows | Local database snapshot |
Native analysis rides an existing Hopper, Ghidra, or IDA install (setup can optionally install Hopper with your approval), and REA's docs stress that each runtime capture runs with its own consent step and a description of its effects.
The hype deserves a counterweight, and the project's own community has been supplying it. In a documented hands-on test on a heavily obfuscated single-line UMD bundle, REA located the two axios call sites but could not extract the URLs, because they were assembled dynamically at runtime. For that kind of target it's a "call-site locator," and finding the hidden endpoints still meant manual grep-and-read through the code.
That matches the README's own framing: REA doesn't promise to recover original source code or clone applications wholesale. Static analysis is only as good as what the code reveals without running, and heavily obfuscated or dynamically-assembled logic will always leave gaps. Treat the unknowns field as a feature, not a bug — it's the tool telling you where its vision runs out.
Also worth knowing: the project changes fast. The README recommends keeping installations updated, and refreshing agent registrations after updates (npx rea-agents@latest setup, then restarting your agent).
Any tool that cracks open compiled software raises the obvious question, and the project doesn't dodge it: the README carries a disclaimer, and community guides emphasize lawful research, education, interoperability, and analyzing software you own or are authorized to examine — being inspired by how something works, not copying someone else's code and designs. Licensing rules and fair-use doctrines vary by jurisdiction, so the sensible move is to check before shipping anything derived. That boundary — inspect to understand, respect the license — is the norm the Chinese developer discussions have been converging on too.
REA's viral week is really a milestone for a broader shift: AI coding agents are moving past writing code and into reading the world around them. We've already watched agents learn to drive browsers, run terminals, and query databases. Now they can stare down a binary and ask, "how does this feature work?" — and get an answer grounded in decompiled code rather than a hallucinated explanation.
That capability is double-edged, and both edges are real. But as a developer tool it fills an honest gap: the knowledge locked inside compiled software has always been one expert away, and now it's one good prompt away. The tool will still show you its blind spots. Whether you fill them in is up to you — which is exactly how a detective should behave.