Reverse Engineer Anything (REA): The MCP That Takes Apps Apart
Reverse Engineer Anything (REA) is a 417k-star GitHub MCP that lets Claude Code, Codex, and Cursor take apart binaries and apps. Setup, uses, and legal limits.

Reverse Engineer Anything — REA for short — is a GitHub project, morluto/rea, that hands AI coding agents a full reverse-engineering toolkit through a single MCP server. Its README calls it "one MCP for reverse engineering across binaries, applications, and runtime behavior," and the scope really is that wide: native binaries, JavaScript and Electron apps, .NET assemblies, websites, even Android devices.
It's MIT-licensed, has roughly 417,000 stars, and installs with one npx command. The idea is simple: instead of you learning Ghidra, your agent drives it, then reports back with evidence and stated limitations rather than confident guesses.
That power cuts both ways, so the legal lines get as much space here as setup.
What REA actually is
MCP, the Model Context Protocol, is how coding agents call external tools. Reverse Engineer Anything is an MCP server that wires your agent to reverse-engineering engines and built-in inspectors: you ask in plain language, and the agent picks the tools and answers.
Three design choices stand out:
- Analysis runs locally. Files aren't uploaded to some REA cloud service, though your agent's model still sees the findings it reads (more in the legal section).
- Answers come with evidence. Each finding carries its evidence and the limits of the analysis, so you can check the agent's work.
- It's agent-agnostic. Setup supports Claude Code, Codex, Cursor, Gemini CLI, and Grok Build, and any MCP-compatible client can register it manually. REA also ships as a Claude Code/Codex plugin and as an agent skill via skills.sh.
One warning up front: the only official sources for Reverse Engineer Anything are the morluto/rea repo on GitHub, rea.tools, and the rea-agents npm package, and the README notes that a lookalike repo or copied README doesn't make a download official. For a tool that opens untrusted binaries with your permissions, that matters.
How to set up REA
- Check Node.js. You need version 22, 24, or 26 on a recent patch release; the README lists the exact minimums.
- Run setup.
npx rea-agents setupregisters the MCP server with your agent and installs REA's workflow instructions, backing up any config it touches. - Restart your agent so the new server shows up.
- Optional: add a native engine. Deep binary work runs through Hopper, Ghidra, IDA, or Kuna. REA uses an existing install, or setup can install Hopper with your approval.
- Optional: install the CLI for scripting REA outside an agent.
npx rea-agents setup # register the MCP server and instructions
# restart your agent, then optionally:
npm install --global rea-agents
rea --help
rea update # or: npx rea-agents@latest setup
REA's MCP input schemas are compact by default to save context window; set REA_MCP_INPUT_SCHEMA_PROFILE=full in the server's environment for the full versions.
New to agents? Our Claude Code tutorial covers installing Claude Code, one of the agents REA's setup supports out of the box.
What working with REA looks like
You don't call REA's tools yourself. You ask your agent questions, and the productive ones name the target, name the behavior, and demand evidence:
- "How does this Electron app move clipboard data between the renderer and the main process? Show me the files and IPC channels you found."
- "What does the function behind this error message compute? Give me pseudocode and the addresses you checked."
- "Which network requests does this page make on load, and which script triggers each one?"
The agent picks the matching inspector and returns findings, the evidence behind them, and what it couldn't determine. Treat those limits as part of the answer: agents sound sure by default, and the evidence trail tells you whether they should. Also ask what it would check next if it were wrong. Reverse engineering rewards skepticism.
What REA can inspect: engines and built-in checks
The core targets:
| Target | What the agent can see | What you need |
|---|---|---|
| Native binaries | Pseudocode, assembly, strings, symbols | Hopper, Ghidra, IDA, or Kuna |
| JavaScript and Electron apps | Modules, imports, source maps, routes, IPC | Nothing extra |
| Websites | Page structure, scripts, network activity | A Chrome-family browser |
| Android | Manifests, classes, decompiled methods, connected devices | adb for devices; JADX and a JDK for APKs |
Beyond those, built-in static inspections need no engine at all: Go and Rust binaries, GPU code objects such as CUDA builds, ML model files in GGUF and safetensors formats, Unity IL2CPP metadata, Godot PCK archives, PE imports and certificates, ELF notes, Linux kernel modules, Erlang BEAM files, .NET assemblies, APK signatures, Flutter apps, and PyInstaller executables. The menu also stretches to WASM modules, EVM bytecode, SQLite databases, firmware images, and packet captures.
That breadth is the selling point: investigations cross formats — an Electron app with a native add-on, an installer wrapping a Go executable — and REA lets the agent follow the trail. If an agent driving an Android device over adb sounds familiar, it's the move behind Clean Your TV, which strips bloatware from smart TVs. REA takes it much further.
Bonus: turning recorded sessions into agent environments
The oddest feature skips binaries entirely: rea environment-build turns a HAR file, a browser recording of an app's requests and responses, into a tool environment an agent can call. Run it with AgentEnv and Docker:
rea environment-build ./session.har ./my-env --name my-env --json
agent-env run ./my-env
The README pitches these as RL environments: train and evaluate agents against a stand-in for the real app, not production. Clever, if niche. Scrub the HAR first, since recordings routinely capture cookies, auth headers, and tokens, and never commit one to a public repo.
Legitimate reasons to use REA
Plenty of reverse engineering is ordinary, legitimate work:
- Interoperability. Getting your tool to talk to an app with no public API and no documented file format.
- Security research and malware-analysis education. Learning how a suspicious binary works — inside an isolated VM, not on your daily machine.
- Software preservation. REA's own case studies lean this way. One rebuilds the sound-panning calculation from DX-Ball, the 1990s Breakout clone, passing 3,205 test cases against the original x86 code and reproducing all 63 compiled function bytes. Another recovers a bullet-ring calculation from TH04, a PC-98-era Touhou game, checked against historical compiler output. Behavior recovered and verified, not guessed.
- Understanding how an app works. A third case study traces Notion's Electron clipboard bridge through its preload script and IPC — the kind of question an integration bug raises.
- Auditing your own builds. The most underrated use. Point REA at what you ship and see what an attacker would see: source maps you forgot to strip, secrets bundled into a PyInstaller executable, native add-ons you didn't know were linked.
Where the legal lines are
This section matters more than the setup steps.
REA's disclaimer limits it to lawful research, education, interoperability, software preservation, and analysis of software you own or are authorized to examine. The tool doesn't enforce any of that; you do:
- Don't bypass DRM, license checks, or anti-cheat. An agent that's good at finding a license check is equally good at getting you sued.
- Don't probe software or services you have no rights to. Websites included: stick to your own properties or authorized targets, and respect the terms of service.
- Don't redistribute what you extract. Understanding how something works is different from republishing someone else's code or assets.
- License your engines. Ghidra is free and open source; IDA, Hopper, and JEB are commercial and need your own licenses. REA grants no license, key, or activation, and doesn't authorize cracked copies.
- Check the law and the EULA. Rules differ by country. In the US, the DMCA's anti-circumvention provisions are the usual tripwire; in the EU, the Software Directive allows decompilation for interoperability only under narrow conditions. Many EULAs ban reverse engineering outright. This isn't legal advice; when money, redistribution, or someone else's software is involved, ask a lawyer.
One privacy point that's easy to miss: REA analyzes locally, but your agent sends what it learns to its model. For sensitive targets, like a client's binary or an internal build, use a model and plan whose data terms you've actually read.
A lighter alternative: leanrea
Not everyone wants an MCP server. leanrea (aicodeking/leanrea, about 3.8k stars, MIT) is the minimalist take: one 8 KB skill file that teaches your agent to reverse engineer with plain CLI tools — strings, nm, otool, jadx, apktool, Ghidra, tshark, binwalk, sqlite3 — through its normal shell. No server; just add the skill:
npx skills add aicodeking/leanrea
It works with Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and other skill-capable agents, and its author's small benchmark claims a speed and cost edge over REA, with candid sample-size caveats. The catch: you maintain every CLI tool yourself and lose REA's packaged engines and built-in inspectors.
New to skills? Our guide on how to use Claude Skills explains how they load, and Ponytail shows how much a single well-written skill file can change an agent's behavior.
Who REA is for
Reverse Engineer Anything fits security researchers and students, developers stuck integrating with undocumented software, preservationists recovering behavior from old games and apps, and teams auditing their own releases before someone less friendly does.
It isn't for anyone hoping for a one-click crack; the project isn't built for that, and the legal exposure is yours. Nor does it replace an expert's sign-off: the evidence trail makes agent findings checkable, which is exactly why someone should check them.
REA works with whatever model your agent runs. Picking an open-weight model for a bring-your-own-model agent like OpenCode? Our GLM-5.3 breakdown covers sizes, prices, and what it takes to run.
FAQ
What is Reverse Engineer Anything (REA)?
REA is an open-source, MIT-licensed MCP server (morluto/rea on GitHub) that gives AI coding agents reverse-engineering tools for native binaries, Electron apps, .NET assemblies, websites, and Android devices. Analysis runs locally, and results come with evidence and stated limitations.
How do I install REA?
Use Node.js 22, 24, or 26, run npx rea-agents setup, and restart your agent. Setup registers the MCP server and installs workflow instructions, backing up your existing config first.
Which AI agents work with REA?
Setup supports Claude Code, Codex, Cursor, Gemini CLI, and Grok Build out of the box. Any other MCP-compatible client can register the server manually.
Is using REA legal?
The tool is legal; what you point it at decides the rest. REA is meant for lawful research, education, interoperability, preservation, and software you own or are authorized to examine. Bypassing DRM or license checks, or attacking software you have no rights to, can break both laws and license agreements.
Do I need IDA or Hopper?
Only for deep native-binary analysis, and Ghidra is a free option there. Many targets — Go, Rust, .NET, Electron, model files, PyInstaller executables — work with REA's built-in inspections alone. If you use IDA, Hopper, or JEB, bring your own license.



