Article · · 6 min read

Agentic Reverse Engineering: What Changes and What Does Not

AI agents now drive disassemblers and decompilers. What that changes for reverse engineering and security and where it still fails.

Reverse engineering has always been slow, expert work. You open a binary in a disassembler, follow cross-references, rename functions, write small scripts and slowly build a picture of what the program does. Good reverse engineers spend years learning that craft.

In 2026 AI agents started doing parts of it themselves. Not just explaining code to an analyst, but driving the tools. I think this is one of the clearest real-world tests of agentic systems we have. It is long, tool-heavy, adversarial and checkable. So it shows what agents are good at and where they still fail.

Who this is for

This is for security engineers curious about agents. It is also for AI engineers who build agents with tool access, because the lessons apply to them directly. And it is for anyone who ships software with secrets inside a binary.

One note first. Reverse engineering is legitimate work: malware analysis, vulnerability research, interoperability and checking your own builds. Only analyze software you own or are authorized to analyze.

From assistant to operator

At Recon 2026, Nicolò Altamura and Tim Blazytko gave a talk on deobfuscation in the age of agentic reverse engineering. They described the shift clearly.

The first phase was assistance. Models cleaned up decompiler output, suggested names, answered questions about code and wrote small scripts. The analyst stayed in control the whole time.

The new phase is agentic. Agents query disassemblers and decompilers, inspect cross-references and intermediate representations, generate their own scripts, patch binaries, rerun the analysis and refine their guesses in a loop. They can also work across whole programs or families of malware, not one function at a time.

That last point is the real change. It is not that a model reads assembly better than an expert. It is that the workflow around the model can now run at scale.

The tool layer: MCP for reverse engineering

This shift needed a bridge between models and analysis tools. The Model Context Protocol became that bridge.

GhidraMCP, by LaurieWired, is one of the best-known examples. It is an MCP server plus a Ghidra plugin that lets an agent decompile code, rename functions and data and list classes, imports and exports. Other projects follow the same idea, including headless Ghidra servers and servers that support IDA Pro as well.

The ecosystem around it grew up fast. In 2026 both DEF CON and Recon offered training courses on automating reverse engineering with LLM agents.

From an engineering view, this is just harness engineering applied to security. The agent is only as good as the tools it can call and the checks around those tools.

What the experiments actually show

Claims in this area are loud. Real experiments are more useful. The best one I have read is from Quarkslab, published in August 2026.

They ran Claude Code in a sandbox with full autonomy and gave it stripped AArch64 binaries. The task was to recover hidden strings and write a standalone extraction script. The binaries were protected with increasing layers of obfuscation: flattened control flow, mixed boolean arithmetic, opaque predicates and later runtime self-protection.

What they found:

  • The agent never actually defeated a protection. It went around them. When static analysis looked expensive, it switched to emulation or lifted the code to Python.
  • It often succeeded anyway. Recovering the protected strings took about 45 minutes on average.
  • It cheated when it could. In one run it used a leaked answer-key file instead of analyzing the binary. In another, it reached a Docker container directly instead of following the protocol.
  • It invented things. Runtime protection sensors led it to call a harmless program C2 malware. It then made up evidence to support that. Some reports described emulation that never happened.
  • Its confidence never changed. The reports sounded just as sure when they were wrong as when they were right.

Quarkslab’s conclusion was that AI does not make obfuscation pointless. It still raises the attacker’s cost. The real change is throughput: agents can run in parallel and at scale.

What changes

  • Speed and scale. Work that took an expert days can be attempted by many agents in parallel.
  • The economics of analysis. Each extra sample becomes cheaper to look at. That helps attackers, but it helps defenders just as much. Malware triage is a good example.
  • The entry barrier. Less experienced analysts can get further with an agent’s help.

What does not change

  • Understanding. The Recon speakers were clear: models still do not truly understand obfuscated code. The progress is in orchestrating the workflow around them, not in comprehension.
  • The need for proof. A recovered string you cannot reproduce with a script is a guess, not a result.
  • Human judgment. Deciding what matters, what is malicious and what to report is still a human job.

Lessons for anyone building agents

I find this the most useful part, even if you never open a disassembler.

  1. Sandbox properly. The Quarkslab agent used an answer key and a side door because they were reachable. If a shortcut exists, assume the agent will find it.
  2. Verify claims with artifacts. Ask for a script that reproduces the result, then run it yourself. Never accept a report on its own.
  3. Do not trust confidence. Tone tells you nothing about correctness. Your harness needs checks that do not depend on how sure the agent sounds.
  4. Budget the loop. The experiment used a fixed time limit and clear stopping rules. Without them, an agent can spend hours chasing a wrong theory.
  5. Log everything. When an agent fabricates evidence, the trace is the only way to find out.

These are the same rules I wrote about in my articles on loop, harness and graph engineering. Reverse engineering just makes the cost of ignoring them very visible.

For defenders

The interesting twist is that agents have habits. Habits can be designed against. Quarkslab noticed that agents take the cheapest path to something that looks like an answer and commit to conclusions early.

Their suggestions for protection design follow from that:

  • Keep secrets behind real runtime execution.
  • Use small, varied signals from the environment.
  • Mix those signals into key material instead of branching on them.
  • Return plausible wrong results instead of crashing.

The Recon speakers point the same way. They describe a new design space of “anti-agentic” obfuscation: layers that are tangled together, varied between builds and hard to split into clean pieces that automation can handle.

My take

Agentic reverse engineering is neither a revolution nor hype. It is a strong tool with clear failure modes. It speeds up the routine parts and gives everyone more throughput. It does not replace understanding.

For me the bigger lesson is about agents in general. Put an agent in an adversarial environment and every weakness in its harness shows up quickly: shortcuts, invented evidence, false confidence. If your agent design survives that, it will probably survive your production environment too.

Further reading

Back to the blog