RC RANDOM CHAOS

An agent reads raw x86 and writes Markdown

A reverse engineer with two decades of experience describes the agent-assisted workflow they now use to disassemble binaries and build custom firmware.

· 4 min read
An agent reads raw x86 and writes Markdown

Today’s LLM agents can work directly from raw disassembly, plain x86 or ARM instructions with no decompiler in the loop, well enough to be useful on real binaries. That claim comes from a reverse engineer who has spent two decades pulling hardware and software apart by hand and has now published the agent-assisted workflow they use instead. The setup is blunt: point an agent at a binary, hand it a set of reverse-engineering skills, and let it produce the first structural pass on its own.

The pipeline itself is ordinary RE with the agent doing the grind. Identify the binary’s type, platform and build, pick the matching decompiler, then have the agent map the basic structure: main functions, the primary branching, and imported functions, whether the target is a desktop executable, a website or a firmware image. Once that overview exists, the rest is whatever the job needs, whether patching the original, building a mod, or just understanding it.

The transferable part is how they stop the agent from flailing, and two habits carry most of it.

Everything the agent finds gets written to Markdown as it goes. The author gives reasons beyond ordinary note-taking: the files survive context compaction and handoff to a fresh agent, and they keep the agent from looping over ground it already covered.

The second habit is a published skill the author calls hypothesis debugging, and it is the one they rate highest. When the agent gets stuck it is forced into a loop: state a hypothesis about how something works and write it to a CSV of hypotheses on disk, design an experiment such as a probe or a log point that definitively proves or disproves it, record the result, repeat. It is the scientific method aimed at a disassembly, and the point is to replace the agent’s tendency to guess and retry at random with experiments that settle a question.

When disassembly alone stalls, the escalation path is familiar to anyone who debugs for a living. Let the agent set breakpoints and step through. Add logging, either by enabling it in the original binary or by injecting a probe that records what you need to a file. Give the agent outside access, meaning computer use for desktop apps or an API-controllable emulator for firmware. Tell it to switch tactics, but specifically: when it is lost chasing xrefs, point it at strings instead. And read the full conversation, thinking traces included, because a smart model still narrows onto a dead approach, and you can often feel that happening before it burns a run.

Two tooling points are worth keeping. A dedicated skill that describes the actual RE tools, radare2 or Ghidra driven over an MCP bridge, matters because without it agents give up too early, not knowing how to drive the disassembler at all. And for building the hack, the author reaches for Python under uv for quick probes and single-file scripts, and Rust for the real implementation. The reason given for Rust is the feedback loop: a strict compiler points the model straight at memory and syntax mistakes on every iteration, which is the tight signal an agent iterates well against.

The results are a personal account rather than independently verified work, but they are concrete. Over six months the author claims to have mapped the communication protocols of a pair of Sony Alpha cameras well enough to build a wireless webcam out of an A7III, reverse-engineered an EmWave biofeedback device, written custom firmware for the Arturia MiniFreak, Teenage Engineering OP-Z and an Akai MPC, built firmware for an Xteink X4 e-reader, fixed a macOS driver for an old HP printer, and cracked a pile of license-locked abandonware. Each, they say, would have taken years by hand.

For anyone wiring agents into this kind of work, the scaffolding does more than the model. On-disk notes, the forced hypothesis loop, skill files that describe the tools, and a language whose compiler talks back are what turn a model that can read assembly into one that finishes the job rather than circling it. The author credits their own instinct for when an agent has gone down a blind path as the thing that keeps the process moving.

Share

Keep Reading

Latest on the Wire

Full wire →

New signal daily · RSS

Stay in the loop

New writing delivered when it's ready. No schedule, no spam.