REA, short for Reverse Engineer Anything, is an open-source toolkit that helps AI coding agents investigate how software works, even when its original source code is unavailable. Hosted on GitHub, the project connects agents to analysis tools for native binaries, JavaScript applications, Electron apps, and other software.
Rather than attempting to recover an application's exact original source code, REA collects evidence from decompilers, disassemblers, strings, symbols, function references, and other analysis techniques. An AI agent can use that evidence to explain a feature, document an implementation, or build a compatible alternative for another project.
REA provides a command-line interface (CLI), a Model Context Protocol (MCP) server, and guided workflows for compatible AI coding tools. It is particularly useful for developers who need to understand undocumented behavior, investigate legacy software, or reproduce a feature without access to its implementation.
Features
AI-Assisted Reverse Engineering
REA is designed to let developers investigate software by describing what they want to understand in natural language.
For example, you could ask an AI agent to investigate how an application's offline search works, trace the relevant functions, explain the evidence, and implement similar functionality in your own project.
REA supplies the investigation tools and findings, while the AI agent performs the reasoning and writes the new implementation. This division makes it easier to investigate unfamiliar software without manually navigating every analysis tool.
The workflow generally follows three stages: decompile or inspect the target, trace the relevant behavior through the available evidence, and recreate the desired functionality in a separate implementation.
Native Binary Analysis
REA connects AI agents to tools that inspect compiled native applications. Depending on the configured analysis provider, developers can examine functions, strings, symbols, assembly instructions, pseudocode, references, and call relationships.
These capabilities help investigate how a binary implements a particular feature or interacts with other components.
For native analysis, REA supports integration with Hopper and Ghidra. The project also documents IDA-related support in its broader development direction, although provider availability and individual capabilities depend on the installed version and platform.
Hopper is a separate product with its own licensing requirements. Ghidra must be installed independently and configured before REA can use it.
Importantly, decompilation produces an approximation of the original program logic, not the original source code with all its comments, names, and design decisions intact.
JavaScript and Electron Application Inspection
REA can analyze JavaScript applications and Electron packages without executing the target application.
It can inspect application directories and ASAR archives to identify modules, imports, dependencies, and relationships between components. This is useful for understanding how a desktop application's frontend communicates with its underlying services.
For example, developers can investigate how an Electron application handles authentication, storage, updates, or networking by examining the available code and tracing the relevant modules.
Static analysis is especially convenient because it does not require a native decompiler for supported JavaScript targets. It also reduces the risks associated with running unfamiliar applications during an initial investigation.
Command-Line Interface
REA provides a CLI for running analysis tasks directly from a terminal or through automation scripts.
Install the command-line package globally with npm:
npm install --global rea-agents
Then start the guided setup:
rea setup
To check the environment and configured analysis tools:
rea doctor --json
For a JavaScript application or Electron package, you can run an analysis directly:
npx -y rea-agents@latest analyze-javascript-application \
/absolute/path/to/app --json
The JSON output makes it easier to process analysis results programmatically or pass structured findings to another tool.
Native binary analysis requires an appropriate provider to be installed and configured. The CLI therefore serves as a common entry point rather than replacing the underlying analysis engines.
MCP Integration for AI Coding Agents
One of REA's strongest features is its MCP server, which exposes analysis operations to compatible AI assistants.
The setup utility can configure supported clients, including Claude Code, Claude Desktop, Codex, Cursor, Gemini CLI, and Windsurf. Additional clients can connect through manual MCP configuration if they support local MCP servers.
After setup, an agent can call REA's tools to inspect a target, search for strings, examine functions, trace references, and collect evidence without requiring the user to execute each analysis command manually.
This integration is valuable for AI-assisted software development because it allows reverse engineering to become part of the same workflow used to modify and test code.
Guided Workflows and Evidence-Based Results
REA provides structured investigation workflows intended to guide an agent from an initial question toward a supported explanation.
Instead of returning only a conclusion, the tools can provide evidence and identify unresolved questions or limitations. Developers can then distinguish observed behavior from assumptions that require further testing.
The project also supports reusable analysis results and snapshots in relevant workflows, reducing the need to repeat expensive analysis operations unnecessarily.
This evidence-oriented approach is particularly useful when examining unfamiliar or poorly documented software, where an unsupported conclusion could lead to an incorrect implementation.
Local Analysis and Privacy
REA is designed to analyze target applications locally rather than uploading them to a hosted REA analysis service.
This is beneficial when investigating internal tools, proprietary software, or applications that cannot easily be shared with an external service.
However, the privacy boundary also depends on the AI agent and model provider being used. Analysis results returned to an agent may be sent to its configured model service, so developers should review that provider's data-handling policy before investigating confidential software.
Guided Installation and Diagnostics
REA includes a setup utility that configures the CLI, MCP server, and matching agent instructions. It can connect existing analysis tools and offer to install Hopper when needed.
The setup process presents proposed changes for review and approval and backs up existing agent configuration before applying changes.
Its diagnostic command checks dependencies, host compatibility, analysis tools, and agent configuration:
npx -y rea-agents@latest doctor
This helps developers identify missing dependencies or configuration problems before attempting a more involved investigation.
Performance and Compatibility
REA is distributed as a Node.js application and supports the command line and local MCP workflows. Its documented runtime requirements include Node.js 22.19 or newer in the 22.x line, Node.js 24.11 or newer in the 24.x line, or Node.js 26 and later.
Native analysis depends on the configured provider and supported host environment. The project documents support for macOS and selected Linux distributions, while Windows support varies by analysis provider and workflow.
Static JavaScript and Electron analysis has fewer dependencies because it does not require a native analysis engine. This makes it a convenient starting point for developers who want to try REA without installing a separate disassembler.
Actual analysis speed depends on the target application's size, the chosen provider, and the complexity of the behavior being investigated. Large native binaries may require more time and resources than a small JavaScript application.
REA is an analysis framework rather than a universal decompiler. Its capabilities depend on the tools available for the target platform, and the accuracy of conclusions depends on the evidence that can be recovered. It cannot guarantee recovery of original source code or perfectly reproduce every behavior of an application.
System Requirements
Runtime: Node.js 22.19 or newer in the 22.x line, 24.11 or newer in the 24.x line, or 26 and later.
Package manager: npm.
Operating systems: Supported macOS and Linux environments, with Windows support depending on the selected workflow and provider.
Native analysis: Hopper or Ghidra for the corresponding supported workflows.
AI integration: An MCP-compatible agent for interactive, agent-driven investigations.
JavaScript analysis: A local application directory or ASAR archive; no native decompiler is required for this workflow.
Ghidra integration has additional requirements, including a compatible Ghidra installation and Java Development Kit. Consult the current installation documentation for exact versions and platform-specific instructions.
Pros and Cons
Pros
Free and open-source under the MIT license.
Connects AI coding agents to reverse engineering tools through MCP.
Supports native binary investigation using decompilation and disassembly.
Analyzes JavaScript applications and Electron archives without executing them.
Provides CLI access for scripting and automation.
Collects evidence to support explanations of application behavior.
Offers structured workflows for investigating and recreating software features.
Designed for local analysis without a hosted REA analysis service.
Guided setup and diagnostic tools simplify configuration.
Can help developers understand legacy software and undocumented implementations.
Cons
Native analysis depends on external tools such as Hopper or Ghidra.
Some analysis providers have platform-specific limitations.
Decompilation cannot reliably recover the original source code.
Investigation quality depends on the available evidence and analysis engine.
Requires an AI agent for the full natural-language investigation workflow.
Additional setup may be necessary for native binaries.
Model-provider privacy policies still matter when sending analysis results to an AI service.
Reverse engineering complex applications can require substantial technical knowledge and time.
Download REA - Reverse Engineer Anything - rea-agents-6.10.1 - Software Mirrors |
|---|
REA - Reverse Engineer Anything - rea-agents-6.10.1 Source Code
REA - Reverse Engineer Anything - rea-agents-6.10.1 Source code (zip)
REA - Reverse Engineer Anything - rea-agents-6.10.1 Source code (tar.gz)
|
REA - Reverse Engineer Anything - rea-agents-6.10.1 Release Notes: 6.10.1 (2026-11-20)
This is the first 6.10 release published to npm. It includes the changes, migration notes, and contributor credits from 6.10.0 below, plus the patch fix.
Bug Fixes
- kuna: use one constant for the serial job count (#12735) (3e3faf2)
6.10.0 (2026-11-20)
Highlights
- Inspect and extract UEFI firmware volumes, files, and AMI NVRAM with three offline CLI and MCP tools. #12342. Thanks @bartman081523.
- Evidence revision 2 gives file, process, debugger, and browser observations explicit subject identities. See the migration details below.
- The verified Ghidra 12.2 lane opens recognized DOS COM files and supports more RISC-V, MIPS32, and PowerPC64 ELF targets. #4811 #4487 #2362 #2338 #12517 #12085. Thanks @abhay-2108, @AurelioB, @Davmunrey, @kaoru0822-kitauji, @Rinkia.
Changes
- JavaScript semantic indexing uses fixed object shapes for nested evaluation contexts to reduce allocation overhead. #9007. Thanks @mshzy.
- Inspect ELF dynamic dependencies and required symbol versions, resolve separate debug-file linkage, inspect DWARF compilation units offline, and decode FDO packaging and dlopen notes. e9c72db #7868 54e3918 #9560 637e4cb #8523 #7237 #7235. Thanks @AniketR10, @gensokyo-dev, @mvanhorn.
- Read cargo-auditable dependencies from WebAssembly and export Go and Rust dependency Evidence as CycloneDX. #5069 237b1ea #8445. Thanks @gensokyo-dev, @kaoru0822-kitauji, @mvanhorn, @yu0809.
- Decode CPython 3.14 and 3.15 bytecode and use Kuna 1.1000. 1d08253 #10518 #12107. Thanks @abhisheksharma001, @gensokyo-dev, @N0zoM1z0.
- Managed member inspection retains
unresolved_definitions and summarizes unresolved definition coordinates. Native inspection surfaces prototype instruction conflicts, resolves RISC-V initializer pointers, and identifies which Mach-O slices a signature covers. #12462 #8161 #1244 #12109 #11620. Thanks @akshad-exe, @N0zoM1z0, @ShuaixinHuang.
- GDB and Rizin explain why stopped sessions reject commands and why a debugger stop or close could not finish. #11652 #11517 #11185.
- Setup manages fx, Junie, Goose, and Kilo registrations, supports explicit MCP catalog profile selection, and flags a shared
enable: false as a manual conflict. Compact MCP input schemas use a portable advertised dialect. #10709 #9354 #11019 #10632. Thanks @kaoru0822-kitauji.
Fixes
- Desktop Evidence retains dconf failures with empty stderr. APT inspection honors disabled deb822 stanzas, uses ASCII separators, preserves tokens and effective identities for one-line sources, and verifies single-stanza identities. Desktop application lookup honors hidden overrides and rejects malformed overrides or desktop group padding before masking IDs. #10230 #10223 #12501 #12498 #12680 #12692 #12711 #12694 #12363 #12675 #12671 #12686 #12708. Thanks @kaoru0822-kitauji, @Plastic-time, @ShuaixinHuang.
- Windows shortcut inspection handles pre-epoch timestamps and validates LinkInfo offsets and fixed-size ExtraData blocks. Windows executable discovery uses PATH/PATHEXT, continues past malformed entries, and refuses unresolved objdump or Rizin commands. Headless IDA stdio bounds executable discovery, handles Windows launchers, and retains failed-launch cleanup for retry. #10305 #10303 #12403 #10361 422cff0 #10891 998faa4 #10739. Thanks @kaoru0822-kitauji, @wunianze666-netizen.
- Setup refresh preserves or repairs Hermes and Goose YAML aliases and merge-inherited settings, including inherited stdio transport. MCP records deferred schemas before protocol framing. b138f52 #10430 #9351. Thanks @kaoru0822-kitauji.
- Finalization keeps cancellation as the primary error when appropriate, captures cancellation during recovered-value publication, and preserves the initial failure after close. Cleanup reports live resources independently of failed closes, retains composite provider clients for retry, and combines provider cleanup failures while retaining their causes. Artifact readers also retain member stream failures during shutdown. 2e1e659 #10645 #12589 #12599 #12591 #12002 #12489 #12487. Thanks @anant8140, @Plastic-time.
- Browser capture admits relative Playwright trace paths through the CLI, validates large scenario reference lists, retains wide native numeric exclusions, reports capture-script semantic limits, keeps invalid CDP and Playwright response statuses unknown while preserving the trace’s reported status and error, bounds retained network-body verification memory, and speeds up script export conflict detection. 4822082 #10575 #10359 #10343 #10341 #11755 #11565 #12296 #12292 #12231 #12225 #12724. Thanks @chessing234, @kaoru0822-kitauji, @ShuaixinHuang.
- JavaScript analysis retains large async chunk collections, proven property presence at reads, shared array-iterator prototype effects, projected array dependencies, and lexical ordering across standalone blocks. It preserves uncertainty before initialization and after immutable pattern targets, and fixes V8 code-cache header handling. CommonJS wrapper redeclarations no longer invent application owners. Destructuring retains dependencies across const aliases, inactive defaults, and nested numeric properties. #10362 #12477 #7559 #12493 #12490 #12519 #12558 #12701 #12682 #12673 #10279 #12084 #12513 #12613 #12595. Thanks @coygeek, @kaoru0822-kitauji, @SII-YDD, @XiaoBinGan.
- ELF readers preserve literal directories in origin expansion, decode 32-bit PRPSINFO values correctly, and retain readable build IDs beside compressed notes. They preserve GNU version slots and dynamic-string diagnostics and distinguish an exhausted string table from a capped scan. ELF admission validates dynamic table framing, section and zlib declarations, interpreter sizes, and dependency table extents, and preserves unwind budget facts. #10215 #10189 #12674 #12685 #12678 #12693 #12445 #12193 #12113 #12344 #12308. Thanks @kaoru0822-kitauji, @wunianze666-netizen, @XiaoBinGan.
- PE readers reject out-of-file resource directories before applying the entry budget, validate certificate framing before capacity checks, and bound TLS and export reads to declared section content. GGUF readers reserve framing for fields following metadata values. UEFI extraction accepts the same
max_volumes and max_files scan controls as inspection. #10375 #12336 #12432 #12338 #12538.
- Gradle recognizes metadata via the root version marker, reports unfamiliar format versions, and preserves variant identity. Maven preserves qualified property keys and non-ASCII whitespace in POM version values, and matches declarations in the project namespace. NuGet handles OPC part-name equivalence and rejects invalid manifest relationship target modes. #12488 #12648 #12677 #11860 #12672 #12691 #12684 #12714. Thanks @ShuaixinHuang, @xu91102.
- Android mapping inspection reports residual signatures without a mapping member. Boot and OTA readers validate boot headers, vendor ramdisk tables, and OTA manifest and signature extents before capacity checks. MIPS inspection identifies unsupported Android relocation declarations. Harmony inspection matches manifests at exact archive-root paths. Deno lockfile inspection retains valid specifiers alongside undecodable rows. #12494 #12396 #12395 #12431 #12397 #12700 #12667.
- Mach-O parsing validates symbol extents before the hardening scan limit and maps high-backed segments in their declared virtual range. Hopper verifies the Mach-O profile signature before loader selection. ELF and Android OTA share exact-frame Zstandard decoding. #12465 #12479 #12485 #12416 #12398.
- GPU inspection reports malformed containers as
invalid_format and validates standalone PTX encoding during discovery. Core-note reads respect the recorded source range, and PyInstaller and Swift readers check entry framing and vtable bounds before applying capacity ceilings. #10644 #12707 #12634 #12622 #12627.
- Go SBOM export retains local modules without Package URL namespaces. Managed inspection retains module identity when its name is unreadable. The reference-source importer preserves cancellation during policy-file cleanup, and process capture handles Darwin-helper exit without crashing the host. #12293 #12441 #12323 #11714. Thanks @IvenKooLab.
- MCP doctor honors output choices on argument errors. Capture image readers validate PNG headers, and trace and keyed-archive errors expose the enforced parser limit. Sigrok catalog scans retain selected decoder rows only. The documentation site resolves authored links to their published routes. #2693 #12310 #12335 #12324 #12284 #12453. Thanks @jasonchen505.
⚠ BREAKING CHANGES
- Evidence records and hand-built bundles require
evidence_format: 2. Recreate older observations, bundles, and snapshots with 6.10. Re-exporting old observations does not update their identities. Read subject.identity in place of subject.digest, subject.format, and subject.architecture (file identities use sha256). Every record has a subject, using an explicit unknown identity when appropriate. Identity, including an artifact's selection, participates in Evidence IDs. Recreate 6.7-era artifact summaries before using compare_artifacts. #11416 #10861.
- Snapshots use
target: {kind, identity} and a non-null execution.subject: {identity, name, local_path}. Binding errors use the same target shape. Universal Mach-O Evidence IDs include the selected slice. Live page tools and their views use a {kind: "url", url, origin} identity with credentials removed, null origin for opaque URLs, and null subject name and local path. Withheld or unreadable URLs retain an unknown identity. Recreate affected Evidence and snapshots. #11551 PR 11559.
- Process captures require
manifest.root_process. Their subject identity is {kind: "process", pid, start_time, executable_sha256} when observed, {kind: "unknown", reason: "not-observed"} when the start identity could not be read, and {kind: "unknown", reason: "withheld-by-caller"} when PID normalization is enabled. Accept cleanup_outcome: "cleaned" on quiesced settlements. Recreate saved process Evidence. Existing omission semantics still apply: raw_data is omitted when it equals data, and residual_unknowns is omitted when there are none. #11568 #10481 #8032 #10956. Thanks @gensokyo-dev, @N0zoM1z0, @Rinkia, @wunianze666-netizen.
- Rizin command Evidence and GDB startup and console Evidence use
{kind: "session", session_kind, id, target}. The session target identifies the initial launch file when REA can observe it. GDB accepts an optional executable. Without one, or when the file identity could not be observed, the target is unknown with reason not-observed. The binding describes the launch file only. The current inferior's identity requires a separate observation. Recreate debugger Evidence because its IDs change. PR 11570 PR 11572 230db70 #11710 #11581. Thanks @gensokyo-dev, @N0zoM1z0.
- Ghidra and Hopper profiles replace hand-bumped markers with
analysis_profile.parameters.producer containing rea_version and sources_sha256. Ghidra drops bridge_sources_sha256 and version suffixes on selection values. Hopper drops function_dossier_coverage. Profiles and Evidence IDs change. Open the target and save a fresh snapshot. #11320.
- Ghidra requires a supported 12.x build starting at 12.2 and a JDK within that build's declared range (25 or newer for the verified 12.2 build). For a DOS COM file accepted by ComLoader, read the reported
load_address (now linear 0x100). The BinaryLoader fallback still uses 1000:0100. #12081 #12086.
- IDA attached registrations must explicitly set
"protocol": "native" and use the native plugin endpoint for an open GUI database. Migrate legacy 1.4 proxy registrations to that mode or to an ida-pro-mcp 2.x supervisor in headless mode. procedure_callers is removed from IDA profiles, and IDA assembly/instruction tools drop the may_show_ui annotation. #10846 #11546 #10516.
- Use
rea mcp or rea --mcp in place of rea --mcp. Regenerate shell hooks with rea completions and update Markdown argument-diagnostic snapshots for the new rendering. Flag-shaped unknown MCP subcommands honor the selected output format. 7d502dd #11724 62014b5 #11742 #10583 #11654. Thanks @gensokyo-dev, @N0zoM1z0.
- MCP rejects
full input and output schema profiles. Remove those settings or select compact. An unset REA_MCP_OUTPUT_SCHEMA_PROFILE now means off; set it to compact to receive tools/list].outputSchema. MCP limit errors omit details.limit.cli_flag; the CLI still supplies its own flag when applicable. [#10693 #11413.
- Use absolute local paths in MCP calls to
inspect_pcap_capture, start_rizin_debug_session, start_gdb_session (including inferior_tty), load_frida_script, and instrument_with_frida. CLI --script-file still accepts a relative path and records the resolved absolute source_path. #11508 #11079 #11580 #11506.
- Native
rea analyze rejects JavaScript-only options such as --integrity-policy with invalid_request naming the flag. Pass those options only for JavaScript targets. For inspect-managed-members --detail summary, rename --evidence-bundle to --evidence_output and read .summary and .evidence_bundle in stdout. Publication failures use the shared error shape. Composite CLI failures such as those from compare-managed-members can carry completed inputs as details.argument_observations] entries with {argument, observation}. [PR 10808 PR 10845 PR 10961.
- For a missing, unreadable, or non-regular target-selected plist, decode
target_unavailable with details.path and reason in place of invalid_request with input issues. Open a plist outside the current app bundle or resource root as a separate target. #9754 #10798. Thanks @Anandumv.
- In Cutter JSON command output, integers beyond JavaScript's safe range are decimal strings. Parse them with a lossless integer type. Cutter's
output_truncated and document_generation may be null. Treat truncation as unknown and list sessions again before choosing expected_generation. GDB MI decodes \e to ESC instead of rejecting the record. #12457 #10726.
- ADB package output preserves whitespace in
version_name. Decode numeric_issues and coverage; malformed versionCode and user_id declarations make coverage partial. For a malformed version token such as 45abc, expect a version_code issue with reason invalid_format, an increased issue total, and a null version code unless a later valid declaration supplies it. 1adc3fa #10519 #7123 #7271 #7281 #7388 #7409 #7534 #7692 #8067 #8141 #8302 #9195 #10172 #10389. Thanks @1052326311, @2SinceJuly, @carcraze, @coygeek, @deepakrakshit, @Eldergenix, @gensokyo-dev, @HeadmasterEggy, @Hiba-Malik, @kittimzhe, @mawahnnie, @N0zoM1z0, @Rinkia, @saariuslystoned, @ShuaixinHuang, @sx4im, @theo-73, @wunianze666-netizen.
- Update coverage decoders for native initializers and kernel build configs to accept
partial for observed but incomplete coverage and unknown when completeness could not be established. ELF unwind ranges use partial in place of incomplete, and capped model metadata arrays use partial in place of preview. #11483 #11486 #11463 #11469.
- Managed member comparison uses tagged objects in
limitations]; read code and side in place of limitation_reasons or message prefixes. Recreate managed observations. Supply explicit nullable assembly, boolean nesting_read, and signature_resolution as "type-names-v2" or null. Null is only valid without examined members, references, call edges, or field accesses. The historical bare-name comparison mode is removed. Call edges and field accesses require target_row_resolved. [#11177 #10952 #11334 PR 10992.
- Recreate JavaScript and Electron captures missing runtime
scripts.parse_failed_total or active Electron parameters.resolved_paths. Application analysis requires statistics.skipped_javascript_files and summary.protocol_registrations. Original-source and module-edge links require source_index and declaration_index. #10958 #10990.
- Recreate browser captures using the current producers. Source-map items require
effective_url, invalid maps require response_identity, and mapping rows require source_index and declaration_index. WebMCP declarations require schema_property_names_coverage. Storage results require content_fingerprints, fingerprint_algorithm, and fingerprints_complete; IndexedDB schema fingerprints require projection_version: 2. Link rows require context_url and context_scope. PR 10991 PR 11002.
- Browser page inspections require accessibility states, script
frame_id, and worker opener_target_id and parent_frame_id. Web-bundle captures require capture.target_origin. Scenario network rows with a null redirect predecessor require redirected_from_transaction_state. In page network requests, include redirects: ] when there are no redirects. DOM snapshots require node_value_length_unit, and redirect timeline rows require redirect_response. Recreate captures before comparing them, including inline inspections. Re-import reference sources so every exclusions[] row carries entry_kind, using the explicit unknown kind where applicable. [#11344 PR 11014 PR 10897.
- Recreate PCAP Evidence with
dns_queries].query_labels_hex and explicit tshark/capinfos identity fields. Recreate desktop state Evidence with effective_view_policy.sqlite_view_bytes, SQLite Evidence with worker_timeout_ms, and Dart AOT Evidence with string_pool.policy. [PR 10879 PR 10886.
- Recreate Android packages, component views, and reference observations with component declaration facets,
target_definition, and direct_invokes_coverage. Declaration coverage and counts drop unknown; manifest views declare facet: "manifest". JNI failures with kind integrity require integrity_check. #11624 PR 10904.
- Recreate native Evidence for Mach-O encryption, malformed slice causes, import facts and symbol
runtime_name; ELF import/export encoding and export visibility; value-flow limits; load-image permissions and relocation symbols; Swift type_reference_kind; and GPU amd_target_metadata. Update strict readers for removed legacy values such as unknown ELF export visibility and modinfo_field_exceeds_limit. PR 10946.
- Recreate inventory Evidence missing ESP
format_metadata.flash_dump, PE signer observations missing unsigned_attribute_oids, and firmware inspection or extraction results missing analysis_timeout_ms. #11595.
Full contribution record: 1589 commits and 1383 merged PRs.
|
How to Install
The recommended approach is to install REA through its guided setup utility.
First, ensure that a supported Node.js runtime and npm are installed. Then run:
npx rea-agents@latest setup
Choose the AI agents you want to configure, review the proposed changes, and approve them. Setup configures the MCP connection and installs the corresponding workflow instructions.
Restart the configured AI client after setup so it can load the new MCP server.
To use REA as a regular command-line application, install it globally:
npm install --global rea-agents
Then verify the installation:
rea doctor --json
For native binary analysis, configure Hopper or an existing Ghidra installation according to the official documentation. Static JavaScript and Electron analysis can be used without installing either tool.
To update an existing installation, follow the update instructions for the installation method you used. If you use the npx workflow, refresh the agent configuration with:
npx rea-agents@latest setup
Review the proposed changes and restart the relevant client when its MCP registration changes.
Final Verdict
REA is a compelling open-source toolkit for developers who want to combine reverse engineering with AI-assisted software development. Its biggest advantage is the way it connects analysis tools, structured evidence, and MCP-compatible agents into a single investigation workflow.
Support for native binaries, JavaScript applications, and Electron packages gives it a broad range of uses, from understanding undocumented features to investigating legacy software and building compatible implementations. The CLI and evidence-oriented results also make it useful beyond interactive AI sessions.
Its main limitation is that REA depends on external analysis engines for many native workflows, and its capabilities vary by operating system and provider. It also cannot recover original source code automatically or guarantee that an implementation recreated from analysis will behave identically to the original.
For developers working with unfamiliar applications, REA is worth exploring, particularly if they already use an MCP-compatible coding agent. It is best viewed as a bridge between reverse engineering tools and AI development workflows rather than a replacement for established disassemblers or the expertise required to interpret their results.
Post a Comment/Report Broken Link: