Generated inputs
Property tests and fuzzers that find the inputs nobody thought to write down.
An agent that writes its own examples tends to pick ones that pass. A property says what must hold for every input, and the tool goes hunting for the input that breaks it. When it finds one, it shrinks the failure to the smallest case it can. Rule 28 says that case belongs in the Contract.
Show tools for
56 tools
Property-based testing
Start here
Bombadil
Property-based testing for web and terminal UIs that explores the interface and checks stated properties.
State rules a UI must always hold, then let it hunt for click paths that break them with no scripted flows.
Pre-1.0, with v0.7.8 the latest release.
Start here
Eris
Property-based testing for PHP that plugs into PHPUnit with generators and shrinking.
The one credible property library for PHP, and it runs inside PHPUnit so the existing gate picks it up.
Start here
fast-check
Property-based testing for JavaScript and TypeScript with shrinking, model-based and race-condition testing.
Works inside Jest and Vitest, so properties join an existing suite and the CI gate runs them unchanged.
Start here
FsCheck
QuickCheck for .NET with generators, shrinking and integration with xUnit, NUnit and Expecto.
The long-standing default for .NET properties, usable from both F# and C#.
Start here
Hedgehog
Property testing with integrated shrinking that keeps the shrink rules inside each generator.
Hand-written shrinkers disappear, so generators an agent writes still give clean minimal failures.
Start here
Hypothesis
Generates inputs from a description of valid data and shrinks failures to the smallest case.
A property states a rule for all inputs, which makes a stronger Contract than the few examples an agent picked.
Start here
jqwik
A JUnit Platform engine for property-based tests with shrinking, stateful testing and edge-case injection.
Runs under the JUnit runner the build already uses, so properties join the gate with no new pipeline.
Start here
prop_check
Hypothesis-style property testing for Ruby with generators, shrinking and RSpec and Minitest hooks.
Shrinking and composable generators suit properties on Rails domain logic.
Start here
PropEr
QuickCheck-inspired property testing for Erlang with type-based generators and stateful testing.
Stateful testing finds ordering bugs in processes and servers that example tests rarely reach.
Licensed GPL-3.0, which matters for some commercial users.
Start here
proptest
Hypothesis-style property testing for Rust with strategies, shrinking and saved failure cases.
Saved regression seeds turn every failure into a permanent test, which feeds bugs back into the Contract.
Start here
rapid
Property-based testing for Go with generators, automatic shrinking and stateful model tests.
State machine tests check a whole API against a simple model, which pins behavior better than examples do.
Start here
ScalaCheck
Property-based testing for Scala and Java with generators, shrinking and commands for stateful systems.
Integrates with ScalaTest, specs2 and munit, so properties run in the existing Scala CI.
Start here
StreamData
Data generation and property-based testing for Elixir, built on lazy streams.
Works with ExUnit, so properties sit next to ordinary tests.
Start here
test.check
QuickCheck-style generative testing for Clojure with shrinking, maintained as a core contrib library.
Clojure's data-first style makes generators easy to compose, and spec can derive them automatically.
-
CsCheck
Random testing library for C# with fast shrinking and model-based tests.
A failure reproduces from one short seed string that can go straight into a regression test.
-
Hegel
Property-based testing libraries for many languages that use Hypothesis as the generation engine.
Brings Hypothesis-quality generation and shrinking to other stacks, and plugs into Antithesis for deeper exploration.
Developer preview announced 2026-03-24 and built on Hypothesis, so it needs Python installed for now.
-
Kotest property testing
Generators, shrinking and property checks built into the Kotest framework.
Kotlin syntax matches the rest of the suite, so agent-written properties look familiar to reviewers.
-
quickcheck (Rust)
A small Rust port of Haskell's QuickCheck that checks properties on random inputs.
Quick to adopt for simple properties, with weaker shrinking than proptest.
In maintenance mode but still receiving commits.
-
Rantly
A Ruby generator library for random test data with a simple property check helper.
Easy to start with. It shrinks less well than prop_check, so failures come back larger.
-
RapidCheck
QuickCheck-style property testing for C++ with shrinking and integration with Google Test and Catch.
Stateful tests of C++ classes against a model prove behavior in code where bugs are expensive.
Fuzzing
Start here
AFL++
Community fork of AFL with better scheduling and mutators for coverage-guided fuzzing.
The default fuzzer for native code. An agent can add a harness and let it run in CI.
Relicensed from Apache-2.0 to AGPL-3.0-or-later on 2026-06-03, with many files still Apache-2.0 and an optional commercial license.
Start here
Echidna
Property-based fuzzer for smart contracts that checks invariants written in Solidity.
Invariants written as code give money-moving contract logic a hard bar that agent changes must clear.
-
Atheris
Coverage-guided fuzzer for Python code and native extensions, built on libFuzzer.
Finds crashes in parsers and C extensions, and Hypothesis can drive it for structured inputs.
-
cargo-fuzz
Cargo subcommand that runs libFuzzer against Rust fuzz targets.
One command adds and runs a target, so a parser change can ship with its own fuzz run.
-
ClusterFuzzLite
Runs fuzzers on pull requests inside CI such as GitHub Actions.
It fires on every change, which turns fuzzing into a gate.
-
Code Intelligence (CI Fuzz)
Commercial continuous fuzzing platform built around the open source Jazzer and Jazzer.js.
Adds triage and CI reporting to fuzz tests that live in the codebase.
-
EvoMaster
Evolutionary fuzzer that writes system-level tests for web service APIs.
Produces runnable regression tests from a service's API, a starting suite for legacy endpoints an agent will touch.
Research-grade, strongest on JVM backends.
-
Fuzzilli
Mutation-based fuzzer for JavaScript engines that works on an intermediate language.
Niche. It suits teams building engines or interpreters.
-
Go native fuzzing
Coverage-guided fuzzing built into go test through FuzzXxx functions and a saved corpus.
Needs no extra tool, and failing inputs land in testdata as regression tests the agent must keep green.
-
honggfuzz
Multi-process, feedback-driven fuzzer with hardware-based coverage on some platforms.
A second engine to run beside AFL++ on the same harness, finding different bugs.
-
Jazzer
Coverage-guided fuzzer for the JVM built on libFuzzer, with JUnit integration.
Fuzz tests run as ordinary JUnit tests, so the Java build's gate runs them.
-
Jazzer.js
Coverage-guided fuzzer for Node.js with Jest integration.
Fuzz targets sit in the Jest suite, next to the tests agents already write.
-
JQF + Zest
Feedback-guided fuzzing for Java that mixes QuickCheck-style generators with coverage guidance.
The generator knows the input structure and coverage steers it into deep branches.
-
LibAFL
A Rust library for building custom fuzzers with swappable parts.
Build a structure-aware fuzzer for an unusual target when stock engines do not fit.
-
libFuzzer
In-process, coverage-guided fuzzing engine built into LLVM.
Harness functions are small enough for an agent to write quickly. It also powers cargo-fuzz, Jazzer and OSS-Fuzz.
In maintenance mode, and LLVM says new features go elsewhere.
-
Mayhem
Commercial fuzzing and API testing platform that combines fuzzing with symbolic execution.
Managed fuzzing with CI hooks for teams that want no part in running engines.
Formerly ForAllSecure. Bugcrowd acquired Mayhem Security, announced 2025-11-04.
-
OSS-Fuzz
Free continuous fuzzing service from Google for qualifying open source projects.
Always-on fuzzing for open source code, with harnesses an agent can help write and keep current.
Open source projects only.
-
PHP-Fuzzer
Coverage-guided fuzzer for PHP libraries, written in PHP.
A rare option for PHP, good for parsers and validators.
-
RESTler
Stateful REST API fuzzer from Microsoft that infers request sequences from an OpenAPI spec.
Finds bugs that need several calls in order, which single-request checks miss.
-
Ruzzy
Coverage-guided fuzzer for pure Ruby code and Ruby C extensions, from Trail of Bits.
The one serious Ruby fuzzer, handy for parsers and gems with native code.
Licensed AGPL-3.0 since its first commit, which matters for some commercial users.
-
SharpFuzz
AFL and libFuzzer instrumentation for .NET assemblies.
Points standard fuzz engines at C# parsers.
-
syzkaller
Coverage-guided kernel fuzzer that generates system call programs.
Matters to the few teams where agents write kernel or driver code.
Deterministic simulation
Start here
Antithesis
Runs your whole system in a deterministic simulator with fault injection and replayable bug reports.
Exposes the rare timing bugs that agent-written distributed code produces, and every failure replays exactly so the agent can fix it.
Agent skills and the Snouty CLI are available, and Snouty is under active development and likely to change.
-
FoundationDB simulation
The deterministic simulation framework behind FoundationDB, which popularized the method.
The proof that simulation catches bugs unit tests cannot, and the design reference for the other tools here.
Reusable only inside FoundationDB's codebase.
-
Fray
Controlled concurrency testing for the JVM that explores thread schedules and replays failures.
Found real bugs in Kafka, Lucene and Guava, and it fits JVM tests with no rewrite.
-
gosim
Simulation testing for Go that controls goroutines, time, network and disk deterministically.
The closest Go equivalent of FoundationDB-style simulation, though development has stalled.
No push since December 2024.
-
Hermit
Runs Linux programs in a deterministic sandbox and can explore thread schedules to find races.
Makes a flaky test reproducible with no code changes, so an agent can chase down intermittent failures.
Experimental, from Meta.
-
Jepsen
Framework for testing distributed databases under partitions and clock faults, then checking histories for consistency.
The standard for finding out what consistency a store delivers, which an agent's own tests cannot show.
-
loom
Exhaustive permutation testing of concurrent Rust code under the C11 memory model.
Checks every legal ordering for small concurrent pieces, a proof-like result for lock-free code.
-
madsim
Deterministic simulator for Rust async code that replaces tokio's runtime, network and clock.
Distributed Rust code gets tested against injected failures with a seed that always replays.
-
Maelstrom
A workbench for toy distributed systems in any language that talk over JSON on stdin and stdout.
A quick way to check an agent's protocol implementation against a checker before building anything bigger.
-
Microsoft Coyote
Systematic testing of .NET async code that explores task interleavings and injects failures.
The main option for deterministic testing of C# services written with async and tasks.
-
Shadow
Runs real unmodified Linux programs in a simulated network and clock.
Tests unchanged binaries under controlled network conditions, useful when agents write networked services in any language.
-
Shuttle
Randomized scheduler testing for concurrent Rust code from AWS.
Explores thread interleavings at scale, which suits concurrent code that agents tend to get subtly wrong.
-
TigerBeetle VOPR
The simulator inside TigerBeetle that replays a whole cluster with injected faults from a seed.
A model for how a spec-first system tests itself, worth copying when agents write storage or consensus code.
The simulator is part of the database repo and ships as no separate library.
-
turmoil
Tokio's test framework that simulates hosts and a faulty network inside one process.
Network partitions and message loss become ordinary unit tests an agent can write and rerun.
Nothing in this section is built for the stacks you picked, and nothing here works with any language. Pick another stack, or .
Gone quiet 2
These tools are archived or shut down, or nobody has released or committed to them in two years. Some still work fine. Read the note before you adopt one.
-
go-fuzz
Early coverage-guided fuzzer for Go that predates the built-in one.
Only matters on old Go versions.
Superseded by Go native fuzzing (go test -fuzz).
-
SwiftCheck
QuickCheck for Swift with generators, shrinking and XCTest integration.
The only established property library for Swift. Check that it builds with current toolchains.
No activity since 2022.
Missing a tool that belongs here? Suggest it.
Every tool here was checked against its GitHub repository or its own site on 6 October 2026. Stars and dates come from GitHub on that day.