---
title: "These past two days, the timeline is full of REA, with a bunch of people exclaiming, \"Closed-source commercial software is going to be stripped bare by AI, not even a pair of underwear left.\" I looked through its repo, MCP contract, and a few cases, and the underlying logic"
url: "https://reamcp.dev/en/cases/timeline-rea-ai-repo-mcp-case-ac3d44"
source: "https://x.com/i/status/2109597331762872359"
source_type: "resource"
author: "edisonZ"
author_handle: "ai_edisonZ"
stars: 0
category: "File formats & protocols"
categories: ["formats-protocols"]
tags: ["electron", "evidence-loop", "ipc", "mcp", "notion", "reverse-engineering"]
added: "2026-10-15T00:40:38.398Z"
updated: "2026-10-15T00:40:38.398Z"
locale: "en"
content_locale: "en"
---

# These past two days, the timeline is full of REA, with a bunch of people exclaiming, "Closed-source commercial software is going to be stripped bare by AI, not even a pair of underwear left." I looked through its repo, MCP contract, and a few cases, and the underlying logic

An X long-form article analyzing the REA (Reverse Engineer Anything) architecture, breaking down its MCP layered design, Evidence ID evidence loop mechanism, and using the Notion clipboard IPC call chain as a case study. Finally, it discusses its capability boundaries (cannot penetrate the backend, relies on local IDA/Ghidra, ineffective against VMP packing).

## Description

These past two days, the timeline is full of REA, with a bunch of people exclaiming, "Closed-source commercial software is going to be stripped bare by AI, not even a pair of underwear left."

I looked through its repo, MCP contract, and a few cases. The underlying logic is actually very straightforward, even without any black magic.
It hasn't invented any new decompilation model, and hasn't even parsed a single line of assembly itself.

But why can it make Claude Code quickly figure out Notion's cross-process communication within minutes, and even write a clean-room reproduction?
The real contrast and value lie here.

1. Pain point: Why did feeding decompiled code directly to AI never work before?

Most people have tried stuffing reverse-engineered assembly or obfuscated JS into large models.
The result is basically a disaster: thousands of lines of code with stripped symbol names and fragmented context thrown in, and the large model guesses and stumbles, with 80% of the logic explanation relying entirely on hallucinated imagination.

REA took a different approach: instead of letting the large model guess at the outermost layer, it built a locally running MCP Server, peeling the entire analysis chain layer by layer:

 - Decision layer (Claude Code / Codex): understands the target, proposes hypotheses, sets direction, and writes reproduction code after obtaining evidence.
 - Scheduling layer (REA MCP): unifies reverse-engineering interfaces across ends, outputting structured evidence packages with Evidence IDs.
 - Execution engine (local toolchain): native programs call IDA / Ghidra / Hopper to extract assembly and cross-references; Electron / frontend directly performs AST static analysis and Source Map restoration; Android calls JADX.

2. Core mechanism: Using the Evidence Loop to crush the large model's hallucinations

What consumes the most effort in reverse engineering has never been failing to understand a piece of code, but constantly manually tracking cross-references (Xrefs), taking notes, and piecing together fragments in the decompilation window.

REA turned this process into an Agent's "verification loop":
The Agent proposes a hypothesis, and the tool returns evidence slices containing precise byte offsets and call topology. More critically, if a static analysis call graph is incomplete, the tool explicitly marks it as "limited coverage."

This means the large model won't misjudge "no call found within the static scope" as "no call exists logically." It must use the conclusive Evidence ID from the previous round to trace the next layer, gradually converging the analysis scope.

3. Specific case: Notion clipboard cross-process call chain

Looking at the official case of tracing the Notion clipboard, the process is actually very clear:
To figure out "how content is written to the system clipboard when clicking copy on the Notion web page":
 1. Scan the APIs exposed by the frontend, locate the preload wrapper function;
 2. Capture the unique IPC channel name notion:clipboard:write;
 3. Follow the channel name to locate the listener and permission check in the main process code;
 4. Finally string together the complete chain of calling Electron native APIs.

Four steps, and the AI didn't guess any code implementation, relying entirely on the factual anchor of the IPC channel name to seamlessly piece together the cross-process call endpoints.

4. Don't mythologize it: 3 insurmountable physical boundaries

To see its value clearly, you must also see its boundaries clearly:

 1. Zero backend penetration: It can only analyze code within the local client. The core logic of SaaS products is entirely in cloud servers, and this tool cannot touch it at all.
 2. Native analysis is highly dependent on the local environment: Reverse-engineering C/Rust/Go native programs requires you to have a commercial version of IDA or Hopper / Ghidra configured locally. It doesn't carry decompilation capabilities itself.
 3. Strong hardening remains a dead end: When encountering VMP packing or high-strength control flow flattening obfuscation, traditional tools can't crack it, and REA is equally helpless.
 4. The output is mechanism and pseudocode, and it cannot restore a 1:1 original engineering source code out of thin air.

