All posts

What is REA (Reverse Engineer Anything)?

REA is the GitHub repo that lets AI agents reverse engineer software, from app behaviour down to native binaries. Learn what it does, how it works, how to install it, and where the legal line sits.

Manish Poduval18 Oct 20267 min read
Article

What is REA (Reverse Engineer Anything)?

REA stands for Reverse Engineer Anything.

It is an open source tool that lets an AI coding agent look inside software that you did not write, and explain how it works.

Not the source code. The shipped thing. The .exe, the Electron app, the Android APK, the compiled binary.

In simple words: REA gives your AI agent eyes for software that has no source code attached.

Why everyone is talking about it

REA is currently the number one trending repository on GitHub.

The numbers are unusual, even for an AI project:

  • Repository: github.com/morluto/rea
  • Around 370,000 stars and 92,000 forks at the time of writing
  • Created in April 2026
  • Written in TypeScript
  • Licence: MIT for the code REA itself authors

Star counts move fast, so treat that figure as a snapshot and not a fixed fact.

The more interesting part is not the popularity. It is what became popular. REA is not a chatbot and not a model. It is an MCP server plus a skill. That is a signal about where AI engineering is going.

First, what is reverse engineering?

When a developer ships software, they do not ship the source code.

They ship a compiled artifact. The human readable code is turned into machine code, minified JavaScript, or bytecode. It still works, but it is very hard to read.

Reverse engineering is the practice of working backwards from that shipped artifact to understand how it behaves.

People do this for normal, lawful reasons:

  • Understanding a file format so their own app can read it
  • Debugging a crash in a dependency that has no source
  • Checking what data an app sends over the network
  • Preserving old software that nobody maintains any more
  • Security research on software they own or are authorised to test

Traditionally this needed specialist tools and years of practice. REA is an attempt to hand that workflow to an agent.

What REA can actually analyse

This is the part that explains the name.

Target What you point REA at
Native binaries Compiled executables and libraries
JavaScript and Electron apps ASAR archives and JavaScript trees
.NET assemblies Managed artifacts
Android apps APK packages
Websites and runtime behaviour Live browser sessions and network captures
Firmware Firmware images and regions
Packet captures Recorded network traffic
Other formats Go, Rust, WebAssembly, Unity IL2CPP, Godot PCK, SQLite, GGUF and safetensors model files, EVM bytecode, crash cores

So "anything" is not marketing. It is a long routing table.

How REA works

The flow is simple to describe:

  • Your agent calls REA through MCP
  • REA inspects or traces the target on your own machine
  • REA returns code, references, and a list of unknowns
  • Your agent uses that to answer your question, explain the behaviour, or write an implementation

Nothing is uploaded to REA. The analysis is local.

There is also a CLI, so you can run the same workflows yourself without an agent in the loop.

If MCP is new to you, read What is Model Context Protocol? first. REA is a very good example of why MCP exists: one server, many agents, no custom integration per tool.

The part that AI engineers should actually study

Here is the detail most tutorials skip.

REA does not just ship tools. It ships a skill that tells the agent how to investigate properly. And the rules inside that skill are a masterclass in building trustworthy agents.

A few of them:

1. Separate observation, inference, and unknown.

Every conclusion has to say which one it is. Static analysis is never allowed to be described as if the code was actually run.

2. Cite evidence.

Findings carry evidence IDs. The agent keeps a ledger linking each conclusion back to the evidence that supports it.

3. Missing data is not proof of absence.

If a Go binary has no metadata section, that means unknown, not not written in Go.

4. Label guesses as guesses.

Pattern matched results stay marked as inferred.

5. Do not assume which app the user means.

If you say "my app", the skill tells the agent to ask, not to pick an example.

6. Keep unresolved questions visible.

At the end, each question is marked answered, partly answered, or unresolved.

Read those six rules again and notice something: none of them are about reverse engineering.

