Agent-assisted reverse engineering, verified byte for byte.

relumea puts an agent on a stripped executable. Read-only calls run at once; the 143 that write stop and wait for you. Recovered C is recompiled with the original toolchain and diffed against your binary, so a match is proven rather than scored.

See the run How it proves a match

05rename_functiondestructiveillustrativerun paused · 8 calls

{ "function_id": 412, "name": "decode_config", "source": "ai" }  →  rename_function

Nothing is written while it waits.

Runs on stripped binaries, no source and no symbols.267 registry tools124 read-only143 gated272 compilers5,779 tests

A match is a diff, not a score

The recovered C goes back through the compiler that produced the target. The bytes are compared instruction by instruction, and the verdict names what still differs.

Recovered source

cfg/decode.c

unsigned int decode_config(unsigned char *buf,
                           unsigned int len, unsigned int key)
{
    unsigned int i, sum = 0;
    for (i = 0; i < len; i++) {
        buf[i] ^= (unsigned char)(key >> ((i & 3) * 8));
        sum += buf[i];
    }
    return sum ^ 0x5A5A;
}

Original bytes

mingw-14.2.0-win32

00401a20  56       push     esi
00401a21  31c0     xor      eax, eax
00401a23  31d2     xor      edx, edx
00401a25  53       push     ebx
00401a26  8b5c240c mov      ebx, dword ptr [esp + 0xc]
00401a2a  3b542410 cmp      edx, dword ptr [esp + 0x10]
00401a2e  741e     je       0x00401a4e
00401a30  89d1     mov      ecx, edx
00401a32  8b742414 mov      esi, dword ptr [esp + 0x14]
00401a36  83e103   and      ecx, 3
00401a39  c1e103   shl      ecx, 3
00401a3c  d3ee     shr      esi, cl
00401a3e  89f1     mov      ecx, esi
00401a40  320c13   xor      cl, byte ptr [ebx + edx]
00401a43  880c13   mov      byte ptr [ebx + edx], cl
00401a46  0fb6c9   movzx    ecx, cl
00401a49  42       inc      edx
00401a4a  01c8     add      eax, ecx
00401a4c  ebdc     jmp      0x00401a2a
00401a4e  355a5a0000 xor      eax, 0x5a5a
00401a53  5b       pop      ebx
00401a54  5e       pop      esi
00401a55  c3       ret

decode_config0x00401a2054 / 54 bytes identicalverdict EXACT

The sample, one screen

412 functions in address order. Filled means the recovered C recompiled to the same bytes. Stub and unattempted cells stay on the page: a miss is a miss.

91.3%

covered · 351 of 412 functions

EXACT198
RELOC141
PROVEN12
NEAR2
STUB3
not attempted56

Section	Address	Functions	Virtual size	Access	Holds
.text	0x00401000	412	98,304	RX	code. Every function on this page.
.rdata	0x00419000	0	32,768	R	read-only data. Scanner output, digests, technique tables.
.data	0x00421000	0	24,576	RW	writable state. Names, types and signatures you decide.
.reloc	0x00427000	0	8,192	R	base relocations, resolved at link time.

Eight calls, one of them gated

The registry marks every tool. Read-only calls are dispatched the moment the agent asks. The 143 that write pause the run and wait on a person.

TaskTriage updater_svc.exe. Name the persistence path and the C2 send. Prove the decoder.

01get_pe_info{ "binary_id": 1 }PE · x86_32 · 4 sections · entry 0x00401a20read-only
02get_imports · get_capabilities · get_protocols_scan{ "binary_id": 1 }106 imports · networking, persistence, process-injectionread-only
03get_function_triage{ "binary_id": 1 }5 ATT&CK techniques · software type · threat scoreread-only
04get_decompilation{ "function_id": 412 }decode_config · 54 B · Cread-only
05rename_function{ "function_id": 412, "name": "decode_config", "source": "ai" }journal_action 31 · name_history row writtengated
06get_matches{ "binary_id": 1, "min_similarity": 70 }47 candidate rows · 12 EXACTread-only
07rebrew testsrc/cfg/decode.c54 / 54 bytes identical · EXACTread-only
08get_remediation{ "binary_id": 1 }YARA rule · Snort 2 set · STIX 2.1 bundleread-only

Approve. the write lands, journaled, revertible

Reject. the run does not fail; it is told no and adapts

What the sample is

Nothing here needed source, symbols or a debug build. Header, imports and strings are the whole evidence base, and the scans work on the bytes as shipped.

Format / arch: PE · x86_32
Image base: 0x00400000
Size: 196,608 B
Sections: .text .rdata .data .reloc
Functions: 412
Source files: 94
sha256: a7ed6974787de73373b3ca48d32faaf6611b6745ed362e85599282d68c1489d4

Import table

106 entries across 5 libraries. The findings below cite these rows as their evidence.

KERNEL32.dll64
ADVAPI32.dll18
WS2_32.dll12
WINHTTP.dll9
USER32.dll3

One registry, four surfaces, every step journalled

The same 267 tools back the web workspace, the CLI, the MCP server and the REST API. Every write records the value it replaced, and every row reverts on its own.

Agentic analysis: Identity, imports, capabilities and ATT&CK findings, run in order, then a written summary.; run_conversation_agent · 267 MCP tools
Decompilation: Engine decompilers produce the C. An optional model proposes names, inline comments and types, all editable and revertible.; rebrew decompile · ai_artifacts
Function matching: Match against your corpus, diff candidates side by side, transfer names and signatures, then verify the result byte for byte.; resembl · rebrew test
Automated remediation: A YARA rule, Snort rules per indicator, a STIX 2.1 bundle, an SBOM and a PDF report.; remediation · export_sbom · report-pdf

