Every major RE tool has a powerful but incompatible scripting API. Analysts must learn each one. AI agents can't easily drive them without tool-specific glue code. There is no common interface -- until now.

idasql, ghidrasql, and bnsql expose the internals of IDA Pro, Ghidra, and Binary Ninja as live SQL virtual tables -- 30+ tables covering functions, cross-references, strings, types, disassembly, and decompilation. These tables are not read-only exports: analysts and AI agents can rename functions, annotate variables, apply types, set comments, and manage bookmarks through standard SQL INSERT/UPDATE/DELETE statements. Changes are reflected live in the RE tool.

Because SQL is the one query language every LLM already speaks fluently, this turns any AI coding agent into a reverse engineering partner -- no IDAPython, no Ghidra scripts, no tool-specific plugins required.

This talk covers:

One language, three tools. The same SQL query runs against IDA, Ghidra, and Binary Ninja. We show how SELECT name, size FROM funcs ORDER BY size DESC LIMIT 10 returns near-identical results across all three tools for the same binary -- and where the interesting differences are.

The decompiler as a database. Decompiled pseudocode, AST nodes, local variables, and call arguments are all queryable tables. We demonstrate queries like "find all functions that call malloc without checking the return value" expressed as pure SQL joins across decompiler and cross-reference tables.

Read-write reverse engineering. These tools don't just query -- they write back. We walk through a complete annotation workflow: the agent decompiles a function, renames variables to meaningful names, applies recovered struct types, adds comments explaining the logic, and bookmarks points of interest. All through SQL, all persisted to the database.

AI-driven analysis sessions. Live demonstration of "vibe reversing": an analyst describes what they want in natural language, and the AI agent autonomously drives the RE tool. We show single-binary triage from scratch, cross-tool comparison of the same binary in IDA and Ghidra side by side, and multi-database campaigns where the agent cross-references findings across related malware samples.

Cross-tool annotation transfer. An agent reads the annotations, variable names, and type definitions from one tool's database and applies them in another -- bridging the gap between analysts who use different RE tools on the same project.

Autonomous type recovery. The agent reads decompiler output, identifies pointer arithmetic patterns and field access offsets, and constructs struct, union, and enum definitions through SQL -- creating types, adding members, and applying them to variables and function signatures. We show how an agent recovers a multi-level struct hierarchy from raw decompiler output and applies it across all functions that reference it.

Source recovery from binaries. We show a complete end-to-end case: starting from a stripped binary, the agent iteratively decompiles, annotates, recovers types and structures, and produces compilable source code -- all driven by natural conversation. We also demonstrate guided recovery where the agent is given partial source code alongside a binary and reconstructs the missing pieces by correlating decompiler output against the known code.

Malware analysis in practice. We walk through a real-world C2 malware sample with layered complexity: an outer loader, an inner DLL, and embedded plugin blobs, each requiring extraction and independent analysis. The agent autonomously identifies the layers, extracts the embedded components, opens them in separate database sessions, cross-references between them, and produces a complete annotated teardown of the malware's architecture.

Multi-database diffing. With multiple databases open simultaneously, the agent compares two versions of the same binary -- identifying new functions, changed code paths, and patched vulnerabilities. This extends naturally to malware variant analysis, patch diffing, and firmware update comparison.

Practical limits and honest lessons. Where LLMs excel at RE tasks (pattern matching, bulk annotation, cross-referencing, structure recovery), where they still struggle (complex control flow, novel obfuscation, very large functions), and what the SQL interface cannot yet capture.

Attendees will leave with a concrete understanding of how to connect AI agents to their existing RE workflow across any of the three major platforms, and what "vibe reverse engineering" looks like in practice today.