Agent-written diversity + differential fuzzing

When your code gets hacked and the crisis hits, show them you’ve already handled it.

AI is making it easier to find and exploit weaknesses in your code. One successful attack can expose your users’ data, cost you customers, trigger lawsuits, and destroy the trust you spent years earning.

Polyform uses AI to create and test multiple versions of the important parts of your code. Your users don’t all get the same version—so if attackers crack one, you can shut it down and switch to another that’s already ready.

When the crisis hits, your backup plan is already running.

Create a free project See differential fuzzing

Built for security No vendor lock-in Works in your stack

A CONCRETE EXAMPLE

Suppose your app needs to decode a filename.

Specify the behavior

Describe every valid input, output, error, security rule, and important example.

Let agents write the code

polyform generate --count 5 creates shared tests and five independent decoders.

Make them disagree

polyform fuzz generates shared inputs, finds different answers, and saves the smallest failing case.

THE WHOLE LOOP

Polyform adds four ideas to a normal software project.

Describe the function

Write down exactly what it accepts, returns, and must never do. Tests enforce those rules.

Have agents write several versions

Each version follows the same contract, so any one can be used.

Give installations different combinations

Your app contains every accepted version. Polyform tells each installation which ones to use.

Remove versions that fail

Your app reports success or failure—not user files. The dashboard makes risky versions stand out.

WHY THIS IS POSSIBLE NOW

AI can write enough code to make diversity practical.

Coding agents can produce and test independent implementations at a scale that was too expensive when every version had to be handwritten. At the same time, advanced AI is making vulnerability discovery and exploitation faster. Shipping different implementations reduces the chance that one flaw exposes every installation at once. It cannot guarantee that an unknown vulnerability is already fixed, but a safe alternative may already be installed and ready to distribute when another version is quarantined.

The implementations become test oracles

Find cases your specification examples missed.

Differential fuzzing does not need to know which implementation is right. It finds inputs where supposedly interchangeable code disagrees, minimizes each input, and saves the exact outputs and seed for investigation.

How local differential fuzzing works


$ polyform fuzz --cases 10000
! disagreement in decode_filename
✓ minimized 143 bytes to 4
✓ saved fuzz/counterexamples/
  decode_filename/91c7….json

Works with your development tools

You specify the behavior. Your agents write and challenge the implementations.

Keep using your editor, test framework, compiler, and source repository. Polyform starts Codex, runs conformance tests and differential fuzzing on your computer, distributes different combinations, and shows you which versions are tied to production failures.

Build your first Polyform project


$ polyform init
$ polyform generate --count 5
✓ 5 implementations per function
$ polyform fuzz
✓ 400 differential cases passed
$ polyform check
✓ tests, fuzzing, and builds passed