2akouwu/reverify

Reverify

Stop your AI from making things up.

It proposes; deterministic tools check every claim against ground truth, and only what's verified counts.

AI is confident and often wrong: it invents an API, a struct field, an offset, or what a

function does, and says it like fact. Reverify makes a deterministic tool the judge — the model

proposes a claim, the tool checks it against the actual artifact, and it comes back **VERIFIED /

REFUTED with evidence**. The model never gets to assert a fact on its own.

Two things it does today:

truth, not trusted, and only what survives becomes a fact (reverify verify, or the MCP

server your agent already talks to).

hands the session off to a file and starts a fresh one, so long tasks don't drift or need

/clear. Works in Claude Code, Codex, Gemini CLI and OpenCode.

The hardest place to prove the first point is binary reverse engineering, where hallucination is

worst — so that's where the numbers come from. On 71 real Windows system files the AI's textbook

answer was wrong 97% of the time; reverify caught every one and **never accepted a wrong

claim** (0 of 71; the same gate runs in CI on Linux and macOS every push, and an independent

aarch64 run found the same) ([EXAMPLE.md](EXAMPLE.md), [BENCHMARK.md](BENCHMARK.md);

python benchmarks/prologue_prior.py).

## The problem

Language models are great at reading code and unreliable at reverse engineering. Ask a

model to reconstruct a struct or an algorithm from a binary and it will confidently invent

offsets, sizes, and behavior. In binary analysis this hallucination problem is far worse

than in source code, and "did the model just make that up?" is the single biggest blocker

to using AI for real RE.

## What Reverify does

Reverify pairs a language model with a deterministic, pure-Python RE toolkit and makes the

toolkit the judge. The model proposes; the tools verify. A hypothesis about a structure or an

algorithm is only reported once it has been checked against the actual bytes — disassembled,

pattern-matched, or executed in the emulator — so the output is grounded in the binary instead

of the model's imagination.

scanning, CPU emulation, Protobuf/TLV dissection, Frida hook generation. Pure Python out of

the box; installs clean with no Ghidra.

itself in place to capstone (disassembly), unicorn (real CPU emulation), lief

(PE/ELF/Mach-O) and Z3 (proofs); pip install "reverify[angr]" adds angr for

function boundaries, the call graph and cross-references. Not installed? It falls back to

the pure-Python core. reverify backends shows what's active.

candidate implementation and a reference over shared inputs and checks they agree, so an AI's

rewrite or refactor is tested, not trusted — a refutation comes back with the input and both

outputs. The same rigour, aimed at ordinary source code.

the tools directly; also a plain CLI.

Reverify is for authorized reverse engineering — malware analysis, CTF, interoperability

research, and software you own or are permitted to analyze. See [SECURITY.md](SECURITY.md).

## Quick start

# Install the CLI + MCP server from PyPI:
pip install reverify        # pure-Python core; or "reverify[full]" for capstone+unicorn+lief
reverify auto sample.bin --json

# Or run straight from a checkout — pure standard library, nothing to install:
python reverify/cli.py auto sample.bin --json
python reverify/cli.py parse-pe sample.exe --json
python reverify/cli.py disasm 90505831C0C3 --arch x86_64

## The verification loop

This is what the name is about. A claim is any hypothesis about the binary; the

deterministic tools are the judge and hand back VERIFIED, REFUTED, or

INCONCLUSIVE together with the bytes they actually observed:

reverify verify sample.bin --claim '{
  "kind": "instructions", "offset": 4096,
  "mnemonics": ["push", "mov", "sub"], "note": "function prologue"
}'

# Check a reconstructed routine actually computes what the model claimed:
reverify verify - --claim '{
  "kind": "emulate_result", "code": "b805000000b90300000001c8c3",
  "arch": "x86", "expect_registers": {"eax": 8}
}'

Claims can be batched from a JSON file (--claims-file claims.json); the CLI exits