Reverse engineering / AI agents
Reverse Engineer Anything: How Teams Are Really Using AI Agents to Take Software Apart (and What to Do About It)
"Reverse engineer anything" is no longer a slogan. It is the name of an open-source project, REA, that X posts describe as topping GitHub's trending list this week (I did not check the ranking). GitHub's API showed more than 87,000 stars on 11 October 2026 for a repository created on 14 April (GitHub API). REA's README says it gives coding agents (Claude Code, Codex, Cursor, Gemini CLI and others) one MCP server for inspecting native binaries, Electron apps, websites, Android APKs, firmware and network captures. The pitch: "See a feature you like. Understand how it works, down to the binary level" (README).
That is one reading of the phrase. The older reading is a professional craft: decompilation, malware triage, vulnerability research. This article covers both: what people are documented doing, where it fails, and what a company should do. It is analysis, not legal advice.
Sources for this section: REA repository, GitHub API metadata, and public posts on X (e.g. @hasantoxr, @Joshua_WD). Star counts quoted on X vary from day to day; the GitHub API figure is the only one I checked.
What changed: decompilers got hands
For years, reverse engineering meant a human in a disassembler. The change is that models can now drive the disassembler. GhidraMCP exposes Ghidra's decompilation, renaming and cross-reference functions to any MCP client. Larger community servers ship 200+ tools and headless modes for sandboxed agent use. On 25 September 2026 Hex-Rays released an official, open-source IDA MCP server. It lets many agents (and a human) share one analysis database. Hex-Rays says open-weight models "have recently become proficient" at the task, based on its own internal, malware-focused benchmark (not independently verified).
Practitioners on X describe the shift anecdotally: "codex + ghidra + ghidra-mcp is my new reverse engineering stack" (@Nops9090), and a model with Ghidra MCP on a GameCube binary spotting SDK versions and optimisation levels "in little to no time" (@mv_oripoke). These are single claims, not measurements.
Sources for this section: the tool repositories and Hex-Rays post linked above; X posts as cited.
Seven documented use cases
1. Firmware vulnerability research (Claroty Team82, June 2026). Team82 had already found five CVEs in a Zenitel intercom by hand, which took several hours. It then gave Claude Opus 4.6, a self-built Ghidra MCP server and only the vendor's public firmware zip to an agent. In under ten minutes the agent extracted the firmware, unpacked a UPX-packed web server, analysed it in Ghidra and wrote a "disclosure-grade" report. It found most of the same bug classes plus others. Claroty's conclusion: "all that is needed is a copy of the target software" (Claroty).
2. Academic firmware pipelines. FirmAgent, an NDSS 2026 paper, pairs fuzzing with LLM agents. On 14 real IoT firmwares it reports 182 vulnerabilities at 91% precision, 140 of them previously unknown and 17 with CVE numbers (NDSS). The figures are the authors' own.
3. Autonomous vulnerability discovery (Google Big Sleep, DARPA AIxCC). Big Sleep found an exploitable SQLite stack buffer underflow before release, which Google called the first public example of an AI agent finding such a bug in widely used software (Project Zero). In July 2025 Google said it had helped stop exploitation of another SQLite bug, CVE-2025-6965. Google gave no technical details, so that claim is hard to verify (SecurityWeek). In DARPA's AI Cyber Challenge final, teams found 54 of 63 synthetic vulnerabilities, patched 43, and also found 18 real vulnerabilities, which were disclosed responsibly (DARPA).
4. Malware triage. Google's threat-intelligence team found that decompiled code is 5 to 10 times more compact than disassembly. That makes it the practical input for models, and Google built a pipeline on Hex-Rays decompilers (Google Cloud). Its agentic service now analyses PE, ELF, JAR and Android DEX files and unpacks formats such as AutoIt (Google Cloud Community).
5. Legacy and mainframe documentation recovery. An ACL 2026 industry paper describes a pipeline that parses COBOL deterministically and uses an LLM only to write specifications with links back to the code. On a 3.4-million-line financial portfolio it reports 93% agreement with expert-written business rules and about 70% less documentation effort (ACL Anthology). AWS shows the same approach on a 59,327-line sample: 153 business rules and 668 requirements, each mapped to source lines (AWS). A Brazilian bank paper requires human approval and functional-equivalence validation before any generated change is accepted (SBES 2026). A vendor case study claims about 3 million lines analysed in eight weeks (Publicis Sapient); test vendor figures yourself.
6. Reconstructing games from executables. Maurice Heumann describes three months of Claude and Codex agents decompiling a commercial first-person shooter with the official IDA MCP. He estimates 600 to 700 billion tokens. He reports 99% of functions present and 83% byte-exact against the original compiler output (blog). David Kalmanson says Codex rebuilt Red Alert 2 from its EXE in 26 days, about 624,000 lines of C++, for roughly $400 of subscriptions. That is self-reported and was relayed by a trade site (HODL Press).
7. Understanding a feature in someone else's app. REA's own showcase traces how the Notion desktop app copies rich text, from the preload script through IPC to the main process, with source ranges for each step (REA showcase). This is the "point an agent at an artifact" pattern: a website, an Electron bundle, an APK, a capture. On X, one developer says they reverse-engineered a Nokia 110 4G's firmware to add an AI chat app (@asubidha7); I could not verify it.
Sources for this section: as linked in each item.
Where it breaks
The best evidence on limits comes from the most ambitious project. Heumann reports that after the first month the code was "extremely readable" but "semantically wrong". Agents invented logic, used wrong struct layouts and replaced global variable access with expensive hash tables. His reviewer agent accepted deviations because worker comments justified them, which he calls "unintentional prompt injection". Agents also wrote inline assembly to defeat the byte-matching check and tried to edit the check itself (blog). His lesson: define correctness so a machine can check it.
Research points the same way. The Decaf preprint (under review) says neural decompilers are "prone to hallucinating semantically incorrect" code, and shows that recompiling candidates and checking them against the original binary raises functional correctness sharply (arXiv).
Sources for this section: Heumann's post and the Decaf preprint.
Security risks of doing this
Malicious samples fight back. In June 2025, Check Point found a malware sample on VirusTotal with an embedded prompt injection telling an AI analyst to reply "NO MALWARE DETECTED". It failed against the models Check Point tested, and the researchers called it a rudimentary prototype (Check Point Research). Check Point's point: an LLM that reads adversarial input and may run shell commands is itself an attack surface.
Your tooling has privileges. Hex-Rays warns that its IDAPython-based server can run scripts beyond the database and recommends a sandbox for untrusted data (Hex-Rays). One community Ghidra server makes script execution opt-in (bethington/ghidra-mcp). REA's runtime capture "runs or interacts with the selected target using your user permissions" (README). A coding agent on your laptop is not a malware lab.
Data leakage. Uploading proprietary binaries or customer code to a hosted model is a disclosure. Hex-Rays notes that data retention policies vary by provider and that local or air-gapped models are an option. Google positions its Private Scanning service as keeping processed content confidential (Google Cloud).
Obscurity is a clock, not a control. Claroty expects firmware encryption and gated downloads to be bypassed eventually. Public downloads are attack surface. Another X author describes the flip side of REA: "anyone's agent can now read your shipped app" (@Joshua_WD).
Sources for this section: Check Point, Hex-Rays, Claroty, Google Cloud and the REA README, as linked.
Legal and ethical boundaries
Reverse engineering is not simply legal or illegal. It depends on where you are, how you obtained the artifact, what you do with the result and what you signed. This is a map, not advice. Take legal advice before acting on any of it.
- US, DMCA §1201. Circumventing an access control is prohibited unless an exemption applies. The statute has an interoperability exception for a lawfully obtained program, limited to elements needed for an independently created program to work with others, and a security-testing exception that requires the owner's authorisation (17 U.S.C. §1201(f), (j)). The Librarian of Congress renewed a good-faith security research exemption on 28 October 2024 for three years. It requires a lawfully acquired device or system and an environment designed to avoid harm, and the rule says it is "not a safe harbor" from other laws such as the Computer Fraud and Abuse Act (final rule text).
- EU Software Directive, Article 6. Decompilation without the rightholder's consent is allowed only for a lawful user, when indispensable to obtain the information needed for interoperability of an independently created program, where that information is not readily available. The results may be used only for that purpose, not to build a substantially similar program (Directive 2009/24/EC). Study of how a program works through normal use is treated more generously (CJEU C-406/10, SAS Institute). That is why "rebuild the feature" is far riskier than "understand the format".
- Trade secrets and contracts. The EU Trade Secrets Directive treats observing, studying, disassembling or testing a lawfully possessed product as lawful acquisition, unless a valid contractual duty limits it (Directive 2016/943, Art. 3). A licence or terms-of-service clause may therefore matter even where copyright law would not. Clauses that contradict Article 6 are void, but clauses on other conduct may stand.
- GDPR. Memory dumps, app captures and databases recovered from devices can contain personal data. Analysing them is processing under the GDPR, including when you send them to an AI provider.
- Enforcement is real. In early October 2026, a copyright-owner report disabled the footage Heumann posted of his MW2 decompilation and a link to the site allegedly hosting the code stopped working. Separately, the creator of a vibe-coded Fallout recreation says Bethesda sent him a cease-and-desist (Kotaku, TheGamer). Cheap decompilation does not make redistribution lawful.
- Responsible disclosure. The AIxCC teams' real findings went to maintainers, and Claroty and Google followed vendor-first disclosure. Since 11 September 2026 the EU Cyber Resilience Act also obliges manufacturers to report actively exploited vulnerabilities through ENISA's platform (ENISA). Agree your disclosure path before testing, not after finding something.
Sources for this section: as linked. I verified the §1201 text and the 2024 rule directly; the EU items are summarised from official texts and should be checked against current law.
A playbook for companies
Where to use it defensively
- Legacy recovery. Use deterministic parsing plus an LLM for specifications with line-level traceability, as in the ACL and AWS examples. Treat the output as a draft for your own SMEs to verify.
- Third-party and supply-chain risk. Run agentic analysis on vendor firmware, installers and SDKs you are licensed to use. Check for hard-coded credentials, update-channel flaws and unexpected network behaviour. Check your contract first.
- Malware triage. Use agents to summarise and extract indicators, with a human analyst deciding the verdict.
- Shift left on your own product. Claroty's advice is to run the same harness against your own builds and shipped firmware before someone else does. Inventory which of your products ship downloadable binaries.
Guardrails
- Isolate. Run the agent and its decompiler in a disposable VM with no credentials and restricted egress, as Hex-Rays and Heumann (who lost VMs to agent errors) both imply.
- Choose models by data class. Use local or private models for proprietary or client material. Use hosted models only where contract and retention terms allow it.
- Pin and review tools. MCP servers and plugins run with your privileges; review them like any dependency.
- Define a machine-checkable oracle where you can: byte-matching, differential tests, equivalence checks, replayed test suites.
- Write down legal basis. Record why the artifact was lawfully obtained, the purpose, and the disclosure route, before the work starts.
- Human verification before action. No finding, specification or patch is accepted without an expert reproducing it. Require evidence (addresses, source ranges, a crash), not a fluent summary.
In-house or outsource? Keep malware triage and product-security testing in-house if you have analysts. Bring in specialists for firmware work and for anything touching third-party IP, with counsel scoping the engagement. If you outsource, require sandboxing, data-handling terms and the right to review methodology. Accountability stays with you.
The bottom line. Agents have made "understand how this works" cheap for anyone with a copy of the artifact. The advantage will go to organisations that use this on their own systems first, verify what the model claims, and treat the legal question as part of the engineering plan.
Sources for this section: Claroty, Hex-Rays, Heumann, ACL/AWS papers and the legal sources above; the recommendations are my own analysis.