> ## Content Index
> Fetch the complete content index at: https://www.tao.media/llms.txt
> Use this file to discover other available public pages before exploring further.

# What Is REA? Reverse Engineer Anything and Perplexity Computer’s /reverse-engineer Skill Explained
- URL: https://www.tao.media/what-is-rea-reverse-engineer-anything-and-perplexity-computers-reverse-engineer-skill-explained/
- Published: 2026-10-21T14:47:55.000Z
- Updated: 2026-10-21T14:47:56.000Z
- Description: REA is an open-source toolkit that lets AI agents inspect how software works without its source code, and Perplexity Computer now offers it as a built-in skill.
- Author: Tristan Hillerich
- Tags: Perplexity, AI, Educational

REA, Reverse engineer anything, means studying a finished piece of software to understand how it works. Instead of reading the original source code, the analyst inspects the program itself, its files, its behavior, its network activity, or its compiled instructions.

REA is an open-source reverse-engineering toolkit that lets AI coding agents inspect how software works without access to its source code, explain what they found, and help rebuild a feature from evidence. On Oct. 16, 2026, Perplexity added REA to Perplexity Computer as a built-in skill that users can invoke with `/reverse-engineer`, extending the company’s earlier Computer launch.

In this context, REA refers to the [open-source project by developer morluto](https://github.com/morluto/rea?ref=tao.media), which describes itself as “one MCP for reverse engineering across binaries, applications, and runtime behavior.” The project is MIT-licensed and connects AI coding agents to tools that can inspect software artifacts, runtime behavior, websites, apps, binaries, and other targets.

A simple example is a calculator. If a user asks why Windows Calculator returns 220 for `200 + 10%`, REA can help inspect the application’s behavior and recover the rule: after addition, 10% means 10% of the first number, so the calculation becomes `200 + 20`. REA’s public examples also show a browser dinosaur game where the agent recovers the rule that the game speed starts at 6 and increases over time until it reaches 13.

REA helps non-developers answer “how does this feature work?” by examining the software itself rather than guessing from the interface.

## How Does REA Work?

REA works by giving an AI coding agent controlled access to reverse-engineering tools. The agent still performs the reasoning and writing, but REA provides the inspection layer that can gather evidence from the target.

### REA Connects To Agents Through MCP

REA connects through MCP, short for [Model Context Protocol](https://modelcontextprotocol.io/?ref=tao.media), a standard for connecting AI agents to external tools and data sources. MCP is the bridge between the agent and the reverse-engineering capabilities.

REA is not a standalone chatbot but infrastructure for agents. Once installed, a compatible coding agent can call REA tools during a task, inspect a target, and incorporate the findings into its plan.

### REA Inspects, Traces, And Returns Evidence

REA can inspect static files, runtime behavior, browser pages, binaries, network captures, and other software artifacts depending on the target and local setup. Its GitHub README says results include “the evidence and limitations behind each conclusion,” since reverse engineering often involves inference rather than perfect certainty.

A useful REA workflow usually looks like this:

1. The user asks a question about a feature or behavior.
2. The agent asks REA to inspect the relevant software target.
3. REA returns code, references, runtime observations, or other evidence.
4. The agent explains the feature and, if requested, implements a reconstruction.
5. The agent tests the result against the observed behavior.

### Self-Hosted REA Runs Analysis Locally

For self-hosted REA, the project says analysis runs locally, though the AI model provider may still receive prompts, summaries, tool outputs, or other information the agent sends during the task. Local analysis does not automatically mean the full workflow is private from every third-party service.

## What Can REA Analyze?

REA is broad, but its support varies by target type and environment. The project’s README lists many target categories, including native binaries, JavaScript and Electron apps, websites, .NET assemblies, Android APKs, firmware, packet captures, WebAssembly artifacts, EVM bytecode, SQLite databases, and more.

The main target types break down as follows:

| Target Type                  | What REA Can Help Inspect                                                                        |
| ---------------------------- | ------------------------------------------------------------------------------------------------ |
| Native Binaries              | Assembly, pseudocode, strings, symbols, calls, and references when supported tools are available |
| JavaScript And Electron Apps | Modules, imports, routes, source maps, IPC, and native add-on relationships                      |
| Websites                     | Page structure, scripts, network observations, and screenshots                                   |
| .NET Assemblies              | Metadata, CIL instructions, dependencies, and build comparisons                                  |
| Android APKs                 | Manifests, classes, decompiled methods, and references                                           |
| Firmware And Captures        | Extracted regions, packet summaries, network traces, and decoded fields                          |
| WASM And EVM Bytecode        | Imports, exports, selectors, byte offsets, inferred arguments, and mutability clues              |

Some workflows require external tools. Native analysis can use Hopper, Ghidra, or IDA, while Android inspection may require JADX and a JDK. The self-hosted project also requires Node.js 22.19+, 24.11+, or 26+.

REA’s full target list applies to self-hosted REA. Perplexity has not documented exactly which target types its Computer integration supports.

## What Is REA In Perplexity Computer?

REA in Perplexity Computer is a built-in reverse-engineering skill for Computer tasks. REA is now available in Computer, and users can ask Computer to inspect how an app works without source code, then build a working version.

Users start a Computer task with `/reverse-engineer`.

Perplexity framed the feature around three practical jobs: recovering a feature, building a reconstruction, and testing the result. That makes REA a natural fit for agentic software work, where the user wants a working implementation rather than a static report.

Perplexity also announced limited-time demo apps around the launch, including examples modeled around design editing, spreadsheets, photo editing, contract review, and audio editing. Those should be treated as Perplexity-created demos rather than official versions of the products they resemble.

For readers who want more information on Perplexity’s launch, read below:

[Perplexity Computer Adds REA to Inspect and Rebuild Apps Without Source CodeThe new skill brings an open-source reverse-engineering toolkit into Computer, with a temporary credit allowance for users to try it.![](https://storage.ghost.io/c/78/0b/780ba906-b1a7-4bf0-873c-bdd5c32e5331/content/images/icon/Group-1321319358-76ecdf07-3bf0-41fa-8fb1-2a289b054e54.png)Intelligence![](https://storage.ghost.io/c/78/0b/780ba906-b1a7-4bf0-873c-bdd5c32e5331/content/images/2026/10/gpt-output-1-17.png)](https://www.tao.media/perplexity-computer-adds-rea-to-inspect-and-rebuild-apps-without-source-code/)

## Is REA In Perplexity Free?

Perplexity said `/reverse-engineer` tasks are free through Oct. 31, 2026, up to 10,000 credits per user or account. After that period, standard Perplexity Computer credits apply.

As of October 2026, Perplexity’s Help Center says 100 credits equals $1, though it also warns that credit pricing, task ranges, monthly allowances, and included usage may change. The same Help Center page says Computer credits are available to Pro and Max subscribers, including Enterprise Pro and Enterprise Max, with plan-specific allowances.

Plan eligibility for the REA promotion was not clearly specified in Perplexity’s public launch wording. If you are trying REA inside Computer, the safest approach is to check the in-product credit and usage screen before starting a large task.

## How To Try REA

There are two main ways to try REA: through Perplexity Computer or by installing the self-hosted REA agent tooling.

| Option              | Best For                                               | How It Works                                                              | Main Caveat                                                                            |
| ------------------- | ------------------------------------------------------ | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| Perplexity Computer | Users who want the fastest path with minimal setup     | Start a Computer task with /reverse-engineer                              | Perplexity has not documented every supported target type or where all analysis runs   |
| Self-Hosted REA     | Developers who want local tooling inside coding agents | Run npx rea-agents@latest setup, approve the plan, then restart the agent | Requires Node.js 22.19+, 24.11+, or 26+, plus target-specific tools for some workflows |

The Computer route is simpler and suits Perplexity users who want to give an agent a task and receive a working result.

The self-hosted route is more flexible. REA’s README says setup supports coding-agent environments such as Claude Code, Codex, Cursor, Gemini CLI, Grok Build, and others. It is the better path for developers who want direct control over the local environment, supported tools, target files, and workflow boundaries.

## REA, SPACE, And Perplexity’s Agent Stack

REA is one piece of a broader shift toward agents that can inspect, build, and test software inside controlled environments.

Perplexity’s [SPACE sandbox](https://www.tao.media/perplexity-releases-firecracker-based-space-agent-sandbox-under-apache-2-0/) gives Computer tasks isolated environments for agent work. REA plays a different role, providing the reverse-engineering and investigation tools that help an agent understand a target. In a typical agent stack, the sandbox provides containment while a tool like REA provides specialized capability.

A general-purpose agent can browse and code, but a reverse-engineering agent needs structured ways to inspect compiled programs, runtime behavior, files, and evidence.

## Conclusion

REA gives AI agents a practical way to investigate software behavior from evidence rather than speculation.

For developers, REA can help answer narrow questions about how a feature works, why an application behaves a certain way, or how to rebuild a compatible implementation. For Perplexity users, the `/reverse-engineer` skill makes that workflow easier to access inside Computer. For everyone else, reverse engineering remains bounded by authorization, licenses, and law, even when an AI agent makes the workflow faster.

REA is best understood as a specialized tool for agentic software analysis. Used responsibly, it can make software behavior easier to study, explain, and reproduce. Used carelessly, it can cross legal, ethical, or security lines quickly.

## FAQs

### What Is REA?

REA, or Reverse Engineer Anything, is an open-source reverse-engineering toolkit that gives AI coding agents tools to inspect how software works without its source code.

### What Does REA Stand For?

REA stands for Reverse Engineer Anything. In AI tooling, it usually refers to morluto’s open-source reverse-engineering project, not real estate or other uses of the acronym.

### Who Made REA?

REA was made by developer morluto and is available on [GitHub](https://github.com/morluto/rea?ref=tao.media). Perplexity integrated REA into Computer, but it did not create the original project.

### How Do I Use REA In Perplexity?

To use REA in Perplexity Computer, start a Computer task with `/reverse-engineer` and describe the software behavior or feature you want the agent to inspect.

### Is REA In Perplexity Free?

Perplexity said `/reverse-engineer` tasks are free through Oct. 31, 2026, up to 10,000 credits per user or account. After that, standard Perplexity Computer credits apply.

### Do I Need Perplexity To Use REA?

No. REA can also be installed for supported coding agents with `npx rea-agents@latest setup`, provided the local environment meets the project’s requirements.

### Does REA Upload My App?

Self-hosted REA says analysis runs locally, but the AI model provider may still receive results or context through the connected agent. Perplexity has not publicly documented where every part of Computer’s REA analysis runs.

### Is Reverse Engineering With REA Legal?

It depends on authorization, jurisdiction, software licenses, and intended use. REA’s own disclaimer limits responsible use to lawful analysis, such as security research, education, interoperability, preservation, and software you own or are authorized to examine.

### What Is MCP?

MCP stands for Model Context Protocol. It is a standard that lets AI agents connect to external tools and data sources, which is how REA exposes reverse-engineering capabilities to supported agents.