Artificial Intelligence

What is ProgramBench: The Uncheatable Benchmark Where Every AI Model Scores 0%

Meta's new benchmark hands AI agents a compiled program and its documentation—no source code, no internet—and asks them to recreate it from scratch. Nine of the most powerful models on earth all scored exactly 0%.

Every few months, a new AI model lands with a headline benchmark score—72% on SWE-bench Verified, 80% on this, 90% on that. The labs trumpet the numbers. The hype cycle spins.

Then someone asks a slightly harder question, and everything quietly falls apart.

Meet ProgramBench, the benchmark that doesn’t care about your leaderboard position. Released on May 2026 by researchers from Meta FAIR, Stanford University, and Harvard University, it does something deceptively simple: it hands an AI agent a compiled program—a real binary that runs—along with its documentation, and says: “Rebuild this. From scratch. No source code. No internet. Go.”

Every frontier model they tested scored 0%. Not low. Zero.

How ProgramBench Works: A Binary, a README, and Good Luck

Before anything, it’s important to know what’s a benchmark.

A benchmark is basically an exam for AI models. Researchers design a set of tasks, run models through them, and score how many the model gets right. The score becomes a shorthand for how “capable” a model is.

It’s also a standardized way to evaluate models and compare them. It gives an objective measure to aspects that usually are described in a subjective way.

The problem is that most coding benchmarks have been getting gamed—not always on purpose, but always by nature. SWE-bench Verified—the go-to benchmark for AI coding until recently—was declared “contaminated” by OpenAI itself. Models had essentially seen the answers during training.

When GPT-5.2’s chain-of-thought logs were audited, the model was reasoning about code details it should have had no way of knowing, pulling from memory rather than actually solving the problem.

ProgramBench is designed to make that impossible.

Here’s what the AI agent actually gets: a compiled binary—a finished program you can run but can’t read—and its documentation. That’s it. No source code. No internet access. The binary is set to execute-only permissions, which means tools like decompilers or disassemblers can’t read it either.

The agent’s job is to figure out what the program does by running it with different inputs, observing the outputs, reading the docs, and then writing an entirely new codebase—in whatever language it chooses—that behaves identically.

Basically what enthusiasts call “reverse engineering.”

Think of it like hearing a song played once and being asked to transcribe every note, instrument, and tempo marking from memory. Except the song is FFmpeg, SQLite or something like that.

The 200 tasks range from compact command-line tools like jq (a JSON processor with 34,541 GitHub stars) and ripgrep (a fast search tool with 62,855 stars) to genuinely massive software: FFmpeg, the media processing giant; SQLite, a database engine embedded in billions of devices; and the full PHP interpreter.

A “pass” requires every single test for a given program to succeed. The median task has 770 tests. FFmpeg alone has nearly 15,000.

Passing a task means passing all the tests for that program. One wrong exit code, one misformatted output, one missing flag behavior, and the task fails. The benchmark authors were intentional about this: a program that passes 99% of tests can still crash in production. Partial credit is noted but doesn’t count as resolved.

Zero. Across the Board.

Nine models were evaluated, all equipped with mini-SWE-agent, a widely used open-source coding agent scaffold. The results are in a table on the ProgramBench leaderboard, and it reads like a joke:

The closest anyone got to “almost winning”: Claude Opus 4.7 passed around 95% on 3% of the tasks—meaning it came close on 6 out of 200 programs but still failed to fully crack any single one. GPT-5.4 and Gemini 3.1 Pro couldn’t even manage that. Their “almost resolved” column is a flat 0.0%.

 

Why It’s So Hard (And Why That’s the Point)

Most existing coding benchmarks—even the tough ones—give models significant hints. SWE-bench asks models to fix a bug in an existing codebase: the structure is already there, the logic is mostly intact, and the model just needs to patch the right spot. That’s closer to maintenance than engineering.

ProgramBench strips all of that away. There’s no skeleton to fill in, no method signatures, no product requirement documents. The model has to decide: what programming language should I use? How should I structure the codebase? What data structures represent the core entities? These are real software design questions that developers wrestle with for months before writing a single line—and AI has been quietly avoiding them by operating on codebases that humans already architected.

The research team found that model-written codebases “diverge significantly from human-written ones, favoring monolithic file structures with longer functions.” Translation: when forced to design from scratch, AI defaults to dumping everything into one giant file rather than thinking in modules, abstractions, and interfaces the way a human engineer would.

 

The Anti-Cheat Gauntlet

The researchers didn’t just design a hard benchmark—they had to design a cheat-proof one. And early trials showed exactly why. When internet access was left on during initial tests, Claude Opus 4.5 simply identified the source repository from the –help output and shallow-cloned it from GitHub.

Other models downloaded source code via package managers—cargo install, go get—or submitted thin wrappers around the original binary. Technically passing. Completely cheating.

The final ruleset is airtight: no internet, execute-only binary permissions, no decompilation tools, and the original binary is deleted before evaluation so models can’t wrap it. Agents run inside Docker containers with no outbound connectivity. The only way to understand what the program does is to actually run it and observe what comes out.

“If you believe empirical rigor is key to progress in AI, you should value benchmarks like ProgramBench that actually take it seriously,” Megan Risdal, an ML researcher at Google DeepMind, wrote on X. “Not enough attention is paid to cheating when evaluating models.”

The benchmark picked up some heat on r/LocalLLaMA within hours of release, with the developer community noting that the tasks which are hardest to benchmark are often the ones that matter most in production—and the ones where AI performance improvement looks fastest are often just benchmarks that have been quietly optimized against.

Is It Even Solvable?

The researchers say yes, and they’re not just being optimistic. Every test targets behavior that can be discovered by running the program with different inputs. The Church-Turing thesis guarantees that any program’s input-output behavior can be replicated in any other programming language. The binary doesn’t hide anything that can’t be found through systematic experimentation. So, in other words, the benchmark is hard, but not impossible.

In fact, some partial scores show real partial progress. The command-line file manager nnn got the best individual result: a best score of 98% from one model, just short of fully passing. The JSON processor jq hit 90%. But the full reconstruction target remained out of reach for all of them.

Submissions to the public leaderboard are coming soon, per the benchmark authors. The race to be the first AI agent—or multi-agent system—to fully resolve even one ProgramBench task starts now, with a public submission portal expected in the coming months.