Article

REA: The Open-Source Toolkit That Gives Your AI Agent a Decompiler

REA: The Open-Source Toolkit That Gives Your AI Agent a Decompiler

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.

What REA actually is

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.

How the loop works

The workflow the project documents is deliberately simple:

  1. Point. Tell your agent what app and what feature you want to understand — "explain how search works in this notes app, and show me the evidence."
  2. Trace. The agent calls REA over MCP: decompile the relevant code, follow calls between functions, record what it sees.
  3. Rebuild. The agent explains the behavior in plain language, or writes and tests an implementation for your own project.

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."

The zero-setup trick: JavaScript analysis needs no decompiler

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.

What it can look at

The target list from the project README is genuinely broad:

TargetWhat you get backRequirements
Native binariesPseudocode, assembly, strings, symbols, callsHopper, Ghidra, or IDA
JavaScript / ElectronModules, imports, routes, IPCNode.js only — no native engine
.NET assembliesMetadata, CIL instructions, declared dependenciesNone (static only)
Android APKsManifest, classes, decompiled methodsHeadless JADX + full JDK
WebsitesPage structure, scripts, network observationsA Chrome-family browser
Saved network capturesRequests, responses, payload locationsHAR file or mitmproxy capture
FirmwareExtraction results, native-analysis handoffsBinwalk / Unblob on Linux
SQLite databasesTables, columns, triggers, sampled rowsLocal 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.

Where it falls short — honestly

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).

The responsible-use question

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.

Why this matters beyond the star count

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.

Keep reading
How a Userscript Adds Reddit-Style Nested Comments to Any Discourse Forum — No Admin Required
Read next →