VeriGen: One prompt. Multiple models. One verified winner.

"AI shouldn't be a gamble. VeriGen delivers the consensus."

Inspiration

Every AI generation is a gamble.

We've all been there. You craft the perfect prompt, hit generate, and cross your fingers. Sometimes you get a masterpiece. Sometimes you get a nightmare. And you have no way of knowing which it'll be until the image loads.

The problem isn't just frustrating—it's systemic. Different text-to-image models have distinct semantic boundaries. Visual representations learned by different generative models diverge significantly, producing images with entirely different attributes from the same prompt. Even minor changes in wording can yield inconsistent or inaccurate outputs.

We discovered a stunning paradox: 97% of organizations believe AI models are capable of checking themselves, yet a staggering 80% still rely on manual spot-checks to verify AI-generated content before it goes live. The burden falls back on already-busy teams, creating deepening productivity bottlenecks and mounting risk exposure.

The question became: What if we didn't have to guess?

What if we could submit one prompt to multiple models, let them all compete, and have an automated system pick the absolute best output—every single time?

That's VeriGen.

What It Does

VeriGen is a Consensus-Verified Media Generator (CVMG) that transforms AI media generation from a gamble into a predictable, verifiable process.

Here's how it works:

One prompt in — You submit a single creative prompt, just like you would to any AI image generator.
Five models concurrently — Behind the scenes, VeriGen fans out to 5 different AI models simultaneously:
- OpenAI DALL-E 3
- GMI Cloud Seedream 5.0 Lite
- Google Imagen 4
- Replicate FLUX Schnell
- Replicate SDXL Turbo
Three-dimensional scoring — Each candidate image is evaluated across three critical dimensions:
- Quality: Visual fidelity, prompt adherence, technical execution
- Diversity: Uniqueness and variation across outputs
- Adversarial Robustness: Resistance to common failure modes and edge cases
Consensus winner selected — A deterministic state machine calculates a weighted consensus score, selecting the single best output.
Everything stored with provenance — All candidates and the winner are stored in Backblaze B2 with SHA-256-verified provenance manifests, creating a complete, auditable record of how every asset was generated.

One prompt. Multiple models. One verified winner. Every time.

How We Built It

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                    User Interface                           │
│              Next.js Frontend                               │
│          (Prompt input, gallery view)                       │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    API Backend                              │
│              FastAPI + Python                               │
│         (Orchestration, consensus scoring)                  │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Genblaze Pipeline                        │
│    ┌──────────────────────────────────────────────────┐    │
│    │  1. OpenAI DALL-E 3  ──┐                        │    │
│    │  2. GMI Cloud Seedream ─┼── Concurrent Fan-out │    │
│    │  3. Google Imagen 4   ─┤                        │    │
│    │  4. Replicate FLUX    ─┘                        │    │
│    │  5. Replicate SDXL                              │    │
│    └──────────────────────────────────────────────────┘    │
│                           │                                 │
│                           ▼                                 │
│              Consensus State Machine                        │
│    ┌──────────────────────────────────────────────────┐    │
│    │  Quality Score  │  Diversity Score │ Robustness │    │
│    └──────────────────────────────────────────────────┘    │
│                           │                                 │
│                           ▼                                 │
│         ObjectStorageSink (Backblaze B2)                    │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│              Backblaze B2 Cloud Storage                     │
│     All candidates + winner with SHA-256 manifests          │
└─────────────────────────────────────────────────────────────┘

Technology Stack

Layer	Technology	Why We Chose It
Orchestration	Genblaze SDK	Unified API across 5+ providers, built-in retries/timeouts, automatic manifests
Storage	Backblaze B2	S3-compatible, 11 nines durability, 99.9% uptime SLA, $0.006/GB with free egress
Frontend	Next.js	React-based, server-side rendering, easy API integration
Backend	FastAPI	Python async, automatic OpenAPI docs, type safety
AI Providers	OpenAI, GMI Cloud, Google, Replicate	Diverse model landscape, accessible APIs

Key Implementation Details

The Genblaze Pipeline — VeriGen leverages Genblaze's concurrent execution capabilities to fan out to 5 models in parallel:

from genblaze_core import Pipeline, Modality
from genblaze_gmicloud import GMICloudImageProvider
from genblaze_openai import DalleProvider
from genblaze_replicate import ReplicateProvider
from genblaze_google import GoogleImageProvider

pipeline = Pipeline("verigen-cvmg")