They are about not hallucinating. An agent that inspects a binary and then confidently invents a function name is worse than useless, because the output looks exactly as credible as a real finding.

This is the same problem we cover in the Foundations course when we look at why models make things up, and the same discipline behind context engineering. REA is one of the clearest production examples of that discipline written down as instructions.

How to install it

Two routes, both via npm.

For your agent:

npx rea-agents setup

Then restart your agent.

Setup supports Claude Code, Codex, Cursor, Gemini CLI, and Grok Build. Any agent that can register a local MCP server can connect manually.

For the command line:

npm install --global rea-agents
rea --help

To update:

rea update

You need a recent Node.js. At the time of writing that means Node 22.23.4 or later on the 22.x line, 24.22.1 or later on 24.x, or 26.12.1 and above.

One more thing worth knowing: deep native analysis needs a disassembler you supply yourself, Ghidra, IDA, Hopper, or a caller supplied objdump or Rizin. REA does not install these for you. Lighter targets like JavaScript apps, APKs and .NET assemblies work without them.

What people are building with it

The common patterns so far:

  • Explaining an undocumented binary or legacy dependency
  • Working out a proprietary file format well enough to read it
  • Tracing what an app actually sends over the network
  • Studying how a feature in a shipped app is implemented, then writing an equivalent of their own
  • Security and malware analysis on samples the researcher is authorised to handle
  • Software preservation, especially for games and abandoned tools

What REA is not

Worth being clear about, because the hype blurs this.

  • It is not a model. It is a tool server. The reasoning still comes from your agent.
  • It is not a decompiler on its own. It routes to and coordinates existing analysis tools.
  • It is not useful on a source repository you already have. Its own skill says to skip REA when ordinary code reading will do.
  • It is not magic. Stripped, obfuscated, or packed binaries are still hard. The honest output in that case is a lot of unknowns.

This matters, so read it properly.

REA's own disclaimer limits it to lawful research, education, interoperability, software preservation, and analysis of software you own or are authorised to examine.

A few practical rules:

  • Reverse engineering is legal in many places for interoperability and research, but the rules differ by country and a licence agreement may restrict it further. Check before you start on something commercial.
  • Commercial tools like IDA Pro, Hopper and JEB need to be legally obtained. REA grants you no licence to them. Cracked copies and licence bypasses are explicitly called out as unauthorised.
  • Runtime capture runs or interacts with the target using your own permissions, on your own machine. Treat it with the same care as running any unknown executable.
  • Download REA only from the official repository. A similar name or a copied README proves nothing, and a tool with this much attention attracts impostors.

"I was curious" is not a legal defence. Understand the terms of the software you are examining.

Why this trend is worth your attention

If you are learning to become an AI engineer, REA is a useful thing to study even if you never reverse engineer a single binary.

It shows three things clearly:

  1. The winning layer right now is tools, not models. REA added capability to every agent at once by speaking MCP.
  2. Skills are the new documentation. A folder of markdown instructions decides whether an agent investigates carefully or confidently guesses.
  3. Evidence discipline is a product feature. The reason people trust REA's output is that it tells you what it does not know.

That third point is the one most people building agents get wrong.

If you want to understand how agents are structured underneath all this, start with Types of AI Agents.

Final thoughts

REA is an MCP server that lets AI agents analyse software they have no source code for, across binaries, apps, firmware and live runtime behaviour.

In simple words:

  • You point it at a shipped artifact
  • It inspects that artifact locally
  • It returns findings, evidence, and an honest list of unknowns
  • Your agent turns that into an explanation or an implementation

The reason it hit the top of GitHub is not that reverse engineering is new. It is that the agent finally has a careful method to follow.

At AI Folks, we teach the practical side of AI engineering: agents, tools, MCP, RAG, context engineering, and how to build systems that are honest about what they do not know.

If you are starting out, our free Foundations course is the fastest way in.

Begin the first module

Become AI native. It is the real deal today, and if it is not for you, you have lost nothing and learnt a new skill.