
Reverse Engineering Anything: How AI Agents Turned a Specialist Discipline Into a One-Line Install
The short answer: REA ("Reverse Engineer Anything") is an open-source toolkit that plugs AI coding agents such as Claude Code and Codex into Ghidra, IDA, Hopper and browser DevTools through MCP and the Agent Skills format. It has spawned ~400 derivatives covering websites, apps, video and firmware. The shift: reverse engineering is now a downloadable dependency, not a decade-long discipline.
By the numbers (verified 14 November 2026)
| Metric | Value | Source |
|---|---|---|
Stars on morluto/rea | 459,130 | GitHub API, 14 Nov 2026 |
| Forks | 112,554 (24.5% of stars) | GitHub API |
| First commit → today | 214 days (created 14 Apr 2026) | GitHub API |
| Average star velocity | ~2,145 stars/day | Calculated |
| Repos matching the phrase "reverse engineer anything" | 427 | GitHub search API |
| …of those, created on or after 1 July 2026 | 399 (93%) | GitHub search API |
| Repos matching "reverse engineering" + agent/skill | 574 | GitHub search API |
| Peak press-era growth (16→20 Oct) | 285,000 → 342,000 stars (+57,000 in 4 days) | ExoBrain; AI Weekly |
| Hacker News launch thread | 814 points, 340 comments | HN item 50028275 |
That growth curve is the story. In the first half of 2026, four repositories used the phrase. Since July, roughly four hundred have. A naming convention that did not exist in January is now a genre.
What actually happened: capability became a package
Reverse engineering has never been illegal, and it has never been easy. For thirty years the constraint was human: you needed someone who could read assembly, recognise a compiler's idioms, and sit with a debugger for a week. That constraint was the moat — for vendors protecting trade secrets, and for the small priesthood of analysts who could do the work.
Two things broke it in 2026.
1. The economic argument collapsed. Simon Willison named it in July 2026: the barrier was never feasibility, it was ROI. Reversing a device protocol was possible — it just wasn't worth the maintenance burden when the API might change. Coding agents destroyed that calculation from both ends. As he put it, "the effort to get a simple automation working has dropped, as has the cost of trying and failing." When a failed attempt costs twenty minutes instead of a fortnight, you stop asking whether it's worth trying.
The academic framing is sharper still. An October 2026 paper by Mandel, Choksi, Castillo, Benthall and Grimmelmann — Cheap Reverse Engineering and What It Will Do — argues that IP law has been quietly resting on a false premise:
"Existing IP and technology laws assume that RE is expensive and time-consuming, and that it requires specialized expertise. They generally allow it, but they rely on its difficulty as a filter to separate (permissible) RE from (impermissible) copying and theft."
Remove the filter and the legal settlement stops being a settlement. The paper notes agents are "cheap (often $20 per month or less), lawful to distribute, and easy for novices to use."
2. The distribution format changed. This is the part most commentary misses. Even in early 2026, an LLM that could read assembly was a chat window you had to prompt cleverly. REA's contribution was packaging: a local MCP server that registers tools with your agent, plus a SKILL.md that teaches the agent how an investigator works — form a hypothesis, pick the probe, read the evidence, revise.
That means the capability now ships like any other package:
npx rea-agents setup # registers REA's MCP server with your agent
npx skills add morluto/rea # or install just the investigation skill
This is the actual inflection. Reverse engineering went from a discipline to a dependency — the same shift that happened to PDF parsing or image resizing a decade earlier. And dependencies spread at the speed of npm install, not the speed of mentorship.
How the stack is wired
Four layers, and knowing them is what separates a useful install from a broken one.
| Layer | What it is | Examples |
|---|---|---|
| 1. Harness | The agent that reasons and calls tools | Claude Code, Codex, Cursor, Gemini CLI, OpenCode |
| 2. Interface | How the agent reaches the target | MCP server (tools) or Agent Skill (instructions + CLI) |
| 3. Engine | The actual analysis muscle | Ghidra, IDA Pro, Hopper, radare2, Frida, CDP, ffmpeg |
| 4. Artifact | Where findings land, in a format the agent can re-read | Pseudocode + evidence, VIDEO.md, HAR, typed API client |
Two design patterns dominate:
- MCP-first (REA, jshookmcp, Ghidra MCP bridges): the server exposes hundreds of typed tools. The agent queries disassemblers, pulls cross-references, decompiles functions, and iterates. REA's own framing is that it "returns findings with their evidence" — the agent gets provenance, not just an answer, which is what stops it hallucinating a plausible function.
- Skill-first (most of the 400 derivatives): a markdown file plus shell access. Cheaper, more portable, no server to keep alive — and critically, no MCP registration to debug.
leanreais the reductio: a single ~8 KB skill that replaces the whole stack with plain CLI calls (its author claims 38% faster runs; self-reported, treat accordingly).
The skill-first pattern explains the explosion. Writing a SKILL.md takes an afternoon. Writing an MCP server takes a week. When the marginal cost of publishing a capability drops to one afternoon, you get four hundred of them in a quarter.
The 10 most-starred agent reverse-engineering repos
Ranked by GitHub stars, verified 14 November 2026. Two are REA derivatives and are labelled as such — that's the point of the ecosystem, not a flaw in the list.
| # | Repository | Stars | Type | Target |
|---|---|---|---|---|
| 1 | morluto/rea | 459,130 | MCP + skill | Binaries, desktop apps, Electron, firmware, model artifacts |
| 2 | zhaoxuya520/reverse-skill | 44,641 | Skill router pack | Routes to RE / pentest toolchains on demand |
| 3 | rehan-remade/universal-modder | 9,681 | Skills + MCP | PC games: recon, RE, asset generation, in-game testing |
| 4 | SimoneAvogadro/android-reverse-engineering-skill | 8,723 | Skill | Android APK/AAB/DEX |
| 5 | JuneYaooo/rea-video | 8,388 | Skill + CLI | Video, shot by shot → VIDEO.md |
| 6 | Integuru-AI/Integuru | 4,799 | Agent (precursor) | Website internal APIs → integration code |
| 7 | taicodeking/leanrea | 4,274 | Skill (REA derivative) | Minimal CLI-only alternative to REA |
| 8 | JoasASantos/REA-Prompts | 4,060 | Prompt pack (REA derivative) | Prompt patterns for REA investigations |
| 9 | ljagiello/ctf-skills | 3,707 | Skill collection | CTF: web, pwn, crypto, RE, forensics, OSINT |
| 10 | kalil0321/reverse-api-engineer | 3,600 | CLI + skill | Website → typed API client in 10 languages |
What each one is actually for:
1. REA — the anchor. One MCP server spanning native binaries, Electron/JS, .NET, Go, Rust, CUDA kernels, GGUF model files, Unity IL2CPP metadata and Godot PCKs. It does not claim to recover source code; it returns pseudocode, assembly, strings, symbols and call references so your agent can explain a behaviour and help you rebuild it. MIT licensed, runs locally.
2. reverse-skill — the router. A Chinese-language-origin pack that does something smarter than bundling tools: it routes. Ask a question, and it decides whether you need a Frida hook, a jadx decompile or a Burp session, then bootstraps only that toolchain. It keeps a self-evolving knowledge file so repeat investigations get cheaper. 44k stars on a router is the clearest evidence that tool selection, not tool capability, is the bottleneck.
3. universal-modder — the workflow. Not just analysis: the agent identifies the engine, reads the code, writes the mod, generates art/3D/audio through fal, launches the game to test, cuts a showcase video, and writes field notes into a shared knowledge/ index for the next agent. This is the closest thing to a self-improving RE loop in the wild.
4. Android skill — the sleeper. 8,723 stars on a skill most Western coverage ignores. It decompiles APK/XAPK/AAB/DEX, maps AndroidManifest, and pulls HTTP endpoints — the fastest route from "this app does something interesting" to "here is the undocumented endpoint behind it." Apache-2.0.
5. rea-video — the format innovation. Give it an MP4 and it returns a per-shot verdict: filmed, AI-generated, avatar, 3D render, or code. It uses ffmpeg keyframes, shot detection, subtitle extraction and optional VLM calls (Gemini or Doubao), then emits two artifacts: a human-readable report.html/PDF and a machine-readable VIDEO.md in an open spec. The reply is a remake brief — camera setups, lighting, the reverse-engineered generation prompt per shot, BPM of the music, where each SFX lands. 8,388 stars in sixteen days.
6. Integuru — the ancestor. Shipped October 2024, long before "agent skills" was a phrase. Give it a HAR file, cookies and a description of the action; it identifies which request does the thing, maps the dependency chain between requests, and outputs runnable Python hitting the internal endpoints. Every "reverse engineer any website" repo since is a descendant of this idea — including the fact that the author later commercialised it.
7–8. leanrea and REA-Prompts — the derivative layer. One argues REA is overbuilt and ships an 8 KB skill instead; the other ships prompts. Both exist because the anchor's README is 33 KB and its skill is 43 KB. When a tool gets that big, a market for "the small version" and "the cheat sheet" appears within weeks. That is a healthy ecosystem signal — and a supply-chain risk, discussed below.
9. ctf-skills — the benchmark. CTF is where reverse engineering has objective answers, so it is where agent skills get stress-tested. This pack covers web exploitation, binary pwn, crypto, RE, forensics and OSINT, with a scripted toolchain installer per language/package manager. If you want to know whether an RE skill actually works, run it against a CTF, not a demo GIF.
10. reverse-api-engineer — the business case. Browse a site (or let the agent browse), capture traffic to HAR, and get a clean typed client in Python, JavaScript, TypeScript, Go, Java, C#, PHP, Ruby, C or PowerShell. This is the single most commercially load-bearing repo on the list, because it converts "a website a human must click" into "an interface an agent can call" — which is exactly what every automation project in 2026 needs.
Also worth your time (the watchlist): angusdevgo/Seep-Reverse-Lab (2,171 — agent-native workbench focused on CWE-602 client-side authorization audits), vmoranv/jshookmcp (2,114 — 735 tools across 36 domains for JavaScript deobfuscation and anti-bot work), miscusi-peek/cheatengine-mcp-bridge (1,803 — Cheat Engine over MCP), cellebrite-labs/ghidra-rpc (400 — Ghidra as an agentic skill, from a forensics vendor), and alexgaoth/awesome-reverse-engineered (1,401 — a searchable index of 17,000+ projects already built by reverse engineering something else).
Seven practical use cases (with what actually gets built)
1. Recovering business logic from a legacy binary
The most valuable and least discussed application. A company runs a 15-year-old desktop or AS/400-era system whose source is gone, whose original developer is gone, and whose behaviour is the business process. The agent traces the code path, returns pseudocode with evidence, and drafts a modern implementation you can test against the original.
REA's own published showcase is the proof of rigour here: reconstructing the sound-panning calculation in DX-Ball and validating the rebuilt C against 3,205 original x86 test cases, reproducing all 63 compiled function bytes. That is not a vibe; that is byte-level equivalence checking. For an ERP migration — where a rounding rule in a 20-year-old invoicing routine is a legal liability — this is the pattern that matters: recover, then prove equivalence against the original, don't just trust the summary.
2. De-bloating hardware you already own
The viral use case. A user gave Claude Code a TV model number; the agent found the device on the network, identified 25 Xiaomi packages, removed them and wrote a new launcher. 404 Media reported the post drew a claimed six million-plus views, alongside AI-written firmware stripping ads from baby monitors and reviving bricked Lululemon mirrors. Legally this sits on the firmest ground in the whole field — it's your device, and the paper above maps it explicitly to the ownership question.
3. Turning a website into an interface for agents
HAR capture → endpoint identification → dependency mapping → typed client. Practical version: a distributor has a supplier portal with no API, and someone re-keys 400 purchase orders a month. reverse-api-engineer turns the portal's own traffic into a client your automation can call. The governance caveat is real — check the ToS, and prefer endpoints your own account is authorised to hit.
4. Competitive teardown without the guesswork
"See a feature you like. Understand how it works, down to the binary level" is REA's own pitch, and it is the honest description of what product teams already do by hand. The Notion showcase walks the clipboard bridge through renderer → preload → IPC → main process to show how rich clipboard formats are handled. The useful discipline: reverse to learn the mechanism, then rebuild your own implementation. Copying the mechanism is fine; copying the artifact is a lawsuit.
5. Video reverse-engineering for content teams
Give an agent a competitor's ad and get back a shot list with per-shot verdicts, a remake brief and paste-ready generation prompts. This is quietly the highest-ROI application for marketing teams — it converts "make something like this" from a vibe into a measurement. rea-video's open VIDEO.md format is the smart part: layered, so an agent reads only the layer a question needs instead of re-ingesting a 40k-token report.
6. Mobile and client-side security audits
The honest security use case, and the one that pays. A skill decompiles the APK, maps the manifest, and hunts for authorisation logic that lives on the client — CWE-602, client-side enforcement of server-side security. Seep-Reverse-Lab is built explicitly around this. Any team shipping a mobile app should assume a competitor's agent will do this to them this quarter; better you find it first.
7. Building RL and evaluation environments
REA documents a workflow that turns a recorded web-app session into tools, then into an AgentEnv bundle with tasks and reward checks. This is how you get training and eval environments for agents operating real-world software — a niche that will matter far more in 2027 than it does today.
The counter-movement: obfuscation gets an AI-native branch
A trend this large generates its opposite within weeks. qybaihe/bla — "Blind LLM Agents" — reached ~5,600 stars with an explicit thesis: poison → exhaust → hallucinate, make reverse engineering bankrupt again.
The Register covered it on 10 November. Creator Timo Zhang's framing is precise about the threat model:
"Coding agents can reverse-engineer shipped packages, CLIs, and WASM in minutes. Classic obfuscation was built for humans and static tools, not LLMs that reason about meaning."
BLA applies renaming, lane splitting, seed-derived string encryption, build polymorphism, decoys, self-seal integrity checks and a coverage matrix — behaviour stays equivalent, recovery cost goes up. Crucially, Zhang does not oversell it: "We raise the cost — we don't claim it is unbreakable," and it explicitly does not stop a human with Ghidra or Frida. Its own CI drives REA against hardened builds and treats "fail to break" as the pass condition.
Read that as a market signal rather than a product review. "Anti-agent hardening" is now a software supply-chain category, sitting next to code signing and SBOMs. If you ship a client-side binary with a paid tier, this is a line item you will be asked about in 2027 procurement reviews.
The risks nobody puts in the demo GIF
Supply chain. REA's README carries an unusual warning for an open-source project: get it from the official repo, the website, or the npm package — "A similar repository name or copied README does not establish that a download is official." Reporting since has noted a lookalike caught serving malware. With 400+ derivative repos and a naming convention that invites clones (there is already a same-description copy of REA sitting at 1,288 stars, pushed the day it was created), assume typosquatting.
Legal. Four overlapping regimes, and they disagree: copyright (interoperability decompilation is permitted in the EU under Article 6 of the Software Directive; in the US, fair use is fact-specific), trade secret, anti-circumvention (§1201), and contract — the EULA you clicked, which usually prohibits exactly this regardless of what copyright allows. Then there is a fifth contract nobody reads: your AI provider's terms. Nothing here is legal advice; the operating rule is that authorisation comes from ownership or written permission, not from technical feasibility.
Security tail. 404 Media's reporting is blunt: poorly coded, barely functional, insecure software is going onto critical hardware. An agent that rewrites your TV firmware can also quietly remove input validation. And when any client-side binary can be unpacked and rebuilt, vendors can no longer assume the software running on a customer's machine is the software they shipped — an anti-cheat that only watches for injected code will not see a rebuilt asset pipeline.
Quality. "Reproduces all 63 compiled function bytes" is an outlier, not a baseline. Most outputs are plausible pseudocode plus a confident explanation. Treat every agent RE result as a hypothesis with a citation, and require a test — the DX-Ball case passes because someone wrote 3,205 of them.
A practical playbook: your first investigation in 20 minutes
- Pick a target you own or are authorised to analyse. Start with an app you built, or an open-source binary. Do not start with a vendor whose EULA you have not read.
- Install the interface, not the whole ecosystem.
npx rea-agents setupfor MCP, ornpx skills add <owner>/<repo>for a skill. If the skill installs but tools are missing, that is expected — instruction files do not register MCP servers. - Ask a falsifiable question, not "how does this work." Good: "In this Electron app, trace how the clipboard writes rich text, and show me the IPC channel names." Bad: "analyse this app."
- Demand evidence. Ask for the function, the address, the call chain, the file. If the agent can't produce a citation, you have a story, not a finding.
- Write the test before you trust the rewrite. Pick 20–50 known input/output pairs from the original, run the reconstruction against them, and require equivalence. This single step separates engineering from entertainment.
What this means if you run enterprise systems
Three implications, in order of urgency.
Your undocumented systems just became recoverable assets. Every organisation has a spreadsheet-adjacent black box — a custom pricing engine, a legacy billing routine, a warehouse allocation script that only one retired person understood. Historically the choice was "keep paying to run it" or "rewrite and hope." There is now a third path: have an agent reconstruct the logic with evidence, then rebuild against equivalence tests. Budget for the tests, not the extraction.
Your IP moat just moved. If your differentiation lives in client-side code, in an undocumented internal API, or in "nobody else can replicate this workflow," assume it is replicable this year. The durable moats are data you own exclusively, service quality, integration depth, and distribution — not compiled logic. Compete on the things a npx command cannot download.
Your AI governance policy is now incomplete. Most enterprise AI policies cover data leakage. Few cover "an employee pointing a coding agent at a competitor's binary," or "a developer installing a 1,288-star lookalike repo." Add two lines: which reverse-engineering activities are authorised and by whom; and an allowlist process for MCP servers and skills, with provenance checks before install.
Sources
morluto/rearepository, GitHub API metadata and README, retrieved 14 November 2026 — https://github.com/morluto/rea- Losio, R. "Reverse Engineer Anything Project Brings AI Agents to Binary Analysis." InfoQ, 17 October 2026 — https://www.infoq.com/news/2026/10/reverse-engineer-anything/
- Dufresne, A. "'Reverse Engineer Anything' hits 342,000 stars as cloning spreads." AI Weekly, 20 October 2026 (reporting 404 Media / Jason Koebler) — https://aiweekly.co/alerts/reverse-engineer-anything-hits-342000-stars-as-cloning-spreads
- Claburn, T. "To thwart reverse engineering by agents, dev proposes blinding them." The Register, 10 November 2026 — https://www.theregister.com/ai-and-ml/2026/11/10/to-thwart-reverse-engineering-by-agents-dev-proposes-blinding-them/
- Miller, J. "Reverse engineer anything." ExoBrain, 16 October 2026 — https://exobrain.co.uk/insights/reverse-engineer-anything
- Mandel, I., Choksi, M. Z., Castillo, J., Benthall, S., Grimmelmann, J. "Cheap Reverse Engineering and What It Will Do." arXiv:2610.35633, October 2026 — https://arxiv.org/html/2610.35633
- Willison, S. "Reverse-engineering is cheap now." 20 July 2026 — https://simonwillison.net/2026/Jul/20/cheap-reverse-engineering/
- Hacker News discussion, item 50028275, October 2026 — https://news.ycombinator.com/item?id=50028275
JuneYaooo/rea-video,kalil0321/reverse-api-engineer,Integuru-AI/Integuru,zhaoxuya520/reverse-skill,rehan-remade/universal-modder,ljagiello/ctf-skills,qybaihe/blaREADMEs, retrieved 14 November 2026- GitHub Search API queries for repository counts, retrieved 14 November 2026 (counts shift as repos are created and re-indexed)
Star counts and repository counts are point-in-time snapshots from the GitHub API on 14 November 2026 and will drift. Self-reported benchmark claims (e.g. leanrea's speed figures) are labelled as such.
क्या आपको यह अंतर्दृष्टि पसंद आयी?
ये रणनीतियाँ आपके व्यवसाय पर कैसे लागू होती हैं, इस पर चर्चा करने के लिए अपने विचार साझा करें या संपर्क करें।
संपर्क करें


