Reversense: closing the loop between instrumentation and representation in reverse engineering

In 2026, most of us still aren't exploring binaries through the Minority Report UX we were promised. The friction is structural, and three causes among many stand out. First, no representation unifies cross-technology ASTs - VM-based bytecode such as Java or Hermes, native code, interpreted code (JS, Python, …) - so a workflow crossing these stacks can't be followed end to end. Second, intermediate representations are built once and left static, so obfuscated or polymorphic code drifts out of sync with what actually runs; if part of the application is unpacked at runtime, the AST produced by naive static analysis can miss entire parts of the target. Third, tools and their abstraction don't share a language, so runtime traces can't be auto-merged to lift the model, and nothing can be driven autonomously. This last point is why we waste time writing hooks, fighting tooling, and reshaping our understanding by hand - yet that understanding hinges on the hypotheses we form during reverse engineering, and on how quickly we can validate or reject them. Reversense, a CPU-agnostic platform and the logical successor to Dexcalibur, models any application and its runtime context - mobile and inter-process cases included - into one queryable and executable representation, untied to a single binary, language, or static view of the code. At its core, a single IR expresses both native instructions and VM opcodes (Dalvik, Hermes), so every runtime trace are recontextualized at the right semantic tier instead of drowning in the interpreter loop. The representation reaches beyond code, also capturing filesystem activity, user interfaces, network, and more; every fact observed at runtime is merged back in, giving analysts and automated agents a live "virtual copy" to query and to hook. We'll quickly show how the representation is built, then run a real mobile app assessment demonstrating powerful features: automatic xref updates, dynamic AST tagging, hook scheduling, mutational hooks, and trace-driven built-in taint analysis. Finally, we'll show how the built-in in-app fuzzer uncovers an alternative execution path.