The AI verification company Theorem runs a free program called OSS Verify. It proves, with a machine-checked mathematical proof, that an open-source project's fuzz tests can never fail on any input under 64 MiB. Anthropic, which worked with Theorem on the research behind it, reported that the same approach proved security properties for 123 open-source libraries. Theorem publishes a skill file that lets a coding agent like Claude Code enroll a project.
A proof is only as good as the test it is about. Theorem's own documentation says so in capital letters: "A weak fuzz target makes the theorems vacuous." So we tested that claim. We wrote four fuzz targets for the cJSON library that all look like they check the same property, planted three of the most common mistakes in three of them, and ran Theorem's own oss-verify check tool on our server.
The short version: the three broken targets passed every check, with exit status 0, until we added a deliberate breakage to the library. Then the tool caught them in about a minute. And our "good" target turned out to have a weakness of its own that the same technique exposed.
This article covers what the skill is, who can use it, what we measured, and the parts any team can copy for private code, with a downloadable kit that includes the four targets and both breakages.
What OSS Verify and the skill are
Fuzz testing feeds a program huge numbers of generated inputs and watches for crashes. Google's OSS-Fuzz has run it on open-source projects for years. A fuzz target is the small function that takes one input and calls the code under test.
OSS Verify goes further. For each fuzz target, Theorem's AI writes a proof, checked by the Rocq proof assistant, that no input makes the compiled program crash, hang or trip a sanitizer. Its program page promises "a proof that your fuzz test will never find another bug, no matter how long it runs." The proof is about the exact compiled binary, not the source code. Bugs found while proving are sent privately to the maintainer, with no disclosure deadline.
The skill (add-project/SKILL.md) is a 215-line instruction file for a coding agent. It makes the agent ask the maintainer what "correct" means before writing any code: which functions take attacker-controlled input, how large real inputs get, which results are expected rather than bugs, and which properties must always hold, such as decode(encode(x)) == x. Then it writes fuzz targets that crash only when one of those properties is broken. It proves each check is real in two ways. Some example input must reach the check (a "coverage witness"). And a deliberate one-line break in the code must make the check fire (a "breakage", which testers also call a mutant). Finally it ports the build and prepares a pull request for the maintainer to open.
Who can use it, and who can't
The limits come straight from the repository's README and program page:
- Only a core maintainer can enroll a project. Theorem checks the contact address against the project's maintainers.
- The project must be open source under an OSI-approved license, with a public repository and at least one fuzz target.
- Languages: the builder handles C, C++, Rust, Python and Go today. Python and Go enrollments are paused, and Go gets no theorem statements yet. C projects whose binaries hold under 1 MB of code get a response soonest.
- You need a Linux x86-64 machine with Docker and buildx, git, uv and about 10 GB of free disk.
- The model covers single-threaded programs only, with no clock, network or environment, and inputs under 64 MiB. There is no MemorySanitizer build and no leak detection.
- Findings and patches are AI-generated, and Theorem says it doesn't promise a person reviews them before they are sent. Proofs take days, and Theorem doesn't promise to merge every enrollment.
- It's free for qualifying projects.
So a small business gets the proof only if it maintains an open-source library in one of those languages. Most don't. But the method works on any code, and the traps below are in plenty of private test suites.
What we measured
We ran everything on our own Ubuntu server on November 19, 2026, with oss-verify at commit 99cf4ff. We installed uv into a home directory and took qemu 10.0.11 out of the exact Debian package the docs name, after checking its SHA-256, without installing it system-wide.
Baseline: cJSON's own enrolled target
cJSON is already on Theorem's list. Its enrolled fuzz target (cjson_read_fuzzer) is also one of the 90 entry points in 32 libraries that already have published proofs.
oss-verify checkwith a second build and the full checks took 256 seconds, including the first download of the 1.1 GB toolchain image, and used about 11 GB of disk.- The second build produced identical bytes, which the tool requires.
- The report said: "0 property checks" in cJSON's fuzz target.
That last line isn't a defect. cJSON's target parses, prints and minifies JSON and checks nothing except that it doesn't crash, which is what most OSS-Fuzz targets do. A proof about it is a real guarantee that the parser can't crash. It says nothing about whether the parser is right.
Four targets that look alike
We wrote four fuzz targets around the same property, a JSON round trip: parse the input, print it, parse the printed text, and require the two parsed values to be equal. Malformed input and numbers like 1e999, which cJSON prints as null by design, are treated as expected outcomes, not bugs.
Scroll to compare columns and rows when the table extends beyond the box.
| Target | How the property is checked | The trap |
|---|---|---|
rt_good |
abort() when the reparse fails or cJSON_Compare says the values differ, with a breakage record in its comment |
None (we thought) |
rt_assert |
assert(b != NULL && cJSON_Compare(a, b, 1));, compiled with -DNDEBUG like a release build |
The check is compiled out |
rt_minus1 |
if (!ok) return -1; |
-1 counts as a pass |
rt_unused |
(void)cJSON_Compare(a, b, 1); |
The result is thrown away |
Each target got the same six seed inputs: a string with escaped quotes, a mix of types, a nested array with Unicode escapes, a non-finite number, a truncated object and a bare string.
We also wrote one breakage patch. It changes one line of cJSON's string printer (line 1039 of cJSON.c at v1.7.19), so that an escaped double quote prints as a backslash instead. Any working round-trip check should catch that on the seed input with a quote in it.
Result 1: with no breakage, the traps are invisible
We ran the three trap targets with no breakage patch, which is how most teams would start. The check took 52 seconds and reported:
Checks: 0 property checks in
rt_assert.c,rt_common.h,rt_minus1.c,rt_unused.c.
That's the same line it printed for cJSON's own crash-only target. Every binary passed every check of the binaries, and the command exited with status 0. The tool can't tell "I only wanted to show it doesn't crash" from "I meant to check a property and it silently disappeared." Nothing in the output looks wrong.
Result 2: a breakage exposes all three
We added the escape-quote patch and ran the three trap targets again (64 seconds):
Scroll to compare columns and rows when the table extends beyond the box.
| patch | result | checks that fired |
|---|---|---|
escape-quote.patch |
not caught by any seed input (coverage and asan-ubsan builds) | none |
The library now prints broken JSON and all three targets still pass. That's exactly the signal you want. Note that the command still exited 0. The finding is in the report, not the exit status, so a CI job that only watches exit codes would have shipped this.
Result 3: one good target hides three bad ones
When we ran all four targets together with the same patch (67 seconds), the report said the patch was caught:
| escape-quote.patch | caught: rt_good on quote, coverage build, exit status 134 (abort()) | rt_good.c:28 |
A patch counts as caught when any target catches it. rt_good did the work, and nothing in that table tells you the other three tested nothing. The only clue is the count at the top: "1 property checks" across four targets that each claim to check one. Read the count, not just the table.
Result 4: our "good" target had a blind spot too
Theorem's pull-request review, which runs on their side and which we didn't run, has a rule we hadn't followed. Check F8 says a check must not take its expected value from the library under test, because "one wrong function then breaks both sides, and the check stays true." rt_good decides equality with cJSON_Compare, which is cJSON's own code.
So we wrote a second breakage that makes cJSON_Compare return "equal" for everything, and ran rt_good against both patches (54 seconds):
| compare-true.patch | not caught by any seed input (coverage and asan-ubsan builds) | none |
| escape-quote.patch | caught: rt_good on quote, coverage build, exit status 134 (abort()) | rt_good.c:28 |
The round trip still catches a broken printer. It can't catch a broken comparison, because it trusts the comparison. The fix Theorem's review asks for is to compute the expected value in the fuzz target itself, from the input and the documented rule, rather than from the library.
Result 5: re-checking a published proof ourselves
The proofs live in a public repository, and anyone can re-run the checker. We fetched the published cJSON binaries with Theorem's oft tool (3 seconds, each checked against its SHA-256) and started the proof check in Theorem's pinned checker image, limited to 8 cores to spare a shared server. The 15 statements compiled first. The proofs were still compiling when we published: 1,258 Rocq files done after 37 minutes, at about 6 GB of memory, with the final, largest theorems still running. Theorem doesn't document how long a check takes. The buyer's guide covers what that published proof does and doesn't cover.
Why each trap happens
assert() disappears. The C standard says assert expands to nothing when NDEBUG is defined. Release build types such as CMake's Release define it. The skill warns about exactly this: "Do not use assert() for a property." Write if (!condition) abort(); instead.
-1 is not a failure. In libFuzzer, returning -1 means "don't add this input to the corpus." Theorem's driver counts it as a pass. The skill's own words: "Do not return -1 for a failed property."
Unused results test nothing. A call whose result nobody checks only shows the call doesn't crash. The skill warns that OSS-Fuzz targets often do this and that "no tool finds it": validation and the check both pass such targets. Our measurements agree.
Trusting the library. A property checked by the library's own function only proves the library agrees with itself.
The common thread is that every one of these targets compiles, runs, covers the code and passes. Coverage numbers look fine, because the code really was executed. Only a breakage asks the question that matters: if this code were wrong, would the test notice?
What to copy for private code
You can't get a proof for closed-source code from this program, but the method costs nothing:
- Write each property as
if (!condition) abort();, with a comment saying what it checks and why it must hold. - Make every expected outcome
return 0: malformed input, size limits, refused allocations. Never return -1 or 1 for "not interesting." - Keep a coverage witness: a few seed inputs that reach every check. Measure it with
llvm-cov, not by eye. - Write one breakage per check: a one-line change that must make it fire, and an input that shows it does. Run the breakages in CI and fail the build when one isn't caught, rather than trusting the exit status of a tool that only reports.
- Compute expected values yourself. If you compare against the library's own function, write a breakage for that function too.
- Count properties per target. A target with zero is a crash test. That's fine if you meant it and a bug if you didn't.
The kit has a checklist, an agent prompt that applies these rules to private code, the four demo targets and both breakage patches.
If you maintain an open-source library
Enroll it. Point a coding agent at the repository's AGENTS.md, answer its questions honestly, and expect the agent to push back on targets like our three. Read the Dockerfile before you run oss-verify check, because it builds with network access. The README says to use it only on a project you trust. Budget for the breakage step, because it's where a weak target gets exposed. And choose the publish setting deliberately: proofs publish after fixes are public by default.
A companion piece covers what a published proof is worth to a defense small business, and a buyer's guide covers how to read the proofs repository when you only use the libraries.
Fact-check notes and sources
- Our measurements: our server, November 19, 2026. oss-verify commit
99cf4ff. cJSON v1.7.19, commitc859b25. qemu-user 1:10.0.11+ds-0+deb13u1 (SHA-256 checked as the docs specify). Times are wall-clock foross-verify check --no-shell --checks, the baseline also with--twice. The demo project was local only and was never submitted. To keep the patches inside the build context, it stored them as allowed.hfiles that theDockerfilecopies into amutantsdirectory. A real enrollment keeps them in the project's own repository. - The skill and its warnings: Theorem Labs, add-project/SKILL.md (the questions,
abort()notassert(), the -1 rule, coverage witnesses and breakages, "A weak fuzz target makes the theorems vacuous"). - Eligibility, requirements, the build-with-network warning, AI-generated findings: oss-verify README. Free, the proof promise, no disclosure deadline: Theorem, OSS Verify. What a statement covers and its exceptions: what-gets-proven.md. How patches are judged caught: build-contract.md. Check F8 and the review rules: review.md.
- Published proofs (90 entry points in 32 libraries): oss-verify-proofs.
- The research behind it: Anthropic, LLMs are making formal software verification feasible at a much larger scale.
- cJSON: DaveGamble/cJSON, MIT license. Our patches are deliberate breakages for testing and fix nothing.
Related reading
- From HACMS and ARES to Your First seL4 System: where verified components fit in a whole system.
- Ponytail Tells the Agent What to Do. These 9 Repos Check That It Did: the same idea for AI coding agents, a check that cannot pass by accident.
- The check was green because it measured a state no visitor is ever in: more green checks that told us nothing.
- Magnetite: How MIT Lincoln Lab's Secure Embedded OS Works: what AI-scale auditing found around a verified kernel.
This post is informational, not security-engineering or legal advice. Mentions of Theorem, OSS Verify, Anthropic, Claude, Google, OSS-Fuzz, cJSON, Rocq, Docker and Debian are nominative fair use. No affiliation is implied.