No source. No symbols. No debug info.: A stripped PE is the normal input, and the scans and the model work on the bytes as shipped.
The agent asks before it writes.: 124 tools are read-only and run on request. The other 143 carry MCP’s destructiveHint, so the run pauses on the call itself and waits for a person.
A match is decided by a compiler.: Similarity scores are a starting point. This is the verdict.

Scan families

19 families make up the 267-tool registry, and every family ships its tools on all four surfaces.

fingerprint
pe-info
filetype
capabilities
protocols
behavior
hardening
secrets
security-scan
threat
remediation
crypto-scan
structs
unstrip
match
lineage
related
composition
benchmark

Fits the toolchain you already run

Renames and signatures leave as runnable scripts for the disassembler you have open. relumea does the analysis; your tools stay where they are.

Ghidrarenames and signatures exported as a runnable Python script

IDA Prothe same export as an IDA script

Binary Ninjathe same export as a rename document

MCP server267 tools for agent clients, 124 read-only

REST APIthe HTTP surface the web UI runs on

CLIreportal, full parity with both

SBOMCycloneDX, SPDX or CSV per artifact

DetectionYARA, Snort 2 and STIX 2.1 exports

Six states, and nothing is hidden

rebrew test writes the verdict. Neither an operator nor the model assigns it, which is why a stub stays a stub on the page.

EXACT: Recompiled bytes identical to the original.
RELOC: Identical except linker-filled addresses.
PROVEN: Not byte-identical; semantic equivalence proven with angr + Z3.
NEAR: Close. The diff names the register, flag or reorder that is left.
STUB: Control flow still diverges. Work remains.
unattempted: Not tried yet. Shown so the coverage cannot flatter itself.

Findings, with the import that fired

Import table and strings only. Every finding names the evidence behind it and how strong that evidence is.

capabilitiesnetworkingWinHttpSendRequesthigh
capabilitiespersistenceRegSetValueExAhigh
capabilitiesprocess-injectionCreateRemoteThreadhigh
hardeninganti-debug-apiIsDebuggerPresenthigh
protocolshttpWinHttpOpenhigh
threatT1071 Application Layer ProtocolWinHttp* + WS2_32high
threatT1547 Boot or Logon AutostartRegSetValueExA on Run key pathmedium
threatT1055 Process InjectionCreateRemoteThreadhigh

Functions, in address order

A sample of the rows the ledger holds. Status is written by the verifier, and the source path is the recovered file the match was proven against.

Address	Name	Size	Verdict	Source
0x00401020	svc_Main	1842	STUB	svc/main.c
0x00401840	cfg_LoadEncrypted	412	RELOC	cfg/load.c
0x00401a20	decode_config	54	EXACT	cfg/decode.c
0x00401c80	net_OpenSession	288	RELOC	net/session.c
0x00402210	http_SendBeacon	640	NEAR	net/beacon.c
0x00402a90	reg_PersistRunKey	196	EXACT	persist/runkey.c
0x00403100	inj_WriteRemote	720	PROVEN	inj/remote.c
0x004038c0	anti_IsDebugged	48	EXACT	anti/debug.c
0x00403b40	str_WideToUtf8	92	EXACT	util/wide.c
0x00404100	buf_Grow	128	RELOC	util/buf.c
0x00404880	crc32_update	176	EXACT	util/crc32.c
0x00405120	svc_Install	384	RELOC	svc/install.c

Where it gets used

First-pass triage is the common case, but the same run answers the questions research, assurance and firmware work all start with.

Malware triage: capabilities, ATT&CK mapping, threat score, family detection from your own reference samples
Vulnerability research: security findings ranked by reachability, attack surface mapped from stored scans
Third-party assurance: library identification and an SBOM for software you did not build
Supply chain: CycloneDX or SPDX per artifact, repeated across a fleet
Legacy modernization: recompile an old binary and byte-match it to prove the source is the original
Firmware: carve and scan device firmware images

Questions

The ones a sceptical reader asks first.

Is this just an LLM?

No. Capabilities, protocols, hardening, secrets, ATT&CK mapping, matching and the byte comparison are deterministic scans and a compiler. The model is optional and reads decompilation already stored.

Where do my binaries go?

Into your workspace, content-addressed and scoped to you. AI features are opt-in; the model sees stored artifacts, not the raw sample.

How do you handle packed malware?

Filetype detection names the packer from section names, entry-point bytes, constants and entropy, and reportal unpacks LZEXE and UPX itself. A packer that rewrites its own stub is reported as unidentified rather than guessed at.

Do you support firmware?

Yes. Firmware extraction and scanning is a separate path from PE analysis.

Can you match across architectures and file formats?

The platform and architecture scope is a coarse filter derived from the stored fingerprint, not a guarantee. Every payload says so.

What can I export?

YARA, Snort 2, STIX 2.1, an SBOM as CycloneDX, SPDX or CSV, a PDF report, C headers for recovered types and signatures, and rename scripts for Ghidra, IDA Pro and Binary Ninja.

Do you integrate with Ghidra, IDA and Binary Ninja?

As exports rather than plugins: renames and signatures leave as runnable scripts for those three tools. Agents reach the same store over MCP, and everything else over the REST API or the CLI.

Can I undo what the agent wrote?

Yes. Every mutating call returns a journal action, so revert_journal_entry undoes it later, from another process.

Stop scoring it. Start proving it.

One email when the hosted workspace opens. Bring a stripped binary and a corpus; the engine behind this page already runs.

The waitlist is not open yet. It starts collecting at the first release announcement.