providers = [
    ("gmi-seedream", GMICloudImageProvider(), {"model": "seedream-5.0-lite"}),
    ("openai-dalle", DalleProvider(), {"model": "dall-e-3"}),
    ("google-imagen", GoogleImageProvider(), {"model": "imagen-4"}),
    ("replicate-flux", ReplicateProvider(), {"model": "flux-schnell"}),
    ("replicate-sdxl", ReplicateProvider(), {"model": "sdxl-turbo"}),
]

for name, provider, params in providers:
    pipeline.step(provider, prompt="{prompt}", modality=Modality.IMAGE, **params)

result = pipeline.run(prompt=user_prompt, max_concurrency=5)

The Consensus State Machine — A deterministic 7-state machine handles the scoring and selection process:

PENDING → GENERATING → VALIDATING → ADVERSARIAL_CHECK → SELECTING → STORING → COMPLETED

Hierarchical B2 Storage — All assets are organized with a structured key strategy:

runs/
  {tenant}/
    {date}/
      {run_id}/
        candidates/
          openai-dalle3/
            image.jpg
            metadata.json
          gmi-seedream/
            image.jpg
            metadata.json
          # ... 3 more models
        consensus/
          scores.json
          winner.jpg
        manifest.json

Provenance Manifests — Every run produces a SHA-256-verified manifest with complete provenance:

{
  "run_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "timestamp": "2026-07-17T14:30:00Z",
  "providers": [...],
  "candidates": [...],
  "consensus": {
    "winner": "openai-dalle3",
    "weighted_score": 0.87
  },
  "canonical_hash": "f1e2d3c4b5a6..."
}

Challenges We Ran Into

1. Standardizing Outputs Across Providers

Each AI provider returns images in different formats, resolutions, and quality levels. We had to normalize all outputs to a common format (JPEG, 1024×1024) before the consensus engine could evaluate them fairly.

Solution: We used Genblaze's unified asset handling to standardize outputs before scoring, with each provider adapter handling its own normalization.

2. Scoring Subjectivity

"How do you objectively score art?" was the biggest philosophical challenge. Artistic quality is inherently subjective. We solved this by focusing on technical criteria that can be quantified:

Quality: CLIP score (prompt-image alignment), image aesthetics models
Diversity: Perceptual hashing distance between candidates
Robustness: Detection of common AI artifacts (blurring, distortion, anatomical errors)

3. Provider API Reliability

During development, we experienced occasional timeouts and failures from different providers. Without Genblaze's retry mechanisms, this would have been a nightmare.

Solution: Genblaze's built-in retries and fallback chains meant we could handle failures gracefully. We also implemented per-provider timeouts to prevent hanging.

4. Cost Management

Generating 5 images per prompt gets expensive quickly. We needed a way to manage costs without compromising on quality.

Solution: We implemented step caching for identical prompts and used GMI Cloud credits (available to hackathon participants) to offset costs. We also store all candidates in B2 only for a limited period, with lifecycle rules auto-deleting older candidates.

5. User Experience

Waiting for 5 models to generate concurrently takes time. We needed to keep users engaged during the process.

Solution: We built a real-time progress indicator using Genblaze's streaming events, showing which models are generating and which have completed.

Accomplishments That We're Proud Of

🏆 Built a Production-Ready Consensus Engine

We didn't just build a demo—we built an architecture that can scale. The 7-state machine, hierarchical storage, and provenance system are designed for real-world production use.

🚀 Integrated 5 AI Providers with One API

Genblaze's provider-agnostic architecture allowed us to add 5 different models with minimal code. Adding a sixth model would take a single line change.

🔒 Created a Complete Provenance System

Every asset generated by VeriGen has a SHA-256-verified provenance manifest. This isn't just a nice-to-have—it's a compliance requirement for regulated industries and a trust builder for all users.

⚡ Achieved True Concurrent Generation

All 5 models generate in parallel, not sequentially. This means VeriGen delivers a consensus winner roughly as fast as a single model would generate.

💰 Built on the Most Cost-Effective Storage

Backblaze B2's $0.006/GB pricing with free egress up to 3x storage means VeriGen can store all candidates and manifests without worrying about egress surprise charges.

📊 Engineered a Deterministic Scoring System

Our 3-dimensional scoring (quality, diversity, robustness) provides objective, reproducible evaluation. The consensus algorithm is deterministic, ensuring the same prompt always produces the same winner.

🎯 Demonstrated Genblaze's Core Philosophy

VeriGen is a living demonstration that the pipeline is what lasts, not the individual models. As models evolve, VeriGen's pipeline will remain valuable.

What We Learned

1. Model Diversity is a Feature, Not a Bug

