REA: The MCP Reverse Engineering Server That Gained 115K Stars in a Week

The MCP (Model Context Protocol) ecosystem is expanding rapidly, and REA (Reverse Engineer Anything) is one of the most noteworthy open-source projects right now. It packages mature reverse engineering engines into a local MCP server, allowing coding agents like Claude Code, Codex, and Cursor to directly "understand" software without source code. The repository morluto/rea went from obscurity to 115,000 stars in just one week, making it one of the fastest-growing projects in GitHub history.

But behind the hype, what problem does REA actually solve, and which parts are overhyped? This article provides a relatively measured assessment based on official documentation, showcased case studies, and real-world evaluation feedback.

The Anomalous Growth in the Star Curve

The REA repository was created in April 2026, then went quiet for several months. It wasn't until early October that Trendshift's daily tracking recorded its first appearance on the trending chart—gaining about 1,400 stars that day. The curve that followed was nearly vertical: 5,602 new stars on October 7, jumping to 19,375 on October 9, 26,572 on October 10, and reaching 31,255 on October 11. During the week of October 6–12, it held the top spot on GitHub Trending for five days.

The release cadence has been equally aggressive. Version 3.2 dropped on October 3, 4.0 on the 5th, 5.0 on the 7th, 6.0 on the 8th, and 6.1 through 6.4 crammed between the 9th and 11th. Seven minor versions in nine days—this pace is a warning signal for any team preparing to adopt it in production.

There was no single trigger for this explosion. What really worked was the tagline—"understand any feature you like, all the way down to the binary layer"—combined with a demo video of an agent reconstructing a desktop app from its binary. But a more accurate characterization is this: REA is a well-built connector that links AI agents with reverse engineering tools that already existed, not some revolutionary new engine.

What REA Actually Does

REA runs as a local MCP server. Your agent calls its tools, REA selects the appropriate engine for the target and performs the inspection, then returns structured analysis results with provenance and explicit uncertainty notes. The same pipeline is also available as a CLI for scripting without an agent.

According to the target comparison table in the README, REA handles a fairly wide range of targets:

• Native binaries: Returns pseudocode, assembly, strings, symbols, and cross-references. Requires Hopper, Ghidra, or IDA.
• Go binaries: Directly reads compiler version, modules, and build configuration with no additional tools needed.
• JavaScript and Electron app code: Extracts modules, imports, source maps, routes, and IPC boundaries using only Node.js.
• Websites: Outputs page structure, scripts, network observations, and screenshots, relying on a Chromium-based browser.
• Saved network captures: Parses requests, responses, payloads, and provenance. HAR format is supported directly; native mitmproxy on Linux requires mitmdump 12.2.3.
• .NET assemblies: Extracts metadata, CIL, and native dependencies with zero additional dependencies.
• APK and Android devices: Produces manifests, decompiled methods, logs, and screenshots. Requires JADX plus JDK, and adb.
• Firmware: Identifies regions and extracts contents. Depends on Binwalk or Unblob on Linux.
• WASM and EVM bytecode: Parses sections, imports/exports, and selector dispatch. Requires WABT, Linux x64 only.

What truly distinguishes REA from a "thin wrapper" is its evidence model. Every result carries provenance: file digests, byte ranges, JSON pointers into captures, and a list of things the analysis could not determine. The project documentation emphasizes this repeatedly. The security FAQ in the README also candidly acknowledges that analysis runs locally, but the model provider behind the agent still receives tool output according to its own data policies.

MCP (Model Context Protocol) is an open protocol introduced by Anthropic in late 2024 to establish standardized connections between AI applications and external data sources and tools. Think of it as the "USB-C port of the AI world": models no longer need custom integrations for each tool, but instead call tools, resources, and prompt templates exposed by servers through a unified JSON-RPC message format. MCP servers can run locally or be deployed remotely via HTTP/SSE. REA's choice of a local server form means the entire reverse engineering pipeline stays on your machine, but the tool results it returns are still sent to the model provider—this is why the article repeatedly stresses that it is "not a sandbox." Understanding MCP is a prerequisite for understanding REA's positioning—its innovation lies in protocol adaptation, not in the reverse engineering algorithms themselves.

