REA Beginner Guide: Install to Your First AI Reverse-Engineering Session with Claude Code (EXE, APK, 2026)

REA (Reverse Engineer Anything) is an MCP-oriented bridge between Claude Code and the tools reverse engineers already use—Ghidra, Hopper, IDA, and jadx-headless-mcp. Source and issues: github.com/morluto/rea. Skills and setup docs: rea.tools. This guide walks from legal boundaries through install, EXE and APK workflows, your first agent session, comparisons, pitfalls, and a seven-step action plan.

1. Why REA: Ghidra alone vs agent + MCP

Disassemblers excel at graphs; they are weak at narrating feature behavior across many functions. Claude Code excels at planning questions but cannot see your Ghidra project until something like REA exposes read-only tool endpoints. REA is that layer: structured fetches (strings, imports, pseudocode snippets, Android manifest slices) inside an agent loop you supervise.

This mirrors the Agent Skills pattern—repeatable workflows with permission boundaries—covered in our Agent Skills guide. Harness choice (Pi vs Claude Code vs Codex) affects how MCP servers start and how long context lasts; see Pi vs Claude Code vs Codex. For samples and keys, prefer cloud Mac isolation plus Mac rental, pricing, and help center links when you need a disposable analysis host.

2. What targets: EXE/PE, APK, Electron/JS, .NET

3. Install REA

1. Install Node 22+; verify node -v.
2. Run npx rea-agents setup to register MCP and Skills for Claude Code.
3. Restart Claude Code completely.
4. Run rea doctor until paths for Ghidra, JDK, and jadx JAR resolve.

npx rea-agents setup
rea doctor
export REA_JADX_MCP_JAR=/absolute/path/jadx-headless-mcp.jar

4. EXE workflow

Import into Ghidra (or Hopper/IDA), wait for analysis, then ask Claude Code for evidence-backed explanations: licensing strings, update checks, configuration paths. REA should return citations you can open in the disassembler. Refuse weaponization prompts; focus on understanding and defensive observability.

5. APK workflow

Install JDK 17, point REA_JADX_MCP_JAR at the headless MCP JAR, and use Android inspect tools from the REA catalog. Start from permissions and exported components, then follow network and storage indicators into Java/Kotlin or JNI.

6. First session prompts

• “Map HTTP-related strings and hypothesize config load path—cite functions.”
• “Summarize exported activities and riskier permissions from the manifest.”
• “Explain update signature verification without bypass instructions.”

7. Compare tools

8. Choose scenario

9. Recommended stack

Claude Code + REA + isolated Mac VM: snapshots for rollback, no sync folders, Ghidra and JDK colocated with samples. Cloud Mac fits bursty audits—see pricing.

10. Pitfalls

• Skipping Claude Code restart after setup.
• Wrong JDK major version for jadx MCP.
• Trusting model prose without disassembler clicks.
• Running unknown binaries on a daily driver.
• Prompts that request bypass or crack steps.

11. Action plan (7 steps)

1. Confirm authorization; copy sample to isolated folder.
2. Node 22+ and npx rea-agents setup.
3. Restart Claude Code; pass rea doctor.
4. Import EXE to Ghidra; finish auto-analysis.
5. Configure jadx JAR env and JDK 17 for APK.
6. Run first-session prompts; save citations.
7. Delete artifacts; snapshot or destroy VM.

FAQ

Can I analyze a competitor without permission?

No—stick to software you may legally study.

Does REA replace Ghidra?

No—it orchestrates tools; Ghidra remains the engine.

What first for APK?

Manifest, exported components, then network/storage.

Conclusion

REA turns reverse engineering into an evidence-driven dialogue when you keep humans in the loop and samples in isolation. Harden prompts with Agent Skills; rent a clean Mac via rental and help when needed.

Reverse engineering in 2026 is less about memorizing every calling convention and more about building a repeatable evidence pipeline: import artifact, index strings, anchor on imports, validate hypotheses in pseudocode, and document what you can prove. REA does not remove that discipline—it automates the boring fetches so you spend cognitive budget on judgment.

Claude Code becomes the conductor. You state intent in plain language; the model plans tool calls; REA returns structured slices from Ghidra or jadx. You still approve risky steps. Treat every summary as a draft until you click through to the cited function or manifest line.