5. Cognitive elevation from an engineer's perspective

The signal REA releases is very clear:
When AST static analysis, symbol extraction, and cross-reference tracking are packaged into an Agent's basic tools, the threshold for analyzing clients has shrunk from "days of human effort" to "the Token cost of a few rounds of dialogue."

So-called "technical barriers" built purely on client code logic, frontend packaging, and simple obfuscation are seeing their defensive returns approach zero.

Client code is becoming a fully transparent white box. The real moat of software has completely shifted to cloud private data flywheels, real-time business Context, and the depth of understanding of users' real scenarios.

## Original README

这两天 timeline 上都是 REA，一堆人惊呼“闭源商业软件要被 AI 扒得连底裤都不剩了”。

翻了下它的 repo、MCP 契约和几个 case，底层逻辑其实非常直接，甚至没什么黑魔法。
它没有发明任何新的反编译模型，甚至连一行汇编都没自己解析过。

但为什么它能让 Claude Code 在几分钟内摸清 Notion 的跨进程通信，还能写出 clean-room 复现？
真正的反差和价值在这里。

1. 痛点：为什么以前直接把反编译代码喂给 AI 根本行不通？

大部分人之前都试过把逆向出来的汇编或者混淆 JS 塞给大模型。
结果基本是灾难：几千行剥离了符号名、上下文破碎的代码丢进去，大模型连猜带蒙，80% 的逻辑解释全靠脑补幻觉。

REA 换了个思路：不让大模型在最外层猜，而是做了一个本地运行的 MCP Server，把整个分析链路分层剥离：

 - 决策层（Claude Code / Codex）：理解目标、提假设、定方向，拿到证据后写复现代码。
 - 调度层（REA MCP）：统一各端逆向接口，输出带 Evidence ID 的结构化证据包。
 - 执行引擎（本地工具链）：原生程序调 IDA / Ghidra / Hopper 提取汇编与交叉引用；Electron / 前端直接做 AST 静态分析与 Source Map 还原；Android 调 JADX。

2. 核心机制：用 Evidence Loop 压死大模型的幻觉

逆向工程最消耗心力的，从来不是看不懂某段代码，而是在反编译窗口里不断手动追踪交叉引用（Xrefs）、记笔记、拼碎片。

REA 把这个过程变成了 Agent 的“查证循环”：
Agent 提出一个假设，工具返回包含精确字节偏移、调用拓扑的证据切片。更关键的是，如果某个静态分析调用图不完整，工具会显式打上“覆盖范围受限”的标记。

这意味着大模型不会把“静态范围内没查到调用”误判为“逻辑上不存在调用”，必须拿着上一轮确凿的 Evidence ID 才能追查下一层，把分析范围逐步收敛。

3. 具体 case：Notion 剪贴板跨进程调用链

看官方追踪 Notion 剪贴板的案例，过程其实非常清晰：
要搞清楚“Notion 网页端点击复制，内容如何写入系统剪贴板”：
 1. 扫描前端暴露的 API，定位到 preload 包装函数；
 2. 抓取到唯一的 IPC 通道名 notion:clipboard:write；
 3. 顺着通道名在主进程代码里定位监听器和权限校验；
 4. 最终串出调用 Electron 原生 API 的完整链路。

四步操作，AI 没有猜测任何代码实现，全靠 IPC 通道名这个事实锚点，把跨进程的调用端点严丝合缝拼齐。

4. 别神化它：3 个无法逾越的物理边界

看清它的价值，更要看清它的边界：

 1. 零后端穿透力：只能分析本地客户端内的代码。SaaS 产品核心逻辑全在云端服务器，这套工具碰不到分毫。
 2. 原生分析高度依赖本地环境：逆向 C/Rust/Go 原生程序，前提是你本机配好了商业版 IDA 或 Hopper / Ghidra，它自己不带反编译能力。
 3. 强加固依然是死穴：遇到 VMP 加壳、高强度控制流平坦化混淆，传统工具啃不动，REA 同样抓瞎。
 4. 产出的是机制与伪代码，无法凭空还原出 1:1 的原始工程源码。

5. 工程师视角的认知升维

REA 释放出的信号非常明确：
当 AST 静态分析、符号提取和交叉引用追踪被打包成 Agent 的基础工具后，分析客户端的门槛已经从“几天的人力消耗”缩减到“几轮对话的 Token 成本”。

纯靠客户端代码逻辑、前端打包和简单混淆构筑的所谓“技术壁垒”，防守收益正在趋近于零。

客户端代码正在变成全透明的白盒。软件真正的护城河，已经彻底转移到了云端私有数据飞轮、实时业务 Context，以及对用户真实场景的理解深度上。