An agent that takes software apart, then puts it back together.

Not a demo that describes the file.

Most AI reverse-engineering tools stop at a summary. ReverseAI closes the loop: it changes the artifact, tests it, and shows the evidence.

It chooses the smallest change that fits.

A resource edit beats a byte patch, which beats a component swap, which beats a rebuild. The engine scores the real analysis, explains why, estimates the blast radius, and asks instead of guessing when the request is ambiguous. Then it plans, implements on a copy, and proves the result.

choose_modification_strategy -> plan_and_modify -> apply_* -> verify_modification -> signed report

Direct, Reconstruction, and Modernisation modes. "Change X, preserve everything else" runs regression cases over the rest of the program.

It will not hand you an unverified file.

The agent declares a behavioral expectation, runs the original and changed artifacts in the sandbox, and compares real outputs. If the test fails, the file stays in the workspace, the delivery is blocked, and you get the reason. A bounded repair loop can ask for another candidate. The signed report proves exactly what was tested.

verify_modification  -> exit, stdout, stderr, output files
differential_test    -> corpus: matches, deltas, regressions
GET /jobs/<id>/report(.html) -> signed JSON / self-contained HTML

The test outlives the chat.

Capture how the original behaves once, then every later change has to keep that behavior. The signed report includes a replay recipe, so a teammate can reproduce the exact verification without a model or an API key. If a case regresses, delivery is blocked.

capture_behavior_corpus -> corpora/<sha256>.json
plan_and_modify use_corpus -> differential regression
reverseai verify --original ... --modified ... --cases ... --report ...
reverseai report verify report.json

Workspace checkpoints make every write reversible. A bounded diff shows what changed before you restore. Path traversal, symlinks, and device nodes are refused.

It asks the question nobody assigned.

ReverseAI builds a world model of the system, then looks for hidden features, undocumented interfaces, fragile dependencies, missing tests, and capabilities that are one change away. Every lead carries evidence, impact, effort, risk, and a falsifiable next step. Nothing is changed because a story sounds convincing.

build_world_model -> discover_opportunities -> form_hypotheses
                    -> simulate_change -> experiment -> verify

A digital twin predicts what it can model and names what must be tested live. A causal claim needs an explicit mechanism. An experiment error is not evidence.

Build the boundary before the authority.

ReverseAI now has a desktop-session broker, a loopback listener, a read-only Telegram channel, a payment intent ledger, an MCP client, signed sandboxed hooks, a verified-trace training pipeline, and a dry-run deployment controller. None of them is enabled by default. The desktop has no input backend, the payment provider is a mock, the Telegram channel has no shell, and deployment has no transport until an operator supplies one.

reverseai surfaces --json
capability opt-in + scoped approval + audit
desktop: allowlist, no input injection
payments: idempotent, mock provider, no card data
self-training: verified traces only, holdout gate
self-deployment: dry run, approval, rollback

The open technical items also moved: differential fuzzing, PE debug/TLS/resources, Mach-O dylibs, Landlock/cgroup/QEMU surfaces, mission resume, and per-token quota.

A passing test is not automatically a strong test.

ReverseAI now mutates the candidate and checks whether the corpus can detect the breakage. It reports killed and surviving mutants, names weak cases, and keeps the delivery gate separate from the measurement. Every tool is called with empty arguments in the contract suite, every CLI command is parsed, every API route is checked for auth and path boundaries, and the sandbox is tested against network, host-file, environment, and timeout escapes.

assess_test_strength -> killed / survived / weak cases
bench --split dev|holdout -> verified, regression, repair,
                             false-verification, refusal, cost, time
reverseai audit -> version, deps, assets, tool metadata, secrets
reverseai repo / xrefs -> repository map and direct call graph

Not just answers. Surfaces you can use.

ReverseAI can create the interaction the work needs: a clarification question with real options, a form, a comparison table, a chart, a control-flow graph, a before/after diff, an approval card, a file drop zone, or a small sandboxed custom view. Every choice has an "Other" escape hatch. The surface answer becomes structured state, and the agent continues from it.

create_surface -> question / form / table / chart / graph / diff
               -> approval / file drop / custom view
               -> structured response -> continue the same conversation

Generated views are validated, rendered from allowlisted components, and custom views run in an opaque-origin iframe with no network.

Plan. Act. Observe. Prove.

Built for a phone, honest on a desktop.

One engine, many ideas.

The planning and tool discipline of coding agents, the memory, research, routines, and durable turns of personal agents, the long-document OCR of Unlimited-OCR, and the interaction language of prompt-kit. Mapped honestly, with deferred features named.

Read the feature map · Read the power map · Read the intelligence roadmap · Read the dangerous-surface ledger

One command locally. One click on Render.

git clone https://github.com/maykano-dev/Reverse-AI.git
cd Reverse-AI
export DEEPSEEK_API_KEY=sk-...
export REVERSEAI_AUTH_TOKEN=choose-a-token
python3 -m reverseai serve
# open http://127.0.0.1:8077