The Problem

AI model providers need a way to prove that a response came from a specific, secret model without revealing weights. Existing solutions either expose the model or require heavy cryptographic setups that are hard to deploy in production.

What This Does

FlashProve is a research prototype that lets a provider publish a commitment ID that binds a set of weights. For each inference, the provider’s GPU generates a zero‑knowledge proof that the reply matches the committed model. Anyone can verify the proof on a CPU with the cp_verify binary, without access to the weights. The verifier runs on Linux with g++ 13+, and the prover requires an NVIDIA H100 GPU and CUDA 13.2.

Key files:

  • verifier/build.sh – builds the verifier.
  • verifier/main.cpp – entry point for cp_verify.
  • blocks/engine/*.h/cpp – core proof‑verification logic.
  • prover/build.sh – builds the GPU prover.
  • examples/ – contains a pre‑generated proof that can be verified with cp_verify.

How It Is Wired

Execution starts in verifier/build.sh, which calls make -C verifier. The Makefile compiles C++ sources, linking against the static library built from blocks/. verifier/main.cpp includes blocks/engine/engine.h; its main() calls engine::verify(proof_file). The verify routine loads the proof, checks cryptographic commitments, and runs a lightweight sum‑check against the model’s hidden state. The only external touchstones are the proof file on disk and the console output. The prover side mirrors this flow: prover/build.sh compiles a CUDA binary that loads model weights, runs inference, and writes a proof file. No network I/O is involved in either component.

The repository’s module graph has a single hub: blocks/engine. All verification paths pass through it, making it the widest blast radius for changes. The prover and verifier are isolated; alterations in prover/ do not affect verifier/.

How To Use It

Setup

git clone https://github.com/moses-y/FlashProve
cd FlashProve
# install build tools (root needed)
sudo apt-get update && sudo apt-get install -y --no-recommends g++ make python3 unzip

Build the verifier

./verifier/build.sh
# output ends with: THE VERIFIER IS BUILT:

Verify stored proof

./cp_verify <path_to_example_proof>
# e.g. ./cp_verify examples/example_proof.bin

The script exits with 0 on success; the last line of output is the verification result.

Prover (GPU only)

# requires CUDA 13.2 and an H100
./prover/build.sh
# run with a synthetic model or a real checkpoint

Real‑World Use

A cloud AI provider can expose a REST endpoint that returns both a model response and a proof file. A consumer downloads the proof and runs cp_verify locally to confirm the response came from the committed Llama 4 Maverick model, satisfying compliance or audit requirements without exposing weights.

Code Health & Issues

  • Medium – No CI/CD pipeline: the repository lacks .github/ or GitHub Actions config, so automated builds/tests are absent.
  • Low – Dependencies declared without lockfile: integrations/pyproject.toml lists packages but no poetry.lock or requirements.txt, making reproducible builds hard.
  • Low – The project is unmaintained (0 stars, no recent commits), so security patches or feature updates are unlikely.

The Bottom Line

FlashProve demonstrates a practical zero‑knowledge inference proof system with a clean C++ verifier that runs on modest hardware. It is useful for compliance‑heavy deployments where model weights must stay secret. However, the lack of CI, lockfiles, and maintenance makes it suitable only for research or short‑term pilots rather than production use.