This Open Source Tool Lets AI Reverse Engineer ANY App

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: This Open Source Tool Lets AI Reverse Engineer ANY App · Channel: Dispatch · 04:10 · Watch on YouTube

Topics: AI agents, Cybersecurity and software security, Open source and software ecosystems

Summary

REA is an open-source tool that lets AI agents investigate apps and other software through a single MCP server, using established reverse-engineering engines and returning evidence for its findings. It supports targets ranging from native binaries and JavaScript apps to Android, .NET, websites, network captures, firmware, and game files. The video demonstrates analyzing Notion’s Electron app and reconstructing a function in DX-Ball, with the latter’s implementation passing 3,205 tests and matching the original function’s 63-byte output. REA runs locally, distinguishes observations from inferences and unknowns, and is presented for lawful research and software users are entitled to examine.

Key points

REA stands for “reverse engineer anything” and provides reverse-engineering capabilities to AI agents through one MCP server.
It can drive tools such as Ghidra, Hopper, and IDA, while integrating with agents including Claude Code, Codex, and Cursor.
REA runs locally and reports evidence, limitations, and unknowns, separating observed findings from inferences.
Supported targets include native binaries, JavaScript and Electron apps, .NET assemblies, Android apps and devices, websites, network captures, firmware, games, Go and Rust binaries, and AI model files.
The agent setup command detects available agents, previews the configuration changes, and makes backups; nothing is written until the user approves.
In the Notion example, static analysis identifies a context bridge API and a renderer IPC call, with exact source locations to guide further investigation.
For DX-Ball, the agent used raw instructions and constants when decompiler output was incomplete to reconstruct sound-panning behavior.
The reconstructed DX-Ball function passed 3,205 tests against the original and compiled to the same 63 bytes.
REA is open source under the MIT license; the video emphasizes lawful research, interoperability, preservation, and software users own or may examine.

Chapters

Start	Chapter	Summary
00:00	Introducing REA	The video presents REA as a unified, evidence-based alternative to using separate reverse-engineering tools or relying on an AI model’s guesses.
01:34	Supported targets and setup	REA’s supported file and app types are listed, followed by a walkthrough of connecting it to an agent or using its terminal commands.
02:38	Analyzing Notion and asking an agent	A Notion Electron app analysis traces IPC-related code, then the video describes how an agent can investigate and implement a requested feature.
03:09	DX-Ball reconstruction and recap	The video shows a tested reconstruction of DX-Ball’s sound-panning function and recaps REA’s evidence-focused, locally run, open-source approach.

Quotes

Meet REA, short for reverse engineer anything — 00:00

REA puts all of that behind one MCP server — 00:32

It all runs locally and every result separates what was observed from what was inferred and lists what is still unknown. — 01:03

The reconstructed C function passes all 3,205 tests against the original and compiles to the exact same 63 bytes. — 03:39

It’s open source under MIT. — 04:10

Concepts and entities

REA, MCP, Ghidra, IDA, Hopper, Claude Code, Codex, Notion, DX-Ball

Full transcript (original language)

00:00 You’re using an app and one feature just works beautifully and you wonder, how did they build that? But there’s no source code. All you have is what shipped, a compiled binary, a minified bundle, a folder full of files. Meet REA, short for reverse engineer anything, an open source tool that lets your AI agent answer that question with evidence. Reverse engineering usually means a drawer full of separate tools. Ghidra or IDA for native code, Jadx for Android,

00:32 browser dev tools for websites, Wireshark for network traffic, each with its own interface and learning curve. And an AI model without those tools simply guesses. It sounds confident, but nothing is backed by the actual bytes. REA puts all of that behind one MCP server, the standard way agents like Claude Code, Codex, and Cursor call outside tools. Your agent asks a question. REA inspects the target and traces the relevant code, driving engines like Ghidra, Hopper, or

01:03 IDA when needed. Then it returns findings with the evidence behind them. It all runs locally and every result separates what was observed from what was inferred and lists what is still unknown. So, what can it read? Native binaries with pseudo code, assembly, and cross-references. JavaScript and Electron apps with modules, preload scripts, and IPC. .NET assemblies, Android apps, and even live Android devices.

01:34 Plus websites and network captures, firmware, Unity and Godot games, Go and Rust binaries, and even AI model files. Let’s try it. Step one, connect REA to your agent. With Node installed, one command does it. NPX REA agent setup. It finds the agents on your machine and lets you pick which to configure. Then it shows the exact plan, which config files it edits with backups. Nothing is written until you approve.

02:05 Restart your agent and the tools are ready. Prefer the terminal? Install it globally and the same workflows run as REA commands. Step two, inspect a real app from the terminal. Here’s a real case from the REA showcase, the Notion desktop app. It’s built on Electron. So we point REA at its preload script and run analyze JavaScript application. It parses the code statically without running the app. And it finds two key things, a context bridge exposing an API

02:38 and a renderer IPC invoke call. Each comes with its exact source location, file, line, and columns. Those anchors tell the agent where to read next through IPC into the main process and down to Electron’s clipboard write. That’s how Notion’s rich copy and paste works. Step three, just ask your agent. Usually, you won’t type commands at all. You just ask your agent, “Understand how search works in the notes app, show me the evidence, and build a similar

03:09 feature.” The agent opens the target, searches for the feature, decompiles the functions, and follows the cross-references. Then it writes an implementation and tests it. How far can that go? Another showcase targets DX-Ball, a classic ’90s Windows game, to recover how it pans a sound when the ball hits a brick. The decompiler output was incomplete. So the agent read the raw instructions and constants. Multiply by 1.5625,

03:39 subtract 500, apply a stored scale. The reconstructed C function passes all 3,205 tests against the original and compiles to the exact same 63 bytes. That’s what sets REA apart. Results carry their evidence, limitations, and unknowns. So, you check the work instead of trusting a guess. And it’s built for lawful work, research, interoperability, preservation, and software you own or

04:10 may examine. Tools like IDA or Hopper need valid licenses. To recap, REA gives your agent one MCP server for reverse engineering, native binaries, electron apps, Android, .NET, and more. It runs locally, and every finding comes with evidence. It’s open source under MIT. Run NPX REA agent setup and find the repo and guides below. Thanks for watching.