For PE files, start with entry points and early imports: file I/O, registry, network, and cryptography APIs often form the skeleton of licensing and update logic. Ask REA for cross-references from suspicious strings before you dive into graph layout. For packed binaries, document the packer and unpack in a dedicated step—do not ask the model to 'defeat' protection.

For APKs, exported components are your compass. A single exported deep link or content provider can explain more than an hour of smali scrolling. Combine manifest inspection with decompiled Kotlin where available; when obfuscation hides names, pivot to URLs, asset paths, and JNI library boundaries.

Electron and hybrid apps reward configuration archaeology: preload scripts, custom protocols, and local HTTP listeners show up quickly in text search once REA surfaces paths. .NET assemblies may be readable in higher-level decompilers; use REA to relate managed entry points to any native shim DLLs.

Operational security matters as much as tooling. Store samples on encrypted volumes inside a VM with snapshots. Disable cloud sync folders in the analysis profile. Rotate API keys if an agent mistakenly reads a secrets file—Skills should scope filesystem access, as described in cloud Mac isolation guides.

When teaching teams, pair REA sessions with a written rubric: what question was asked, which tool returned data, what was verified manually, and what remains unknown. That rubric survives personnel changes better than a chat transcript.

Performance tuning: large Ghidra projects slow MCP round-trips. Trim imported memory blocks when possible, analyze only relevant modules, and close unused tools. For jadx, prefer headless MCP with explicit JAR path over GUI automation.

Comparison shopping between Pi, Claude Code, and Codex is really a question of where your tools live. Claude Code plus REA shines when you want local MCP servers, long sessions, and Skills checked into git next to your lab notes.

Finally, link your workflow to pricing reality: isolated Mac rental beats buying hardware you only use for quarterly audits. Document session teardown—delete samples, revoke tokens, snapshot clean state—so the next engineer inherits a safe baseline.

Reverse engineering in 2026 is less about memorizing every calling convention and more about building a repeatable evidence pipeline: import artifact, index strings, anchor on imports, validate hypotheses in pseudocode, and document what you can prove. REA does not remove that discipline—it automates the boring fetches so you spend cognitive budget on judgment.

Claude Code becomes the conductor. You state intent in plain language; the model plans tool calls; REA returns structured slices from Ghidra or jadx. You still approve risky steps. Treat every summary as a draft until you click through to the cited function or manifest line.

For PE files, start with entry points and early imports: file I/O, registry, network, and cryptography APIs often form the skeleton of licensing and update logic. Ask REA for cross-references from suspicious strings before you dive into graph layout. For packed binaries, document the packer and unpack in a dedicated step—do not ask the model to 'defeat' protection.

For APKs, exported components are your compass. A single exported deep link or content provider can explain more than an hour of smali scrolling. Combine manifest inspection with decompiled Kotlin where available; when obfuscation hides names, pivot to URLs, asset paths, and JNI library boundaries.

Electron and hybrid apps reward configuration archaeology: preload scripts, custom protocols, and local HTTP listeners show up quickly in text search once REA surfaces paths. .NET assemblies may be readable in higher-level decompilers; use REA to relate managed entry points to any native shim DLLs.

Operational security matters as much as tooling. Store samples on encrypted volumes inside a VM with snapshots. Disable cloud sync folders in the analysis profile. Rotate API keys if an agent mistakenly reads a secrets file—Skills should scope filesystem access, as described in cloud Mac isolation guides.

When teaching teams, pair REA sessions with a written rubric: what question was asked, which tool returned data, what was verified manually, and what remains unknown. That rubric survives personnel changes better than a chat transcript.

Performance tuning: large Ghidra projects slow MCP round-trips. Trim imported memory blocks when possible, analyze only relevant modules, and close unused tools. For jadx, prefer headless MCP with explicit JAR path over GUI automation.

Comparison shopping between Pi, Claude Code, and Codex is really a question of where your tools live. Claude Code plus REA shines when you want local MCP servers, long sessions, and Skills checked into git next to your lab notes.

Finally, link your workflow to pricing reality: isolated Mac rental beats buying hardware you only use for quarterly audits. Document session teardown—delete samples, revoke tokens, snapshot clean state—so the next engineer inherits a safe baseline.

Further reading

• Agent Skills guide for Claude Code and Codex →
• Pi vs Claude Code vs Codex (2026) →
• AI Agent Skills and cloud Mac isolation →