ProofStudio

ProofStudio turns AI-generated media into reviewable, byte-verified evidence with provider lineage, Genblaze manifests, and durable Backblaze B2 storage.

Comment

Inspiration

Generating an AI image is now easy. Proving exactly how it was created, which provider and model produced it, what bytes were stored, and whether the evidence remained unchanged is much harder.

AI media teams often have the final asset, but the supporting evidence is scattered across logs, provider responses, storage systems, and internal tools. That makes review, auditing, handoff, and verification unnecessarily difficult.

ProofStudio was built to turn an AI media generation into a durable, reviewable evidence record instead of leaving reviewers with only an image and a promise.

What it does

ProofStudio captures the complete evidence trail around an AI-generated media run.

For each generation, it can preserve:

  • The original generation brief
  • The provider and model used
  • Provider request lineage
  • The original generated asset
  • SHA-256 integrity hashes
  • A Genblaze manifest
  • A structured run bundle
  • A verification receipt
  • Backblaze B2 storage references
  • Read-after-write byte verification
  • Execution counters that expose duplicate or continuation calls
  • An explicit truth boundary explaining what the evidence does and does not prove

The public Review Room allows a judge or reviewer to inspect the generation, provider lineage, integrity hashes, stored evidence, execution counters, and storage limitations from one interface.

A typed FastAPI service also exposes health, version, campaign, run, attempt, asset, manifest, passport, private-proof, and controlled Genblaze bundle-import routes through a public OpenAPI contract.

Verified live proof

The deployed live proof contains evidence from one successful GMI Cloud image-generation request using Seedream 5.0 Lite.

The verified record includes:

  • One original provider generation request
  • Zero continuation generation posts
  • No duplicate generation
  • One original 4096 × 2304 PNG
  • 7,494,910 original image bytes
  • A verified Genblaze manifest
  • Five exact evidence objects stored in Backblaze B2
  • Five B2 exact-key preflight checks
  • Five B2 writes
  • Five immediate verification reads

The five stored evidence objects are:

  1. The source brief
  2. The original generated PNG
  3. The structured run bundle
  4. The Genblaze manifest
  5. The verification receipt

After every successful write, ProofStudio immediately reads the object back from Backblaze B2 and compares the returned bytes with the original local bytes.

How we built it

The backend is built with Python, FastAPI, Pydantic, Uvicorn, HTTPX, boto3, and a structured provider-adapter layer.

The generation workflow records the provider response and request identifiers, constructs the run evidence, produces a Genblaze manifest, calculates SHA-256 hashes, and writes the evidence objects to Backblaze B2.

The storage continuation uses:

  • Exact-key preflight checks
  • A local single-writer boundary
  • Plain B2 object writes
  • Immediate post-write reads
  • Byte-for-byte verification

The frontend is built with React, TypeScript, Vite, HTML, and CSS. Large evidence surfaces are lazy-loaded so the public application remains stable while still exposing detailed judge-facing proof pages.

The frontend and API are deployed separately on Render. The public proof page is directly accessible from the ProofStudio homepage in one click, and every secondary page includes a clear route back to the main site.

Challenges we faced

Preventing duplicate generation

The evidence-storage stage must never silently trigger another media generation. We added explicit execution counters showing one original provider request and zero generation posts during continuation.

Describing B2 storage honestly

A successful object write does not automatically prove global race safety or atomic create-if-absent behavior.

ProofStudio uses exact-key preflight and a local single-writer boundary, but it does not describe the storage operation as globally atomic, overwrite-proof, or race-free.

Separating byte integrity from semantic truth

A matching SHA-256 hash proves that two byte sequences match. It does not prove that the media is factually true, legally authentic, human-authored, or free from manipulation before it entered the recorded workflow.

The product presents this distinction directly instead of hiding it in documentation.

Making technical evidence understandable

Provider responses, hashes, storage keys, manifests, and verification receipts are useful to engineers, but they can overwhelm reviewers.

We designed the Review Room to expose the important evidence progressively while keeping the underlying records available for deeper inspection.

Creating a reliable public judge experience

The project contains many proof surfaces. We had to make sure the verified live proof was accessible directly from the homepage and that reviewers could always return to the main ProofStudio site without becoming trapped in a secondary route.

Accomplishments that we are proud of

  • Produced a real GMI Cloud generation and preserved its provider lineage
  • Stored five exact evidence objects in Backblaze B2
  • Verified every successful B2 write through an immediate readback
  • Demonstrated one original provider request with zero duplicate generation
  • Published a judge-readable live proof page
  • Built a typed FastAPI and OpenAPI evidence contract
  • Exposed the limitations of the storage and integrity guarantees honestly
  • Created a one-click path from the homepage to the verified proof
  • Built a clear return path from secondary proof pages
  • Delivered a complete public application, API, proof record, and video demonstration

What we learned

We learned that trustworthy provenance depends as much on clearly stated limitations as it does on successful hashes and storage writes.

A hash can establish byte identity, but only within a defined evidence boundary.

Provider lineage becomes much more useful when the original request count, continuation count, storage operations, and verification reads are visible together.

We also learned that technical correctness is not enough for a public proof product. Navigation, readability, deployment stability, and the ability to inspect the evidence without special access are part of the verification experience.

What is next for ProofStudio

The next stage is to expand ProofStudio into a reusable evidence layer for more image, video, and audio providers.

Planned improvements include:

  • Automated browser QA across every route, button, link, console state, and network request
  • Additional generative-media provider adapters
  • Evidence comparison between multiple generations and revisions
  • Richer campaign and team review workflows
  • Exportable evidence packages for external reviewers
  • Optional C2PA-compatible metadata support
  • More advanced authorization for private campaign evidence
  • Stronger storage coordination for multi-writer environments

Truth boundary

ProofStudio proves what the recorded workflow and stored bytes show.

The current B2 continuation uses exact-key preflight, local single-writer enforcement, plain object writes, and immediate byte verification.

It does not claim atomic create-if-absent behavior, global race freedom, legal authenticity, semantic truth, human authorship, biometric identity, or C2PA certification.

Built With

Share this project:

Updates

Submission history