HAR (HTTP Archive), which appears repeatedly in the article, is a standardized JSON format for recording complete network sessions captured by a browser or proxy. Each entry contains the request method, URL, request headers, request body, response status code, response headers, and response body, along with timestamp and duration information. Chrome DevTools' Network panel can directly "Save all as HAR," and tools like mitmproxy can export the same type of data. HAR's value lies in being an offline, reproducible evidence snapshot—REA does not re-issue any requests when reading it. But HAR has two common pitfalls: first, it includes Authorization headers and cookies by default, which need to be sanitized; second, under high-concurrency scenarios, the order of entries may not reflect true causality. REA's credential stripping and per-entry verification mechanisms are designed precisely to avoid these two issues.

Installation and Getting Started

The prerequisites are clear: Node.js 22.19 or higher (23 and 25 are not supported) plus npm. A single command registers the MCP server and installs skill instructions for the corresponding agent:

npx rea-agents setup

The installer first shows a plan, backs up existing configuration, and only writes after your confirmation. According to the installation documentation, REA supports over a dozen clients including Claude Code, Claude Desktop, Codex, Cursor, Gemini CLI, Windsurf, Devin, OpenCode, Antigravity, GitHub Copilot CLI, VS Code, Grok Build, and Hermes, each of which can be specified via the --client flag. After restarting the agent, you can ask questions directly, such as "figure out how search is implemented in the Notes app, show me the evidence, then build something similar in my project."

For a global CLI installation, use npm install --global rea-agents, then self-check with rea doctor --json.

Static JavaScript analysis, .NET, websites, and capture processing require no additional engines. Deep native analysis requires Hopper, Ghidra 12.1 with JDK 21 or higher, or IDA. The installer can automatically install Hopper after you agree, but Hopper is standalone commercial software requiring a separate license. The Ghidra path on Windows is marked as experimental.

What the Showcase Cases Reveal About Real Capabilities

The project's own case studies are the most honest benchmark. In the DX-Ball study, the agent traced the call chain all the way to the position-to-translation helper function, rewrote incomplete pseudocode into C, and the reconstructed result passed the original 3,205 x86 test cases and fully reproduced the 63 bytes of the compiled function. In the Notion case, REA crossed from the renderer process through preload and IPC all the way to the Electron main process, clarifying the call path of the clipboard API. A third case reconstructed the bullet ring angle calculation from the 16-bit instructions of a 1990s PC-98 game.

The common feature of these cases is: the problem was well-scoped—how a single function works, where a particular data path leads—and came with a way to verify the answer. This is exactly the feasible range for agent-based reverse engineering today.

The "rebuild an entire app" style demos are eye-catching in video, and the results do bear some resemblance to the target. But an early review compared REA against a plain agent on a simple Mac app and found the gap was small, while REA ran slower. The value only emerges when the question is specific enough and the target complex enough.

From Network Capture to Testable API Specs

For anyone building on top of APIs, this part is the most practical. REA's inspect_web_network_capture tool can read HAR files or native mitmproxy captures on Linux offline, without re-requesting any recorded URL. It verifies each entry, preserves request and response bodies along with their digests, and structurally excludes authorization headers, cookies, and credentials in URLs.

The next capability will be immediately recognized by API teams. Feed the preserved evidence to inspect_analysis_view with the api-surface view specified, and REA groups every request by method, origin, and inferred path template. Numeric IDs become {numeric}, UUIDs become {uuid}, long hex strings become {hex}, and dates become {iso-date}. Each group cites its original records and flags mixed status codes or content types. The capture documentation carefully notes that this view does not claim to constitute a schema or handler—it is an inferred inventory, not a specification.

This inventory happens to be the starting point for an API reverse engineering workflow. The typical path is: first reproduce the flow in Chrome DevTools with a test account, saving all requests with content as HAR; have the agent analyze this HAR with REA and summarize the API surface, yielding an endpoint list, ID patterns, and error calls; then import the same HAR into Apidog, turning the captured requests into endpoints with built-in test cases; then use the {numeric} and {uuid} placeholders inferred by REA to guide which path segments need parameterization in Apidog; finally enable smart mock so client code can run before the real API ships, write assertions against captured response shapes, and execute in CI via the Apidog CLI.

