⏱️ Reading time: 6 min

GPT-6.1 Sol programmed directly in machine code: it read the hexadecimal dump of an executable (no disassembler, no compiler and no tool of any kind) and accurately described what the program did. It then edited those same bytes to add a new function, and in another test, wrote a functional binary from a text description. The authors tested the approach on four different programs, including a real FreeBSD binary, and the model correctly identified all four.

📑 En este artículo
  1. What It Means to Program in the Machine Code Space
  2. The Experiment: No Tools, One Shot
  3. From Disassemblers to Raw Bits: Three Ways to Open a Black Box
  4. The Bug It Found Without Seeing a Single Line of Source Code
  5. What This Means for Developers and Security Analysts
  6. Between Excitement and Alarm: What the Community Is Saying
  7. The Experiment’s Limits
  8. References

What It Means to Program in the Machine Code Space

Almost no one writes machine code by hand. A compiler and a linker turn source code into bytes, and going back the other way requires disassemblers and decompilers: x86-64 instructions have variable length, jumps are relative distances, and a single misplaced byte in the header can keep the file from loading at all. The experiment by George Xenos and Sotiris Giannopoulos, published in November 2026, asks what a general-purpose LLM can do with those raw bytes when it has none of those tools.

The authors call this Machine Code Programming: a model that reasons about the bytes of an executable with no compiler, assembler, disassembler or execution step between the model and the file. They tested three capabilities, reading, extending and writing, plus a real-world case: analyzing a malware sample.

The Experiment: No Tools, One Shot

The setup was deliberately restrictive. The model was GPT-6.1 Sol (gpt-6.1-sol, high reasoning effort) running on Codex CLI 0.166.0, and the input was a hexadecimal dump generated with xxd, at a rate of about 2.4 tokens per byte. A local relay stripped every tool from every request and audited the event stream of each turn; a live test also asked the model to read a planted file, run a command and look up a URL, to confirm it truly had no access.

In the extend and write experiments, the model got a single shot: no feedback, no second attempt. Each resulting build ran alongside a reference build compiled with GCC, under qemu-x86_64 on Apple Silicon, and had to match the reference byte for byte on standard output and exit code across every test case. The read and from-scratch write experiments were not scored with that formal benchmark, the authors note.

The model ran on Codex CLI 0.166.0 with high reasoning effort. Foto de James Harrison en Unsplash

From Disassemblers to Raw Bits: Three Ways to Open a Black Box

Reading binaries without source isn’t new, but traditional tools depend on fixed architecture rules. Xenos and Giannopoulos’s work can be compared to another approach chasing something similar: understanding an opaque artifact without its original representation.

ApproachWhat It NeedsWhat It Returns
Traditional disassemblers and decompilersArchitecture rules (instruction length, relative jumps, header format)Readable code, but depends on a specialized tool per format
Weight-Space Programming (Takehi et al.)Direct access to a neural network’s weightsReading and writing weights without retraining the model
Machine Code Programming (GPT-6.1 Sol)Only the hexadecimal dump, no tool at allReading, extending and writing complete executables

The comparison with Weight-Space Programming isn’t incidental: the authors themselves cite it as a direct precedent, because both treat an artifact normally considered unreadable to a model (trained weights in one case, compiled bytes in the other) as something that can be read and edited in the very format it lives in, as they describe in their post.

The Bug It Found Without Seeing a Single Line of Source Code

The hardest case was ministat, FreeBSD’s statistics tool. The authors compiled it with -O3, statically linked it against musl, stripped its symbols and obscured its last three text strings by flipping the high bit of every byte. Even so, GPT-6.1 Sol found the decoding loop, recovered the program’s option list and described all eight of them, according to the experiment’s record.

That’s where the most striking finding showed up. Reading the t-table as raw 64-bit floats, the model noticed that the option labeled as 99.5% confidence actually uses the critical values for 99.8%: the binary’s -c 99.5 flag applies a stricter test than it claims. It’s a real bug in the original code, one the model detected by reading only the binary’s bytes, with no access to source code.

The patch to wordcount changed only 74 of its 5,368 bytes. Foto de Ilya Pavlov en Unsplash

What This Means for Developers and Security Analysts

For a malware analyst or reverse engineer at a security company, this doesn’t replace IDA Pro or Ghidra, but it does change the first step. The same team gave the model an unknown malware sample and it identified it correctly, extracting the right indicators of compromise (IOCs), and DeepSeek V4.1 Flash reached the same conclusion on that sample, which the authors take as preliminary evidence that the phenomenon isn’t limited to closed models.

The concrete recommendation for an incident response team is to use this as rapid triage before opening the disassembler: ask a model to read the hex dump and summarize likely behavior and IOCs, then validate each finding with traditional tools. None of this replaces human verification, especially since the experiment itself ran with a single response and no chance to correct errors midway.

Between Excitement and Alarm: What the Community Is Saying

Discussion on Hacker News split quickly. User fwlr listed a long set of objections (legal, ethical, licensing, data retention) that, in their view, will surface before this technique reaches production. Another comment, from rossy, questioned how the result is framed: to them, phrases like “writing directly in machine code” suggest the model understands the binary as just another language, when the process seems different from reading natural syntax.

That second objection matters so the finding isn’t oversold. The original Hacker News thread, “LLMs can read and write executables byte by byte from a hex dump”, summarizes the experiment well, but the discussion makes clear there’s still no consensus on whether this is genuine understanding of the binary format or a pattern learned over thousands of similar examples.

The Experiment’s Limits

The result comes with several explicit caveats. The extend and write experiments used a single attempt, with no feedback: there’s no data on how often the model would fail given a second chance. The read and malware experiments weren’t scored with a formal benchmark, unlike the extend experiment, where every patch was validated against hidden tests.

Cost isn’t trivial either. Patching the simplest program took 93 seconds and generated 3,440 output tokens, and adding decryption to an AES tool took 201 seconds and 9,324 tokens, editing 5.9% of the binary. These are few-kilobyte programs built specifically for the experiment; there’s still no evidence the approach scales to real executables of hundreds of megabytes with dynamic symbol tables and external dependencies.

References

Featured image: Foto de Jakub Żerdzicki en Unsplash

📬 Get new articles by email

We only email about big articles (1-2 a month).

How each article is made (sources, testing and editorial criteria): How we work.

Did it work for you? Got a different error? Say so below: questions get answered and help the next reader.

Leave a comment

El Solitario Editorial

Article prepared by the El Solitario editorial team from cited sources, under the editorial responsibility of Luis Navarro. More details in "How we work".

0 Comments

Leave a Reply

Avatar placeholder

Your email address will not be published. Required fields are marked *

You can include code inside <code>…</code> or, for several lines, <pre><code>…</code></pre>.

This site uses Akismet to reduce spam. Learn how your comment data is processed.