Different models excel at different things. DALL-E 3 produces photorealistic images but struggles with complex compositions. Seedream 5.0 Lite is excellent at artistic styles. Flux Schnell is fast but lower quality. By using all of them, VeriGen gets the best of all worlds.

2. Provenance is the Next Frontier

We started building VeriGen thinking quality was the problem. We quickly realized that provenance and trust are actually the bigger challenges. When we can prove exactly how an asset was generated, we unlock use cases that would otherwise be impossible—regulatory compliance, legal discovery, and enterprise adoption.

3. Genblaze is Production-Ready

We went into this hackathon thinking we'd need to build a lot of infrastructure ourselves. Genblaze handled retries, timeouts, manifests, storage integration, and streaming events out of the box. The Genblaze team has built something genuinely useful for production AI pipelines.

4. Backblaze B2 is a Hidden Gem

The S3-compatible API meant we could use familiar patterns. The pricing is unbeatable. And the always-hot storage means assets are immediately available for serving—no cold start delays.

5. Consensus is More Valuable Than Speed

Users don't just want fast generation—they want reliable generation. The extra 5-10 seconds for consensus scoring is worth it when you know you're getting the best possible output.

What's Next for VeriGen

Short-Term (Next 30 Days)

Priority	Feature	Description
✅	Video support	Extend consensus scoring to AI-generated video
✅	Audio support	Add text-to-speech and music generation to the consensus pipeline
✅	User accounts	Enable saved histories and personal galleries
✅	API access	Expose VeriGen as a REST API for integration

Medium-Term (3-6 Months)

Priority	Feature	Description
⭐	Model marketplace	Allow users to add their own models via provider adapters
⭐	Custom scoring weights	Let users tune quality vs. diversity vs. robustness
⭐	Batch processing	Generate hundreds of consensus-verified images in one pipeline
⭐	Feedback loops	User ratings adjust scoring weights over time

Long-Term (6-12 Months)

Priority	Feature	Description
🚀	Enterprise dashboard	Team workspaces, audit logs, compliance reports
🚀	CDN integration	Global delivery via Cloudflare/Fastly
🚀	C2PA integration	Embed provenance directly into assets for industry compliance
🚀	Multi-modal consensus	Combine image + video + audio consensus into one pipeline

The Vision

VeriGen will become the standard quality layer for AI-generated media. In a world where anyone can generate anything, VeriGen provides the confidence that what you're generating is actually good.

We see a future where VeriGen is:

Integrated into creative suites (Adobe, Figma, Canva)
Embedded in content management systems (WordPress, Contentful)
Used by regulated industries (healthcare, finance, legal)
Trusted by enterprises as the only way to generate AI media at scale

Built With

Backblaze B2 — S3-compatible cloud object storage for all generated assets and manifests
Genblaze — Python SDK for orchestrating generative media workflows across providers
OpenAI DALL-E 3 — Image generation
GMI Cloud Seedream 5.0 Lite — Image generation
Google Imagen 4 — Image generation
Replicate FLUX Schnell — Fast image generation
Replicate SDXL Turbo — Fast image generation
Next.js — Frontend framework
FastAPI — Python backend API
Python — Consensus engine and orchestration

Try It Yourself

VeriGen is open source and available for testing.

GitHub: github.com/verigen/verigen
Live Demo: verigen.app
Documentation: docs.verigen.app

The VeriGen Team

We're a team of developers who believe AI should be reliable, verifiable, and trustworthy.

[Your Name] — Lead Developer, Consensus Engine
[Your Name] — Frontend, UI/UX
[Your Name] — Genblaze Integration, B2 Storage
[Your Name] — Scoring Algorithm, Data Analysis

"VeriGen submits your prompt to 5 AI models concurrently, scores each on quality/diversity/robustness, picks the consensus winner, and stores all candidates + provenance in B2 via Genblaze."

One prompt. Multiple models. One verified winner. Every time.

Appendix: Key Research Sources

Source	Key Insight
Markup AI Survey	80% manual review, 97% trust gap
Forrester AI Survey	$300K+ avg GenAI investment
Gartner TrustOps	50% enterprises by 2027
IBM Institute	60% lack AI approach
Backblaze B2	11 nines durability, $0.006/GB
Genblaze Docs	Pipeline-first, provider-agnostic

Built With

aws/gcp/azure
backblaze
cloud
docker/kubernetes
fastapi
genblaze
gmi-cloud
langsmith
next.js
oauth2
openai
opentelemetry
railway
replicate
rest
sqlite

Updates

Lucy Low started this project — Jul 28, 2026 12:15 PM EDT

Leave feedback in the comments!

Log in or sign up for Devpost to join the conversation.