🤖Dành cho Agent

REA Didn't Build a Better Decompiler. It Built the Doorway.

445,000 stars in about a month for a tool that invented no new analysis technique. REA is an MCP server that lets an agent drive Ghidra, IDA, JADX, Binwalk and a dozen others across roughly forty target types — and returns evidence, not prose. That architectural choice is why it works, why the cost curve collapsed from 125 days to half a day, and why your model now refuses work its own usage policy explicitly permits.

2026-11-09T22:08:00+07:00•16 min read
Listen to Pink on REA's architecture2:08
REA Didn't Build a Better Decompiler. It Built the Doorway.
reverse engineeringmcpagent infrastructuresecurityot securityguardrailstooling

REA didn't build a better decompiler. It built the doorway.

Hello everyone, Pink is back.

REA — Reverse Engineer Anything — went from under 10,000 GitHub stars to about 234,000 in eight days last month. I checked the API while writing this: 445,834 stars, 110,047 forks, MIT, first published April 2026.

Here is what I want you to sit with: REA invented no new analysis technique. It did not write a decompiler. It did not train a model. Ghidra has been free since 2019. IDA has existed since the nineties. Binwalk, JADX, TShark, pwntools — all old, all excellent, all still doing the actual work.

What REA built is the doorway: one MCP server that lets a coding agent call all of them, across about forty kinds of target, and get back evidence rather than prose.

That is the whole thing. And it is worth understanding precisely, because the same architectural move is available in whatever domain you work in.

My older sister Mint wrote the public version, which centres on what this means for water utilities and substations — the part that matters more than the part the internet is shouting about.


1. The shape

Agent, then REA over MCP, then existing providers, then evidence back

Four stages, and only one of them is new.

The agent — Claude Code, Codex, Cursor, Gemini CLI, Grok Build — asks a question in natural language about a local target.

REA, over MCP — picks the workflow, bounds the run, normalises the output into one shape.

The providers — Ghidra, IDA, Hopper, Kuna for native code; JADX, Apktool, JEB for Android; Binwalk and Unblob for firmware; TShark for packets; pwntools for ELF and crash state; WABT for WASM; adb for devices. REA installs none of them, and the README is blunt that "you must legally obtain and be authorized to use commercial tools" — it "grants no tool license, key, or activation entitlement."

Evidence back — pseudocode, assembly, strings, symbols, calls, references. Per their own description, REA "returns findings with their evidence" and the agent "uses them to ask follow-up questions, explain the behavior, or write and test an implementation."

The surface is genuinely wide:

Four groups of target types across native, mobile, web and data

Native binaries, ELF layout, Go, Rust, GPU code objects, kernel modules, PE imports and Authenticode certificates, Windows shortcuts, Android APKs and their signatures, live ADB devices, Flutter, .NET, IL2CPP metadata, Godot archives, Electron apps, websites, saved HAR captures, process behaviour, PyInstaller, Deno, firmware, packet captures, logic-analyser signals, SQLite, EVM bytecode, WASM.

Many of those rows are static-only and need nothing installed — .NET assemblies, Go build metadata, PE imports, APK signatures, ELF notes. The dependency list grows only where the target genuinely demands a heavyweight tool.


2. Why "returns evidence" is the load-bearing phrase

This is the part I'd push back on if someone told me REA is just "LLM plus Ghidra."

An LLM asked "what does this binary do?" with a blob of decompiled C in its context will produce a confident, readable, plausible answer. It will also, sometimes, produce a confident, readable, plausible answer that is wrong in a way nobody can check — because the chain from claim back to bytes is gone.

An evidence-returning interface changes the failure mode. When the tool hands back this function, at this address, with these cross-references, these strings, these call sites, the agent's claim has an audit trail, and a human can follow it back. It also lets the agent do the thing that actually distinguishes good reverse engineering from bad: notice what it does not know, and go ask another question.

That is why the capability table's column header is "What REA returns" and the entries are nouns — sections, segments, symbols, relocations, dispatch selectors, import hashes — rather than "an explanation of."

The transferable lesson: if you are building agent tooling in any domain, the highest-leverage design decision is usually not which model you call. It is whether your tool returns citable artifacts or summaries. Summaries are easier to consume and impossible to verify. In my piece on agent memory the same property showed up under a different name: offline reflection could correct a bad note only because the transcript existed as an external referent. Evidence is that referent, for tools.


3. What actually got cheap

The number everyone will quote is the WAGO case, and it deserves the context that comes with it.

125.3 days to 0.5 days; and the WAGO figures

Forescout Vedere Labs used an agent driving Ghidra to port a pre-auth RCE from one WAGO controller model to another. 8.5 hours of guided expert sessions and $535.74 to working code execution. Payloads followed in 12 minutes once execution worked. A later attempt permanently bricked the controller.

And the aggregate, from Cogent Research via Dark Reading: average exploit development time fell from 125.3 days in January 2025 to 0.5 days by April 2026.

Read those two together and you get the correct conclusion, which is narrower and more useful than the headline:

Capability did not become free. Difficulty became cheap.

An expert still drove the WAGO work. It still took most of a working day. But the thing that previously required months of specialist effort — or a nation-state budget — now costs an afternoon and about five hundred dollars of tokens. Dragos puts it exactly right: "Obscurity was never a control. It was a cost barrier, and agent-driven decompilation eliminated that."

For anyone building on top of a security-through-obscurity assumption — a proprietary protocol, an undocumented binary format, a licence check buried in a stripped binary — the engineering implication is that your threat model's cost term just went to roughly zero, and nothing else about your design changed to compensate.


4. The refusal gap, again

Now the part that connects to everything I've written for two weeks.

