Reverse engineering with an LLM is mostly a context problem

A two-decade reverse engineer now points an agent at a binary and steers. The wins came from notes on disk, described tooling and a hypothesis loop — not from the model.

Reverse engineering with an LLM is mostly a context problem
Screenshot of Rizin analysing a binary — Anton Kochkov, CC BY-SA 4.0

A developer who has spent two decades reverse engineering hardware and software published an account this week of how he now does the work: he points a coding agent at a binary, gives it a Ghidra bridge over MCP, and lets it work through the disassembly with him steering. According to the post on Slow Chronicle, projects that would previously have taken him years each — mapping the protocols of two Sony mirrorless cameras, building custom firmware for musical synthesizers, resurrecting a driver for an old HP printer — were finished in the last six months.

The interesting part is the scaffolding around the model, not the model.

The model is the cheap part

The author's stack is deliberately unremarkable: DeepSeek v4.1 Flash in a harness, Ghidra with an MCP bridge for decompilation, radare2 and kuna for faster command-line work, Python with uv for throwaway probes, Rust for anything that ships. Nothing is exotic. What made the difference is that every tool the agent needed was reachable and described, and that every conclusion it reached was written somewhere durable.

That is a context engineering problem in disguise, and the workflow generalises to any team building with agents.

Discipline one: findings live on disk, not in the window

He instructs the agent to document findings in Markdown files as it goes. The files serve three purposes: they become his own notes, they let the agent resume after compaction or a handoff to a different model, and they stop the agent from looping.

Anyone who has run an agent knows the loop: the context fills, older reasoning is summarised or dropped, and the agent cheerfully re-derives a conclusion it already reached. A notes file outside the context window is the cheapest fix: a paragraph of instructions against hours of repeated work.

For a normal engineering team: give the agent a fixed scratch directory, tell it what belongs in each file — findings, open questions, failed approaches — and make reading them step one of every task.

Discipline two: describe your own tools

The author keeps dedicated skills for his RE tooling — how to drive radare2, what the Ghidra MCP bridge exposes, which script to run for targeted decompilation. Without that, he writes, agents "often give up too quickly, getting lost, not knowing how to do the actual disassembly."

This is the most underrated failure mode in agent systems, and it is not specific to reverse engineering. An agent given a database and no schema conventions will guess column names; given a deploy pipeline and no runbook, it will invent a command. The model is not being stupid — it is being asked to act on documentation that exists only in a senior engineer's head. Writing that down as a skill file the agent loads, rather than a wiki page nobody opens, converts a class of confident guesses into correct actions.

Discipline three: one hypothesis, one experiment

The hypothesis-debugging loop is the piece worth stealing outright. When the agent gets stuck, it must state a hypothesis about how something works, write it to a CSV on disk, design a probe or log that definitively confirms or refutes it, record the result, and repeat. The author describes it as a variation of the scientific method that stops the agent "going in circles" by forcing definitive experiments instead of endless guessing.

Teams running agents on production incidents will recognise the failure this prevents. An agent without a hypothesis log produces plausible-sounding explanations in sequence and never converges, because nothing it learns is falsifiable or remembered. A CSV with three columns — hypothesis, experiment, result — is a primitive evaluation harness, and often enough.

The human stays in the loop, narrowly

Two details push against the "autonomous agent" narrative. First, he reads the agent's full reasoning traces when it stalls, to spot when it has committed to a narrow approach — following cross-references down a dead end — and then tells it to try something specific instead, like following strings in the binary. Second, he picks Rust for implementation because the compiler gives "brutally good feedback loops", pointing the agent at memory and syntax problems immediately.

Both are the same insight: agents do well where the environment returns sharp, local, verifiable signals, and badly where they must infer success from ambiguous output. A strict compiler, a failing test, a decompiler that either resolves a function or does not — these are ground truth. A dashboard saying "200 OK" is not.

What this does not prove

The post is one skilled practitioner's account, not a controlled study. The author says his two decades of experience are what let him steer the agent correctly — knowing when a decompilation looks wrong, and which experiment would settle it. The successes are his own hacks on his own devices, with no claim about safety or licensing. Read it as a workflow report from someone with strong priors, not evidence that agents replace expertise.

A checklist for teams running agents

  • Write findings to files outside the context window, and make re-reading them step one of every task.
  • Ship tool skills: exact commands, schemas, and what each tool is bad at.
  • Force one falsifiable hypothesis per attempt, logged with its experiment and result.
  • Read the trace when the agent stalls; redirect to a different signal rather than repeating the instruction.
  • Prefer environments with strict, local feedback: types, tests, schemas, real decompilers.
  • Move from cheap exploration (Python, uv, single-file probes) to strict implementation (Rust, TypeScript) once the approach is known.
  • Keep a human who can tell a plausible answer from a correct one.

None of this requires a frontier model — just treating the agent as a junior engineer with a fast keyboard, no memory, and total obedience to whatever documentation you actually wrote down. At NetPy we build agent systems on that assumption: the harness, the tools and the written context do the work, and the model is the swappable part. If you need an isolated machine to run untrusted analysis on, NetPyCloud will give you a VPS you control end to end.


Header image: Rizin disassembler analysing a binary — screenshot by Anton Kochkov, CC BY-SA 4.0, via Wikimedia Commons.