Authors report gpt-6.1-sol can read and write executables from hex dumps

A blog post defines "Machine Code Programming" as a general-purpose LLM reasoning directly about an executable's bytes, with no compiler, assembler, disassembler or execution between it and the file. The authors test three abilities and one real-world case on gpt-6.1-sol (which they call Sol 6.1) at high effort through Codex CLI 0.166.0. The input is an xxd hex dump pasted into the prompt, at about 2.4 tokens per byte. They cite Takehi et al., who recently showed that LLMs can read and write neural network weights directly, which Takehi et al. call Weight-Space Programming.

Understanding. The model got hex dumps of three programs the authors wrote plus one real FreeBSD binary, ministat. It correctly identified what all four were from bytes alone. Ministat was the hardest case: built at -O3, statically linked against musl, stripped, with its own text removed and its last three strings hidden by setting each byte's high bit. The model found the decoding loop, recovered the option list and described all eight options. The authors say that, to their surprise, it also found a real bug. Reading the t-table as raw 64-bit floats, it noticed that the option labeled 99.5% confidence uses critical values for about 99.8%, so -c 99.5 applies a stricter test than it claims. The authors confirmed the bug in the original source code using Claude.

Patching. For each of the three programs the authors asked for one new feature. The model replied with a list of byte edits, each the same length as the bytes it replaced. Hidden tests checked that old behavior still worked, that the new feature worked and that long inputs were handled. All three patched programs passed every test. The authors say Sol 6.1 worked like a human patching a binary: it found padding, made it executable by editing the segment headers, wrote new code there and overwrote existing instructions with calls into it.

Writing. Given a written spec and no hex, the model had to produce a full ELF64 program with every byte of the file, headers included, and no assembler or compiler. All three files ran and matched the reference on every case. The model worked out every jump, call and header field itself. Extending a program used 1.8 to 3.7 times fewer output tokens than writing it.

Malware. Using the same prompt as the understanding experiment and no hint that the file was malicious, the authors gave Sol 6.1 a real 4,608-byte PE32+ sample whose only visible import is Sleep. Its other API calls are hidden behind name hashes and its strings are built on the stack. In 211 seconds the model concluded that it downloads machine code and runs it in memory, and its report named a hardcoded server, 165.154.205.34 on port 443. The authors then compared this with a public VMRay dynamic analysis of the same file. The sandbox confirms the address, the request and the download, but not the 10 s retry or the XOR key itself. The comparisons were made after the run and cover one sample and one run. The authors add that rotate-right-13 hashing is common in public tooling, so recognition probably helped. They did not ask Sol 6.1 to modify malware or write any. The understanding and malware experiments are not formally scored.

A second model. The authors repeated the malware experiment with a different harness, opencode, and a different model, DeepSeek V4.1 Flash, whose weights are public under an MIT license. It got the same sample and request at high reasoning effort, with one reply and no tool calls recorded. They call this preliminary evidence that the ability is not limited to closed frontier models. Three of its deductions were checked against the executable: it decoded e9 03 00 00 00 as a jump to 0x408 past three padding bytes; it assembled 47 45 54 20 and 2f 3f 61 00 from two stack writes into the string "GET /?a" even though the dump has no ASCII column; and it read 80 34 19 99 as XORing a byte in a buffer with 0x99, then ff d3 as a call into that buffer. DeepSeek reached the same conclusion with about 17 times as many reasoning tokens as Sol 6.1. It repeatedly revised its reading and explicitly recalled familiar API hashes. It got nine of the 13 hidden function names right, and two of its naming errors led it to misread the marker-file check. The post reproduces its reasoning transcript unchanged, false starts included, and says it is model output, not a verified analysis.

