REx@Skill: Agentic Binary Reverse Engineering & Vulnerability Discovery in Claude Code

Security researcher Norbert Tihanyi, PhD, has released REx@Skill, an open-source agent skill designed for Anthropic's Claude Code environment to autonomously perform binary reverse engineering and vulnerability discovery. Moving beyond conventional single-prompt queries that rely on superficial code pattern matching, the project deploys seven specialized subagents coordinating static deconstruction, dynamic emulation, fuzzing, and constraint solving to systematically discover and analyze defects in compiled binaries.

Image source: @TihanyiNorbert on X

Seven Specialized Subagents Architecture

Applying large language models to binary security analysis has historically suffered from critical architectural bottlenecks. Feeding sprawling disassembly dumps into a single prompt window often triggers severe context saturation and hallucinations, causing models to overlook intricate execution pathways or fabricate non-existent vulnerabilities.

REx@Skill tackles these limitations by introducing a modular architecture powered by seven specialized subagents. Rather than treating reverse engineering as a monolithic task, the skill partitions the workflow into focused operational domains: static reconnaissance of binary metadata and exported symbols, execution path tracking across control-flow branches, vulnerability hypothesis formulation targeting suspect memory access patterns, and empirical validation through dynamic instrumentation.

Crucially, the seven subagents coordinate within a unified workflow rather than operating as disconnected prompt queries. Findings from static analysis, execution traces, crash telemetry, and constraint equations are passed seamlessly across agents, maintaining complete analytical context across every phase of the investigation. This integrated multi-agent pipeline ensures that findings from one stage directly inform and guide the next.

Integrated Toolchain: Ghidra, QEMU, AFL++, and Z3 in One Pipeline

The technical backbone of REx@Skill is its native integration of four foundational reverse engineering and security research toolchains into a single orchestrated workflow.

• Ghidra: Drives static decompilation and structural deconstruction. It parses PE and ELF binary structures, reconstructs call graphs, and extracts high-level decompiled pseudocode to map the initial attack surface.
• QEMU (qemu-user): Provides dynamic emulation and cross-architecture execution. It monitors register state transitions, dynamic memory allocations, and runtime branching behaviors under controlled conditions.
• AFL++ (American Fuzzy Lop++): Operates as a coverage-guided fuzzing engine. Targeting input entry points highlighted during static inspection, AFL++ injects mutated test cases to provoke unexpected memory corruption or application crashes.
• Z3 SMT Solver: Serves as a constraint solver and symbolic execution engine. It mathematically calculates the exact input constraints required to reach guarded code paths or trigger identified vulnerability conditions, proving theoretical exploitability.

These four foundational toolchains work in tight concert to create a closed-loop analysis pipeline. When static analysis with Ghidra flags potential vulnerability indicators or unverified execution paths, the workflow can initialize dynamic emulation in QEMU, deploy AFL++ to discover crashing inputs, and leverage Z3 to solve complex branch constraints and verify reachability, completing an end-to-end automated security audit loop.

Target Workflows, Operational Prerequisites, and Sandbox Requirements

REx@Skill is built for security researchers, reverse engineers, vulnerability analysts, and Capture The Flag (CTF) competitors looking to accelerate deep binary auditing through agentic workflows. Because it is packaged natively as a Claude Code agent skill, analysts can invoke and oversee autonomous reversing routines directly within their standard terminal workflows using natural language directives.

However, deploying REx@Skill effectively requires careful attention to critical operational prerequisites and system boundaries.

First, strict execution sandboxing is essential. Because REx@Skill conducts dynamic emulation, instrumentation, and coverage fuzzing on live executable code, analyzing untrusted or potentially malicious binaries must take place within an isolated virtual machine or dedicated sandbox container to safeguard the host operating system.

Second, local toolchain dependencies must be configured beforehand. The framework relies on external native binaries, including Ghidra with its requisite Java Development Kit (JDK) runtime, QEMU, AFL++, Z3, and Python analysis libraries. These components must be installed and properly configured in the host or container environment prior to invoking the skill.

Third, computational and API resource demands should be budgeted carefully. Z3 constraint solving and AFL++ fuzzing campaigns consume substantial CPU cycles and memory. Additionally, the intensive reasoning exchanges and frequent coordination among seven autonomous subagents can rapidly consume Claude Code API tokens during complex binary engagements.

Sources

• GitHub Repository: tihanyin/REx-skill
• Dr. Norbert Tihanyi on X (@TihanyiNorbert): REx@Skill Announcement