REA: The Open-Source Tool That Lets AI Agents Reverse Engineer Any Program

When Closed Source Is No Longer a Moat

An open-source repository called REA (Reverse Engineer Anything) is climbing GitHub at a remarkable pace — according to veteran developer Rob Shocks (Switch Dimension channel), the project racked up roughly 7,000 to 8,000 stars in a single day, and it keeps growing. What it does sounds almost subversive: let your coding agent (whether that's Claude Code, Cursor, or Codex) peek inside an application you have no source code for, figure out how a particular feature works, produce evidence, and then help you build your own version.

People have already used it to study games, analyze software, and even crack desktop applications that have been locked down for twenty years. Rob, a software developer and product manager with 20 years of experience, wanted to clarify two things in his video: what REA actually does (because most of the discussion he'd seen missed the point), and why it matters to everyone who ships software.

What REA Actually Does

The core idea behind REA is simple: you see a feature in some application you want, and you just ask your agent to investigate it — no original source code required. Under the hood it's an MCP server plus a CLI that plugs cleanly into any tool supporting the MCP protocol, which these days covers a very wide range.

The key detail is that it handles more than Electron apps, where partial source was always somewhat accessible. REA works with genuinely native applications: native binaries on Mac, Windows, and Linux, plus .NET assemblies, Android APKs, firmware, websites, and even smart contract bytecode. That covers most of the desktop software you use every day.

Here's where a lot of people get confused: it doesn't spit out raw source code. Once an application is compiled, the original source is gone — no tool can fully restore it. What REA gives you is pseudocode, assembly, module maps, call paths, and network activity, with every finding backed by evidence: where it came from, how confident the model is, and what it couldn't figure out. That level of transparency used to cost serious money and serious time.

MCP (Model Context Protocol) is an open standard released by Anthropic in late 2024, designed to give AI assistants a unified way to connect with external tools and data sources. Think of it as the USB port of the AI world — tool developers implement an MCP server once, and every client that supports the protocol (Claude, Cursor, Cline, etc.) can call it directly without per-platform adaptation. REA ships as an MCP server, meaning it can be dropped into any AI coding environment that already integrates MCP with almost zero extra configuration. This plug-and-play characteristic dramatically lowers the barrier to assembling a reverse-engineering toolchain, and it's a big reason REA spread so quickly.

It's Not Magic — It Just Removes Friction

Rob is careful to point out that REA is not a decompiler and contains no revolutionary black magic. The real work is still handled by the hardcore tools that reverse engineers have relied on for years — tools like Ghidra, the free framework released by the NSA. In other words, these reverse-engineering operations were always possible; they just required enough time and money.

What REA does is eliminate the friction. These professional tools are powerful but famously hard to learn. REA gives your agent dozens of plain-text tools — things like "open this binary," "find strings," "trace function calls" — so the agent can work its way through a codebase on its own.

Setup is trivial: a single npx rea-agent setup command does it. It shows you a plan of what it's about to change, backs up your config, adds the MCP server and a skill that teaches the agent how to run an investigation, and asks for your approval before touching anything critical.

Ghidra is a reverse-engineering framework developed by the NSA and publicly released in 2019. It's widely regarded as a powerful open-source alternative to the commercial tool IDA Pro. It supports disassembly and decompilation of binaries targeting x86, ARM, MIPS, and many other architectures, converting machine code into pseudo-C and providing function call graphs, data-flow analysis, and other advanced features. Despite its power, Ghidra's learning curve is steep — mastering it typically takes months of dedicated study, and reverse engineering itself demands deep familiarity with assembly language and OS internals, keeping the skill set confined to a small community of professional security researchers. REA wraps a natural-language interface around Ghidra, letting an AI agent drive complex operations with simple text commands, effectively erasing that professional barrier.

Live Test: Cracking His Own Locked App

To run a fair test — rather than a "trust me, it works" demo — Rob built his own application instead of risking legal trouble by targeting commercial software.

The app is called Vault. Enter the right unlock code and you get in; inside are a validation rule and a hidden message that only appears on a correct entry. Crucially, he built it the way real applications are shipped: optimized, with all function names stripped, so check unlock code became an anonymous function at some memory address. Then he "threw away the key" and sealed the source code away.

After the agent opened the binary with Ghidra, it got back 242-plus functions, every one named something like fun plus an address. Within just a few calls, though, it located the function that actually mattered and reconstructed the code into something resembling C. It then wrote a small generator that produced the code AGNT-1001, and Rob walked right in.

Rob kept hammering this point: the agent did not copy the code. It understood the logic and wrote something entirely new — a validation-code generator that didn't even exist in the original app. That's the essence of reverse engineering.

What This Means for the Software Industry

For years, software has enjoyed a quiet, unspoken form of protection. Reverse engineering was always legal and always possible — it was just slow, specialized, and expensive, so almost nobody bothered. That friction was the protection, and REA removes it.

Rob doesn't buy the doomsday narrative he's seen online about planes falling out of the sky. Breaking genuinely critical systems still involves serious obstacles. But he offers a practical warning: if you ship a desktop application, a browser extension, a game, a mobile app, or a large chunk of client-side JavaScript, you should now assume anyone's agent can figure out how it works. He even predicts some interesting GTA 6 mods in the coming months.

In his view this isn't a disaster — it's a correction. Code was never really a moat, at least not for most people. Your actual competitive advantages are your data, your users, your cloud-side security, your shipping velocity, your taste, and everything running on your servers that nobody can see.

There's a security upside too: you can point REA at applications already on your machine and ask, "What exactly is this thing doing? What is it sending out?" Real-world cases already exist of 3D printers and even coffee machines being compromised and quietly exfiltrating large amounts of data to unknown destinations.

Three Things You Must Know Before Using It

Rob lays out three critical caveats:

Legal considerations. He's not a lawyer and this isn't legal advice. That said, reverse engineering for interoperability is generally protected; however, many applications' terms of service explicitly prohibit it, and bypassing DRM or encryption is an entirely separate legal question. The safe territory: your own apps, open-source binaries, security challenges, and targets you're authorized to test. REA's own disclaimer makes it clear — responsibility is yours.

It's not sandboxed. If you run the target program for runtime capture, it executes with your permissions. Don't point it at random binaries downloaded from a forum, and keep the agent's approval prompts enabled, because nobody knows what kind of prompt injection might be hiding inside. Rob strongly recommends running it in a sandbox.

The project moves fast. This repository changes constantly, full of breaking updates and high energy — expect it to keep evolving, and stay current.

Prompt injection is a class of security attack targeting AI agents: an attacker embeds instruction-like text inside external content the model will process — documents, web pages, code comments, or even strings inside a binary — in an attempt to hijack the agent's behavior, such as leaking a system prompt, executing unauthorized commands, or bypassing safety limits. In REA's use case, a maliciously crafted binary could hide such instructions in its string table or symbol names; when the agent scans and reads that content, it may be manipulated. This is precisely why Rob repeatedly warns against targeting unknown binaries and recommends running everything in a sandbox — a sandbox constrains the resources the agent can access, so even if prompt injection occurs, the actual damage an attacker can cause is dramatically limited.

Smart Ways to Use It

As a software engineer, Rob sees REA's genuine value in scenarios like: studying how great desktop applications handle offline state, sync, clipboard access, and search, then building your own version; auditing the large number of Electron apps sitting on your machine; and recovering logic from old projects where you've lost the source code.

What he explicitly won't do is point the tool at a competitor and clone the product — that's legally high-risk and entirely misses the point. The right move is to understand the ideas and build something better, because you'll never out-market the company that made it. In today's world, everything comes down to distribution.