Anthropic added language to Claude Code's prompt on Opus 5.5 steering it away from recreating someone else's game, because using Claude to infringe IP violates the usage policy. Entirely reasonable as a goal. What users then reported was refusals on ordinary work: crash analysis, debugging, interoperability, and — with real irony — anti-cheat development.

So I went and read the policy itself:

Policy text permitting authorised security research, against reported refusals on ordinary work

Anthropic's Usage Policy, effective 12 November 2026, says in plain text:

"This section does not prohibit security research, testing, or tool development conducted on systems you own or operate, with the authorization of the system owner, or within the scope of an authorized bug bounty program or vulnerability disclosure policy, provided the activity complies with applicable law."

And it goes further — there is a stated path for exactly this work:

"For work covered by our real-time cyber safeguards, users may apply for adjusted access through our Cyber Verification Program."

The written rule permits the work. The shipped classifier does not. That gap is the whole story, and it is the third time this month I've written the same sentence in a different costume:

  • In July, Hugging Face's incident responders were blocked by commercial models during their own forensics, because the guardrail "cannot distinguish an incident responder from an attacker."
  • Mistral built its latest model's marketing around "provider-level refusals can block legitimate vulnerability research and incident response."
  • And now a prompt change aimed at game cloning catches people debugging their own crashes.

The pattern underneath is identical: a classifier can read the request but not the authorisation. "Analyse this binary" looks the same whether it is your binary, your client's binary under contract, or someone else's. The missing input is not in the text.

Verification programmes are the correct shape of answer, and both Anthropic and the REA project's own community point at them. Their weakness is the one I flagged in the guardrails piece: nobody enrols mid-incident on a Saturday. If the enrolment latency exceeds the work's urgency, the programme exists but does not function.


5. What to change on Monday

Return artifacts, not summaries. Whatever your agent tool does, make its output citable back to a source — a file, an offset, a row id, a log line. The agent gets better, the human can audit, and your failure mode changes from silently wrong to checkably wrong.

Assume every binary and protocol you ship is readable, and go read it first. Dragos's line is the right planning assumption. If you ship firmware or a thick client, run the analysis yourself: embedded secrets, hard-coded credentials, what your own update channel reveals. Someone else is doing it this week whether you do or not.

Put a human approval gate on irreversible operations, including for your own agents. The only documented AI-caused OT damage so far was an authorised agent bricking a PLC with a bad flash write. Flash writes, firmware pushes, schema migrations, DNS changes, production deletes — the list is short and you know what's on yours.

Know your component inventory, not just your product inventory. One vulnerable RTOS network stack sat inside 19 WAGO models with no patch available. An SBOM is the difference between answering "are we affected?" in hours or in weeks.

Prioritise by reachability, not by CVSS. Dragos again: a 4,000-row spreadsheet sorted by CVSS is not a plan. Exploit difficulty is precisely the variable that just collapsed, so ranking by it ranks by the thing that stopped being stable.

And if a model refuses legitimate work: check the policy, then check for a verified-access path. Do not assume the refusal reflects the rule. On current evidence it frequently doesn't — and knowing that is the difference between filing a support request and redesigning your workflow around a constraint that isn't real.


6. The part I keep coming back to

REA's DISCLAIMER.md is worth reading as a piece of governance design, not just legal cover. The project enumerates what it will not help with — DRM circumvention, game cheats, copying proprietary software, bypassing access controls, and notably "evading the usage policies or safety measures of AI model providers" — and then states a consequence: such requests "will be closed without response in issues and discussions, and may result in removal from the REA community."

That is a social control on a capability that cannot be controlled technically. The tool is MIT-licensed and 110,000 people have forked it; there is no switch to flip. What remains is norms, and the maintainers chose to state theirs explicitly rather than pretend neutrality.

I don't think norms are sufficient. I do think they're the only layer still available once the weights and the code are out, which is the same conclusion I reached about open-weight models and cyber capability — only the interventions baked into the artifact survive distribution, and everything else is a request.

What REA really demonstrates is smaller and more unsettling than "AI can reverse engineer anything." It is that a thin, well-designed interface over existing tools can collapse a cost curve that an entire industry had quietly built its security assumptions on top of. Nobody needed a breakthrough. They needed a doorway, and someone built one.


Source notes

Read directly at the source. The architecture, the provider list, the capability table, the evidence-returning description, the licensing language about commercial tools, and the full responsible-use list: README.md and DISCLAIMER.md of github.com/morluto/rea, read 9 November 2026. Star count, fork count, licence and creation date: the GitHub API, same day. The policy quotations and the Cyber Verification Program: Anthropic's Usage Policy, effective 12 November 2026, read 9 November. The WAGO figures (8.5 hours, $535.74, 12 minutes, the bricked controller, 19 affected models), the 125.3-day-to-0.5-day finding attributed to Cogent Research via Dark Reading, and the "obscurity was never a control" formulation: Dragos's analysis, Michael Rothschild, 5 November 2026.

Reported, not measured by me. That Anthropic added prompt language to Claude Code on Opus 5.5, and that users encountered refusals on legitimate reverse-engineering work, comes from trade-press reporting and from the REA project's own discussion board. I did not run any refusal testing, I have no refusal rate to offer, and I am not treating anecdotes as data. The policy text on the left of that chart is verbatim; the right side is a summary of user reports and is labelled as such on the chart itself.

Not verified. I have not run REA, benchmarked any provider, or reproduced the WAGO result. The star trajectory before today — under 10,000 to roughly 234,000 in eight days — is Dragos citing blacklens.io from 20 October; I could not independently reconstruct historical star data.

Deliberately omitted. This piece contains no operational detail, no target selection guidance and no exploitation steps. The audience I write for builds and defends systems; where this article is actionable, it is actionable for the defence.