REA Reverse Engineering Toolkit: Letting AI Agents Actually Dissect Binaries

Reverse engineering has long been a discipline that relies heavily on experience and intuition: dump strings, wade through disassembly, and hope the function you're reading happens to be the critical one. Most investigations stall before they can explain a single feature. REA (Reverse Engineer Anything) aims to change that — it gives programming agents a genuinely usable reverse engineering toolchain that transforms binaries into strings, cross-references, and readable decompiled code, with evidence behind every conclusion.

What REA Is: A Local Agent Reverse Engineering Toolchain

REA's core identity is clear: 94 subcommands, one local installation, no dependency on any cloud service, and all analysis running on your own machine. It's both a command-line tool and a local server — your AI assistant can talk to it through either entry point.

The entire workflow breaks down into three steps: decompile the target to recover code, strings, and symbol names; follow those threads until the agent can explain how a feature is actually implemented; then reconstruct that feature in your own stack. You only need a single prompt — describe an app you admire and the feature you're interested in, and the agent handles the rest. It opens the target, follows the evidence, and writes up its findings.

In terms of code scale, this is no weekend toy. The project has roughly 900 TypeScript files and hundreds of tests underneath, with source directories organized by provider, covering everything from Android to browsers. The command catalog is auto-generated from source, so it never drifts from the actual code. Everything is readable, with no service layer obscuring it — you can audit before you trust.

REA's use of the MCP (Model Context Protocol) architecture deserves a separate note. MCP is an open protocol proposed by Anthropic that enables AI models to call external tools and data sources in a standardized way. REA exposes all its subcommands through a local MCP server, meaning any MCP-compatible AI client (such as Claude Desktop, Cursor, etc.) can invoke REA's reverse engineering capabilities directly without extra adaptation. This is fundamentally different from the traditional "paste code to AI" approach: agents can actively initiate tool calls, receive structured responses, and decide on next actions based on results — forming a true reasoning-execution loop rather than single-turn Q&A.

Installation and Environment: Up and Running in a Minute, Bring Your Own Engine

The installation barrier is low: install the executable, point it at an analysis engine, and let setup register everything with your agent. The key detail — setup shows you exactly which files it will touch before doing anything, requires your approval at each step, and offers a dry run to preview the plan without executing it.

System requirements are modest: Node 22 or later, running on Linux or macOS, with nothing on the list requiring sudo. Static JavaScript analysis doesn't require any engine at all, which is why you can try things out before installing any engine.

Deep native analysis is what requires an engine. Ghidra is the free, open-source first choice; Hopper is another first-class option (runs in demo mode without a license); IDA is also supported. Configuration typically only requires exporting an install path and Java home, then running the doctor to confirm. The doctor checks runtimes, system state, and every configured engine — on a fresh machine it will honestly tell you "nothing is wired up yet" and then tell you how to fix it.

Ghidra, Hopper, and IDA are the three mainstream decompilation engines in the reverse engineering field today, each with a distinct focus. Ghidra was open-sourced by the NSA, supports major architectures including x86, ARM, and MIPS, is completely free, and has the most active community ecosystem — though it requires a Java runtime. Hopper is a commercial tool for macOS/Linux with a lightweight interface and scripting support; demo mode gives access to core features with save restrictions. IDA Pro is the industry standard, with the highest decompilation quality, particularly when dealing with complex obfuscation or commercial firmware — though licensing costs are substantial. REA abstracts all three as interchangeable "providers," binding the toolchain to none of them, so users can choose freely based on existing licenses and target platform.

Evidence First: Every Conclusion Comes With a Receipt

REA's most noteworthy design philosophy is the "evidence bundle." Every answer records what was observed, where the source is, how confident the conclusion is, and what remains unknown. Whether accessed from the command line or the server, the agent reads the same structure either way. As the video puts it — "a claim without a receipt is just a claim."

These evidence tools are just ordinary subcommands: export in a canonical format, import evidence bundles produced by others, compare two runs, or diff a submitted build against the version the app actually shipped. All of them can be run directly from the shell without going through an agent. Snapshots of expensive analyses can be saved to disk and the next question answered from the file, avoiding the cost of re-running the engine — and the files are local, owner-readable only, and deletable at any time.

The command line and server are "one implementation, two doors": they run the same workflows and the same contracts. What you get in the terminal is exactly what the agent sees. Exit codes honestly report success, failure, or signal back to scripts. Nothing is uploaded at any point — analysis only happens on the local machine.