Limits and outlook. The authors call these early results on small programs that may soon challenge the foundations of reverse engineering. They say disassemblers and decompilers remain essential for human analysts but may turn out to be optional for an LLM, and that malware triage could become faster because the lifting-to-assembly stage disappears. Context size is the hard limit: a hex dump costs about 2.4 tokens per byte, so the largest test, a 67 KB binary, took about 163,000 tokens, and a 10 MB program would need about 24 million. Because the largest test was 67 KB, the authors do not know how quality holds up near the context limit. One way forward they name is a harness based on Recursive Language Models. They also point to earlier work on raw bytes in malware detection with trained models such as MalConv, and on models applied to assembly, including the SLaDe decompiler.

Key facts

  • The authors report that gpt-6.1-sol (Sol 6.1), given xxd hex dumps at about 2.4 tokens per byte, identified all four test programs, including a stripped FreeBSD ministat build, from bytes alone.
  • All three patched programs passed every hidden test, and all three ELF64 files the model wrote from a spec ran and matched the reference; extending used 1.8 to 3.7 times fewer output tokens than writing.
  • On a 4,608-byte PE32+ malware sample, Sol 6.1 concluded in 211 seconds that it downloads machine code and runs it in memory, naming 165.154.205.34 on port 443; a VMRay sandbox confirmed the address, request and download.
  • A repeat with DeepSeek V4.1 Flash (MIT-licensed weights, opencode harness) reached the same conclusion with about 17 times as many reasoning tokens and got nine of 13 hidden function names right.
  • Context is the hard limit: the 67 KB test binary took about 163,000 tokens, and a 10 MB program would need about 24 million.

Why it matters

If a general-purpose model can work on executable bytes without a disassembler or compiler, the usual pipeline from bytes to readable code stops being a required step for the model. The authors argue this may soon challenge the foundations of reverse engineering and could speed malware triage by removing its slowest, most tool-dependent stage. They frame it as an extension of recent work on LLMs reading and writing neural network weights directly (Takehi et al.), applied to executables. The finding that the model spotted a real mismatch between a labeled 99.5% confidence level and critical values for about 99.8% in ministat, later confirmed in the source, is the most concrete sign of real understanding they offer.

Who it affects

Malware analysts and reverse engineers are the group the authors name most directly: disassemblers and decompilers stay essential for humans but may be optional for an LLM. Teams building detection and analysis tooling are also pointed at, since the authors say a general-purpose model could make both detection and analysis more efficient. Researchers on long-context harnesses are affected too, because the authors name Recursive Language Models as one way past the context limit.

How to use it

No product or tool is released in the text. The setup the authors describe is a general-purpose model run through a coding harness (Codex CLI 0.166.0 for Sol 6.1, opencode for DeepSeek V4.1 Flash) with an xxd hex dump pasted into the prompt. For patching, the model replies with a list of byte edits the same length as the bytes replaced. For writing, it gets a written spec and must reply with every byte of the file. DeepSeek V4.1 Flash weights are public under an MIT license. The one-shot approach cannot read very large programs, so it fits small binaries only.

How solid is it

This is a single blog post with self-reported results; the visible text names no authors or institution. The model name gpt-6.1-sol is the authors' own and was not independently checked here. The malware comparison was made after the run and covers one sample and one run, and the sandbox did not confirm the 10 s retry or the XOR key. The understanding and malware experiments are not formally scored. The patching and writing results are reported as every hidden test passed, but only three programs each. The DeepSeek repeat is called preliminary evidence, and its reasoning transcript is labeled model output, not a verified analysis. The crawled text ends partway through that transcript, so anything after it was not seen.

Risks and caveats

The largest test was 67 KB, so quality near the context limit is untested, and a 10 MB program would need about 24 million tokens as a hex dump. The authors say recognition of familiar patterns such as rotate-right-13 hashing probably helped on the malware sample. DeepSeek made naming errors, two of which led it to misread the marker-file check, and it used about 17 times as many reasoning tokens as Sol 6.1 (a comparison of reasoning tokens only, not cost or time). The authors note they did not ask Sol 6.1 to modify malware or write any, and they describe the results as early results on small programs.

“These tools are still essential for human analysts, but for an LLM they may turn out to be optional.”

— The blog post's authors, on disassemblers and decompilers