Article
The last software moat that just cracked: AI can now read compiled code well enough that "closed source" means less every month
You can no longer assume that shipping a compiled binary hides how it works. The assumption that withholding source code keeps outsiders from understanding your software has been quietly breaking all year, and the evidence from October 2026 makes it hard to ignore.
The one-number headline: On SRE-Bench — a benchmark built from 19 private programs (16,900 lines each) with 44 anti-analysis techniques applied — OpenAI's GPT-6 Astra fully solved 88.0% of binary reverse-engineering challenges on one attempt and 99.2% within four attempts. The previous generation, GPT-5.6 Sol, managed 55.9% and 68.7%. [1]
That does not mean you can hand any compiled executable to ChatGPT and get the original source back five minutes later. But it does mean the cost of reading software — understanding what it does, how its subsystems connect, where its vulnerabilities are — has dropped dramatically.
What changed: agency, not just language models
AI-assisted reverse engineering isn't new. Language models could explain snippets of assembly or help write Ghidra scripts for several years. The shift in 2026 is that coding agents can now carry out multi-step investigations: they decompile a function, follow its callers, search for strings, examine cross-references, infer data structures, write a script to test a theory, compare two versions of a binary, revise the theory when reality contradicts it, and continue. [1][2]
This loop — observe, hypothesize, test, revise — is the real capability. Earlier models could answer questions about a small block of code you pasted in. A 2026 agent can act like a junior reverse engineer sitting at a workstation, building a mental model of an entire program one subsystem at a time.
Projects like ghidra-rpc (from Cellebrite Labs) wrap Ghidra's decompilation, graphing, scripting, and patching tools in interfaces designed specifically for AI agents — letting them rename symbols, define data structures, diff binary versions, and keep a persistent project database that becomes the agent's external memory. [1] That persistence matters: a reverse-engineering job that would overwhelm a single context window can now span hundreds of tool calls.
The open-source decompilation race
The open-source side has moved fast too. LLM4Decompile, which hit 7,300+ GitHub stars, is the first open-source LLM dedicated to decompiling Linux x86_64 binaries (GCC O0–O3) back into readable C source code. Its V2 series (trained on 2 billion tokens) refines Ghidra's pseudocode, and its V1.5 models showed over 100% improvement over earlier versions. [3] A 9B-parameter model achieves a 0.65 re-executability rate — meaning nearly two-thirds of decompiled functions produce code that compiles and runs correctly.
The project's decompile-bench provides 2 million binary-source function pairs for training and 70,000 for evaluation — a resource that didn't exist in any usable form two years ago. [3]
The "Reverse Engineer Anything" repo went viral for a reason
A GitHub repository called Reverse Engineer Anything (REA) accumulated ~310,000 stars in late October 2026, gaining 208,000 in a single week. [4] It's free and open-source: you plug it into a coding agent, point it at a downloaded app, and ask questions in plain English. When tested against Signal's desktop app (which is open-source, so every answer could be checked), REA got all five questions right — taking 3 to 7 minutes per question. [4]
The same article documented a clean-room rebuild of Linear's core issue tracker: a one-page spec written from Linear's public docs, handed to Codex, produced a working board with statuses, priorities, and Cmd+K search in 3 minutes and 28 seconds. [4]
What this means for software moats
If AI can now read and understand compiled software, what defenses still work? The classic framework of seven moats (Hamilton Helmer's Powers) gives a useful lens. [4] Of the moats software companies have relied on:
- Features — broken. An agent rebuilt Linear's core screens in under 4 minutes.
- Habit/muscle memory — wearing down. An agent doesn't care where your buttons are; as a16z put it, "agents may kill muscle memory as a moat." [4]
- Workflow integration — holds. Linear moves issues when PRs open or merge; a clone without GitHub integration lacks that.
- Data — holds. A clone starts with fake issues; real data (like Coinbase training a model on its own fraud data that beat frontier models) is hard to replicate. [4]
- Network effects — holds. Your team is already in Linear; nobody is in the clone.
- Distribution/integrations — holds. Linear plugs into GitHub, Slack, Figma, Sentry; a clone plugs into nothing.
- Learning speed from users — holds. Every interaction with real users generates proprietary insight about what actually matters.
The headline takeaway: data, workflow, network, and distribution still defend you. Features and UI alone do not.
The bigger picture
Amjad Masad, CEO of Replit, summarized the trend in a post that got 1.33 million views: "What's happening in the AI-powered reverse engineering and decompilation is absolutely insane. Pretty soon all software will be de facto open-source. AI is coming for everything and everyone." [5]
That's overstated for effect, but the direction is real. A systematic review of 144 research papers on AI-augmented binary reversing (published June 2026) catalogs 22 distinct reverse-engineering domains where ML and LLMs are now applied — from vulnerability discovery to malware analysis to legacy system migration. [2]
The cost of writing software has been falling for two years. The cost of reading software whose source you don't possess is now falling just as fast. For builders, the implication isn't panic — it's a shift in what you defend: not the code itself, but the data, the workflows, the integrations, and the user relationships that compiled code alone cannot replicate.
Sources:
[1] Popular AI, "Frontier AI can now reverse-engineer software binaries. Here is what that means in 2026" (Oct 6, 2026) — covers SRE-Bench results, ghidra-rpc, and the agency shift. https://www.popularai.org/p/ai-reverse-engineering-software-binaries
[2] Kwon et al., "SoK: AI-Augmented Binary Reversing" (arXiv:2606.17398v1, Jun 2026) — systematization of 144 papers across 22 binary reversing domains. https://arxiv.org/html/2606.17398v1
[3] albertan017/LLM4Decompile — open-source decompilation LLM, 7.3k+ stars, decompile-bench with 2M training pairs. https://github.com/albertan017/LLM4Decompile
[4] AI by Aakash, "Reverse Engineer Anything: What's Still a Moat?" (Oct 18, 2026) — REA testing, clean-room Linear rebuild, moat analysis. https://www.aibyaakash.com/p/reverse-engineer-anything
[5] Amjad Masad (@amasad), Oct 7, 2026 — "Pretty soon all software will be de facto open-source." https://x.com/amasad/status/2107671204639465961
[6] Tom's Hardware, "OpenAI's isolated red-team AI agents built a hidden CPU cache channel to talk with no network or shared files" (Oct 25, 2026) — related: AI agents finding hardware-level covert channels in sandboxed environments. https://www.tomshardware.com/tech-industry/artificial-intelligence/openais-isolated-red-team-ai-agents-built-a-hidden-cpu-cache-channel-to-talk-with-no-network-or-shared-files-exploited-cpu-cache-timing-to-bypass-microvm-sandboxes