REA's evidence bundle design solves a core problem in AI agent engineering: tracing hallucinations. When an AI model draws conclusions based on tool responses, if the tool only returns plain-text answers, there's no way to verify whether the model is citing real data or "filling in blanks." Structured evidence bundles build verifiability into the tool contract itself — by mandating that every claim record its source file, line number, and confidence level — rather than relying on the model's self-restraint. This is conceptually similar to citing document passages in a RAG (Retrieval-Augmented Generation) system, except REA's evidence is engineering fact dynamically extracted from binaries rather than static corpus. This design lets every step of an agent's reasoning be independently audited by a human reviewer or a downstream automated process.

Beyond Binaries: Static Analysis Across Multiple Target Types

REA's capability surface is broad: 41 native inspection tools, 14 investigation workflows, plus separate command families for artifacts, managed code, firmware, Android, and browsers. 18 providers underpin the entire analysis capability.

A compelling example is Electron/JavaScript applications — REA can map them without running a single line of code. On a real desktop app, it recovered a complete list of inter-process communication channels without launching the application: history, downloads, hotkeys, dialogs, update checks — 45 channels in total, each traced back to the exact line of code that declared it. Beneath the channels is a larger graph: each node carries a type, containing source ranges, expressions, reads, call sites, and bindings — all recoverable from files that were never executed.

But REA is also candid about its limits: because nothing was run, dynamic relationships remain unresolved, and the documentation says so in the same paragraph that lists the findings. An agent that knows its limits reports unknowns rather than fabricating answers. Missing evidence never counts as passing.

Electron applications are a special class of reverse engineering target worth some background. The Electron framework bundles a Chromium browser engine with a Node.js runtime into a single desktop application, so distribution packages are essentially web applications containing HTML, CSS, and JavaScript alongside a local runtime. Developers typically package assets using the asar format, which isn't encrypted but does prevent direct browsing. Electron applications have main and renderer processes that communicate through IPC (inter-process communication) channels, and these channel declarations exist entirely within static JavaScript files. REA's ability to parse all IPC channels without launching the application exploits exactly this property — source-level declarations leave ample statically analyzable traces without touching any runtime state.

Honesty as the Foundation of Trust

What's most compelling about this tool is its candor about what it can't do. Request deep native analysis without a configured engine, and REA politely declines — it points out the missing provider, explains why, and gives you the fix command. No silent degradation, no fabricated answers.

Engines are bring-your-own. Ghidra, Hopper, and IDA are independent products with their own licenses, and setup never installs any of them without asking. JavaScript static analysis doesn't need them, so the free path is genuinely free. Session termination is also part of the contract: if a session ends abnormally, REA reports which resources couldn't be verified rather than quietly claiming a clean exit. Closing a session removes temporary projects but leaves your own tools and work untouched.

The most critical bottom line: no decompiler can promise to restore original source code, and REA says so in plain language. It explains how it reached a conclusion, but it never claims it can clone an app for you. Evidence, not enthusiasm — that is its entire promise.

Engineering Maturity and Roadmap

REA is not a dormant project. Recent commits mix documentation fixes, semantic analysis fixes, and MCP prompt work, indicating active maintenance. The repository runs focused tests, full checks, and real provider validation, with hundreds of test files proving the boundaries — claims about engines are validated against the engines themselves, and results that can't be validated don't pass. CI runs the same checks you can run locally.

Version iteration is also clear. Version 4 shipped Android package analysis, firmware extraction, Ghidra annotations, and Windows support in a single release. Feature additions include issue numbers, making it easy to trace what changed and why. The roadmap is public and pragmatic: the current focus is keeping documentation accurate and expanding native coverage, followed by deeper layering between static extraction and runtime observation, better comparison for obfuscated builds, and more runtime behavior analysis.

Uninstallation is also clean: the uninstaller only removes registrations it owns and doesn't follow symlinks into your data directories. Keep your engines, keep your evidence — only the integration is removed.

Conclusion

REA moves reverse engineering from "guess-driven" to "evidence-driven," and delivers that capability to AI agents in a locally auditable, no-upload, receipt-attached way. 94 subcommands, 80 cataloged commands, 18 providers, a binary on your path, and no account required — for developers and security researchers who need to follow strings all the way to pseudocode, this is a toolchain worth serious evaluation.