REA decompiles everything without source code: the repo blowing up GitHub in 48 hours
🔎 An agent that opens software's black boxes
On October 7, 2026, a developer signing as "morluto" publishes REA — Reverse Engineer Anything. An open source MCP server paired with a CLI that gives any coding agent an unprecedented power: decompiling native binaries, Electron apps, .NET assemblies, Android APKs, even websites — then explaining how a feature works without ever seeing the original code.
The next day, the repo racks up around 2,956 stars in 24 hours and snags the top spot on GitHub trending. Within days, the counts climb from 10,400 to over 14,000 stars, topping the TypeScript repos, with 32 releases published (StartupFortune, dev.to).
Why now? Because the last missing building block for agents has just fallen into place. They've been able to write code for two years. They can now read any software, even closed-source. And the same technical building block serves both to understand software and to attack it — that's the whole unease of this week, mirroring the ARTEX project shared in parallel.
To follow this kind of launch as it happens, our watch of new AI tools is updated continuously.
The essentials
- REA = open source MCP server + CLI, shipped on October 7, 2026, #1 on GitHub trending from day one (~2,956 stars in 24 hours, 14,000+ within days).
- It connects your agent (Claude Code, Cursor, Codex, Gemini CLI, Windsurf, Devin, Copilot CLI…) to 41 binary inspection tools and 14 guided investigation workflows.
- Three-step loop: decompile → trace → recreate the logic in your own stack, without ever seeing the original code.
- Legitimate uses: closed-source dependency auditing, taking over legacy binaries, interoperability.
- Gray-area uses: competitive intelligence, proprietary code protection — an Electron app got reverse-engineered in 10 minutes.
- Documented limitations: binaries too large for the context window, Windows tools without headless mode, no real-time collaboration.
Recommended Tools
| Tool | Main use | Price (October 2026) | Ideal for |
|---|---|---|---|
| REA | Agent-driven decompilation and investigation | Free (open source) | Devs, auditors, reverse engineers |
| Claude Code | Host agent to drive REA in the terminal | Included with Pro/Max (from $20/month, check anthropic.com) | Long investigations on large models |
| Cursor | MCP host agent directly in the IDE | ~$20/month (check cursor.com) | Investigation integrated into daily work |
| Ghidra | Headless decompilation of native binaries | Free (open source) | Native binaries, lightweight firmware |
| JADX | Android APK decompilation | Free (open source) | Android apps |
| Frida | Dynamic instrumentation | Free (open source) | Runtime tracing |
| radare2 | Low-level disassembly | Free (open source) | Fine-grained analysis, exotic formats |
To choose the host agent that will drive REA, see our comparison of the best AI tools for code.
REA, what exactly is it? An MCP that turns your agent into a reverse engineer
REA is an MCP server — the connection standard between agents and tools — that plugs your coding agent into the full arsenal of professional reverse engineering. You give it a binary, an Electron app, an APK, or a URL; it investigates the functionality, explains how it works, shows its evidence, then builds a version tailored to your stack and your requirements (mcp.market).
Installation takes a single line (official repo):
npx rea-agents@latest setup
The server runs on Node.js 22+ and exposes a tool catalog organized into four families (dev.to):
- Binary analysis: format parsing, section enumeration, symbol extraction.
- Decompilers: headless Ghidra, Hopper bridge.
- Disassemblers: objdump, radare2, Binary Ninja via plugin.
- Runtime tracing: dtrace, strace, frida for dynamic instrumentation.
The development pace is staggering: 32 releases in three days, up to v6.1.0 on October 9. v4.1, released just hours after launch, already added APK analysis via JADX, firmware analysis via Binwalk and Unblob, and IDA Pro as an analysis backend — the same tools as professional reverse engineers, with an agent at the controls.
Two details make the difference. First, the MCP server maintains investigation state across tool boundaries: your agent switches from Ghidra to frida without losing the thread. That's the project's real contribution according to dev.to's analysis — not the frontend, but this persistent investigation memory. Second, OAuth credential injection enables API-level inspection, via Stripe or GitHub CLI wrappers, without ever exposing tokens to the agent.
Announced targets: native binaries, JavaScript/Electron apps (modules, imports, source maps, routes, IPC, native add-ons), .NET assemblies, Android APKs (ByteIota).
The three-step loop: decompile, trace, recreate
REA follows a pipeline described in the README: decompile, trace, recreate. It's this triptych that sets it apart from a mere decompiler — the last word isn't "understand," it's "rebuild."
Step 1 — Decompile. The agent extracts readable code and naming hints from the binary. Ghidra headless produces pseudo-C, symbols and imports are mapped.
Step 2 — Trace. The agent follows execution until it isolates the functionality you care about. This is where dtrace, strace and frida come into play: dynamic observation, network calls, real behavior — not just dead code on a page.
Step 3 — Recreate. The agent reimplements the logic in your stack, with your conventions, your tests, your requirements.
A concrete example: you use a SaaS tool whose CSV export function is slow and opaque. You point REA at it. The agent decompiles, traces the execution path, discovers that the export goes through a non-parallelized sequential worker, and hands you a clean reimplementation. What used to take weeks of reverse engineering becomes an afternoon of assisted investigation.
A classic decompiler hands you pseudo-C and leaves you alone staring at the screen. REA adds an agentic layer that formulates hypotheses, tests them, traces, validates and documents. That's the difference between a magnifying glass and a colleague.
Why It's Exploding: MCP Has Become Agent Infrastructure
REA isn't an isolated flash in the pan: it's the symptom of a shift. MCP has become the standard integration layer for agents, and GitHub's October 2026 trending page (github.com/trending) is a real-time snapshot of it.
We've already analyzed how the harness layer is becoming infrastructure, with two of the three trending repos on GitHub. REA fits exactly into this dynamic: the value no longer lies in the model, but in the tools the model can drive.
Three signals from the same week confirm it:
- OpenCode: 8 million devs, 172K stars — the open source coding agent that surpasses Claude Code and Codex: open source coding agents are scaling to industrial levels.
- Prime Agent: the #1 repo on GitHub (17,500 stars) that makes coding agents self-improving — and auditable: trust in what the agent does is becoming a product in itself.
- MiroFish: an undergrad builds 700,000 AI agents in 10 days — this open source project predicts the future and is exploding on GitHub: massive orchestration is no longer reserved for labs.
In this context, REA is the logical next step. Agents knew how to write code; what they lacked was the ability to read other people's code. And since REA is an MCP server, you plug in the model of your choice — Claude Opus 4.7 in Claude Code, GPT-5.5 in Codex, Gemini 3.1 Pro in Gemini CLI. The marginal cost of a new agent capability is trending toward zero. That's exactly what makes this type of repo explode in 48 hours.
Auditing closed-source dependencies: the serious use case
The first benefit for a professional developer isn't espionage: it's auditing. How many times have you integrated a proprietary SDK, a vendored binary, or a library with no published source, without knowing what it actually does?
Undocumented telemetry, unexpected network calls, identifier collection: traditional tools — surface-level static analysis, network sandboxing — give you clues. REA gives you answers, with a chain of evidence to back them up. The agent shows how it reached its conclusions, which changes everything in an audit context.
Two concrete scenarios where REA is a game changer:
The abandoned SDK. The maintainer has vanished, the source was never published, and your product depends on it. With REA, you map the behavior, isolate the critical functionality, then recreate it in-house. The third step of the loop exists precisely for that.
The unknown binary legacy. That old .NET assembly shipped with your information system, which nobody dares touch for fear of breaking something. Decompilation, tracing, a documented report: you finally know what it does, and you can replace it with full knowledge of the facts.
A methodological point: if you use an agent to audit, the agent itself must be auditable. That's the whole point of projects like Prime Agent, which make the agent's reasoning inspectable. An audit conducted by a black box isn't an audit — it's a gamble.
Competitive intelligence: the yellow line
Yes, REA makes reverse engineering of a competitor's product accessible to everyone. No, it is neither legal nor ethical in most cases — and this needs to be said clearly.
Technically, the game has changed. Understanding how a competitor implements a feature used to require a specialized team and weeks of work. It's becoming a single agent session. Clean-room reverse engineering — drawing inspiration from mechanisms without copying the code — has existed for decades, but its cost has just collapsed.
The legal framework, in a nutshell (this is not legal advice):
- The EU permits decompilation for interoperability in certain cases (Directive 2009/24/EC on the legal protection of computer programs).
- Copying decompiled code violates copyright, everywhere, period.
- The terms of service of products often prohibit reverse engineering, with varying force depending on the jurisdiction.
My position: use REA to understand mechanisms — architectures, patterns, protocols — never to copy code or assets. The "recreate in your stack" loop is legitimate when it concerns ideas and functional implementations, not copy-pasting disguised as rewriting.
And the mirror from the same week is a reminder: the same technical building block serves both to understand closed software and to attack it, as shown by the ARTEX project shared alongside. The controversy around models' hacking capabilities, reignited by Anthropic's accusation against GLM-5.3 shows that the question of what we allow agents to do has become political, not just technical.
Your proprietary code is no longer protected
If your moat rests on "nobody can see my code," that moat just died. An Electron developer learned it the hard way: their app was reverse-engineered in 10 minutes by an AI (Reddit, r/electronjs).
Electron apps are particularly exposed. Packaged JavaScript is still JavaScript, source maps sometimes linger in the archive, routes and IPC channels can be mapped out, native add-ons can be decompiled. REA explicitly targets this attack surface: modules, imports, source maps, routes, IPC (GitHub).
Three immediate consequences:
Security through obscurity is dead. Minification, obfuscation, asar packaging: all of that used to slow down a motivated human. It no longer slows down an agent equipped with 41 inspection tools.
The real moat shifts. Service, data, distribution, network effects: if your value lives on the server side, a decompiled client won't kill you. If it lives in the client, you have a problem as of today.
Detection becomes a line of defense. REA's API-level inspection goes through your endpoints — via the Stripe or GitHub CLI wrappers. Your logs, your rate limits, and your anomaly alerts are now your radar.
Concrete action: move sensitive logic to the server side, and design every client as public code from the very first line. That was already a security rule. It has become a rule of commercial survival.
What REA doesn't do (yet)
REA has limitations, documented by its own users — better to know them before sinking a day into investigation (dev.to).
Binaries too large for the context. A multi-gigabyte firmware doesn't fit in the context window. The agent loses the thread on very large targets. The workaround: split by sections and features, and let the MCP server maintain state between passes.
Windows tools without headless mode. x64dbg and IDA Pro can't be driven headless, which limits automation on these backends — even though IDA Pro has been supported as an analysis backend since v4.1.
No real-time collaboration. One investigation = one agent. No multi-developer sessions on the same trace, for now.
The host model's quality makes all the difference. The agent drives, but the LLM reasons. On a weak model, the investigation drifts quickly and produces plausible but false conclusions. For complex targets, stick to the top of the agentic ranking — GPT-5.5 (98.2), Gemini 3 Pro Deep Think (95.4), Claude Opus 4.7 (94.3) — see our comparison of the best LLMs for coding. For simple tracing, Claude Sonnet 4.6 (81.4) or GPT-5.3 Codex (80) are more than enough.
❌ Common Mistakes
Mistake 1: pointing REA at a multi-gigabyte target
The agent's context doesn't scale infinitely, and the investigation drifts on large targets. Solution: break it down by sections and modules, investigate one feature at a time, and let the MCP server maintain state between steps.
Mistake 2: copying decompiled code as-is
It's the fastest way to infringe copyright and inherit unreadable, unmaintainable, and potentially hole-ridden code. Solution: use the "recreate" loop — understand the logic, reimplement it in your stack with your own conventions and tests.
Mistake 3: skimping on the host model
Reverse engineering is a hard agentic task; a mediocre model drifts and fabricates plausible but false conclusions. Solution: reserve complex targets for models at the top of the agentic leaderboard, and keep fast models for simple tracing.
Mistake 4: believing obfuscation still protects you
The Reddit field feedback is unequivocal: 10 minutes for a packaged Electron app. Solution: treat the client as public code from the design stage onward, and put sensitive logic server-side.
Mistake 5: letting the agent investigate unsupervised
14 guided workflows don't replace human judgment, especially on third-party targets. Solution: validate each step, demand evidence — REA shows it — and document conclusions before acting on them.
❓ Frequently Asked Questions
Is REA free?
Yes: the project is open source, available as a CLI and MCP server. You only pay for the host model's tokens, and investigation sessions on large targets consume a lot of context. Plan for a substantial token budget for a serious audit.
Which coding agents are compatible?
12 major agents via MCP: Claude Code, Cursor, Codex, Gemini CLI, Windsurf, Devin, GitHub Copilot CLI, and others. If your agent speaks MCP, it can drive REA's 41 binary inspection tools and 14 guided investigation workflows.
Is it legal to decompile commercial software?
It depends on the jurisdiction and the use. The EU allows decompilation for interoperability (directive 2009/24/EC); terms of service often prohibit it; copying decompiled code violates copyright everywhere. Consult a lawyer for any professional use.
Does REA replace Ghidra or IDA Pro?
No, it orchestrates them. REA drives Ghidra headless, radare2, frida, and others via MCP, and has supported IDA Pro as an analysis backend since v4.1. Professionals keep their tools; REA adds the agentic layer that chains the steps together.
Which model should I choose to drive REA?
The models at the top of the agentic leaderboard: GPT-5.5 (98.2), Gemini 3 Pro Deep Think (95.4), and Claude Opus 4.7 (94.3). For simple targets, a mid-tier model like Claude Sonnet 4.6 (81.4) is enough and costs significantly less in tokens.
How can I protect my Electron app against this type of tool?
Preventing decompilation is impossible; you can only reduce the impact surface. Move sensitive logic server-side, don't store anything critical in the client, and monitor your API endpoints — that's the path REA's inspection takes.
✅ Conclusion
In 48 hours, REA went from unknown repo to number one on GitHub trending — and made reverse engineering as accessible as a chat session. Try it on a closed dependency you've been stuck with for months, and choose the right host agent from our selection of the best AI tools for code.