The division of labor is clear: REA excels at reading evidence and explaining it, while Apidog is where endpoints become shareable, mockable, testable, documented contracts. The two do not replace each other.

API surface refers to the complete set of endpoints, methods, parameters, and response shapes that a service exposes externally. It is not a formal contract, but rather an outline "traced backwards" from actual traffic. REA's api-surface view classifies each request in a HAR by method, origin, and inferred path template, replacing specific values with placeholders like {numeric}, {uuid}, {hex}, and {iso-date}, thereby compressing a large number of discrete samples into a small number of readable endpoint patterns. The industry equivalent of this approach is "traffic-driven API discovery," commonly used for legacy system modernization, competitor integration, or SDK auto-generation. Note its boundaries: path templates are statistical inferences, mixed status codes or content types are flagged as uncertain, and it won't tell you whether parameters are required or optional, nor provide field-level schemas—these must be filled in manually or by tools like Apidog.

A Few Things You Must Know Before Adopting

The release pace is a double-edged sword. Seven minor versions in nine days, combined with the project's always-bump-minor policy, means minor upgrades may introduce breaking changes. The 6.2 migration guide changed the shape of every MCP result. If you're writing scripts based on REA's JSON output, be sure to pin versions and read the changelog before upgrading.

It's a connector, not a sandbox. The project security policy explicitly states that the local provider bridge is not a sandbox, and opening untrusted binaries executes parsing with your user privileges. Analyzing untrusted targets must be done in an isolated environment.

Platform limitations are very specific. Native mitmproxy decoding requires exactly mitmdump 12.2.3, running on Linux, and provided by you. Firmware extraction, EVM, and WASM paths are Linux x64 only. Hopper has no Windows build.

Legal responsibility is yours. The README limits REA to legitimate research, analysis, and reconstruction, and states that users are responsible for obtaining authorization. The legal issues around copying competitor features don't change just because the tool exists. The project has also had to state: it does not issue tokens, and any coin borrowing its name is unrelated to it.

The project is still early. At the time of writing there are over 100 contributors, 170+ open issues and PRs. The documentation is fairly complete, but be prepared for rough edges once you stray from the demo path.

FAQ

Is REA free? Yes. MIT license, no charge for the npm package. If you choose to use Hopper for native analysis, that's a separate paid product; Ghidra is free.

Does REA upload my app or binary? No. Analysis runs locally. Tool results are sent to the model your agent uses, so that provider's data policies apply.

Do I need Ghidra or IDA to get started? No for JavaScript, Electron, .NET, website, or capture analysis. Only native binary decompilation requires an engine.

Can REA generate OpenAPI specs directly from traffic? No. The api-surface view is an inferred inventory with path templates. Import the HAR into Apidog to get editable endpoint definitions, then export OpenAPI from there.

How to Use It Right Now

REA's stars come from a simple but effective positioning: packaging real reverse engineering engines behind an MCP server and clearly documenting the evidence returned. Use it to answer well-scoped questions—how a particular function works, which IPC channel carries messages, what an app's traffic looks like. Treat the "rebuild everything" demos as demos only.

For API teams, the most practical benefit is in the capture path. Have the agent read a HAR with REA, then import the same file into Apidog to turn the inventory into mockable, testable, documentable endpoints.

One-line Summary

REA wraps mature reverse engineering engines in a local MCP server so coding agents can understand software without source code, but its real value lies in well-scoped, specific questions.

Paragraph Summary

REA is the morluto/rea open-source project that shot from obscurity to 115,000 GitHub stars in a week, packaging reverse engineering engines like Ghidra, Hopper, JADX, and Binwalk into a local MCP server for agents like Claude Code, Codex, and Cursor. Its core differentiator is the evidence model: every result carries file digests, byte ranges, JSON pointers, and uncertainty notes rather than being a black box. The genuinely landing scenarios are well-scoped questions—how a particular function is implemented, which IPC path is used—not the "rebuild the entire app" shown in demo videos. Most practical for API teams is the capture path—REA reads a HAR to infer the API surface, which then imports into Apidog to become mockable, testable endpoint definitions. Before adopting, watch out for the aggressive release cadence of seven minor versions in nine days, the non-sandboxed execution model, and hard platform limits like Linux x64.