• 

• 

ReelProof — Project Story

Inspiration

Short-form video has become one of the fastest ways for a small brand or creator to explain an idea, launch a product, or reach a new audience. The workflow is usually fragmented: one tool writes the script, another generates images, another makes music, and a video editor assembles the result. When something looks wrong, it is difficult to know what happened or reproduce the final video.

We wanted to build a creator tool that treated generated media as something that should be inspectable, not disposable. ReelProof was inspired by a simple question: can an AI-generated reel explain how it was made and prove that its assets were not silently changed? That led us to combine GenBlaze's provider orchestration and provenance model with Backblaze B2 as a durable system of record.

What it does

ReelProof turns a topic and an optional product image into a ready-to-post vertical reel. A creator can choose between:

• A fast captioned slideshow made from generated stills.
• A POV montage that chains generated images into image-to-video clips.

The system creates a structured beat plan, generates each visual, sends it to a separate vision judge, and uses the judge's feedback to repair weak results. The loop is bounded, so a failed visual can be improved without creating unbounded cost or latency. Captions are burned with ffmpeg for predictable legibility, and optional music and narration complete the reel.

Every upload, generation attempt, captioned frame, audio file, clip, and final MP4 is stored with a GenBlaze manifest, provider/model metadata, SHA-256 hashes, and parent-run lineage. The verification API reloads the manifest from B2 and checks its integrity, so the creator can inspect the path from input to final deliverable.

How we built it

The frontend is a React/Vite creator workspace. A FastAPI backend owns campaign state and starts leased background workers; progress is streamed to the browser with SSE and replayed from SQLite when a client reconnects.

GenBlaze is the execution layer:

• Pipeline runs image, audio, narration, ingest, and chained image-to-video steps.
• AgentLoop connects generation to the vision evaluator and records the reject → refine → pass history.
• ObjectStorageSink and genblaze-s3 write assets and canonical manifests directly to Backblaze B2.
• RetryPolicy, fallback models, timeouts, and video checkpoints make provider failures recoverable.

We also built project-owned provider integrations instead of hiding vendor calls in application code. CloudflareImageProvider implements GenBlaze's SyncProvider contract for Cloudflare Workers AI, including model registration, image conditioning, response normalization, and typed provider errors. StabilityAudioProvider extends the GenBlaze Stability provider to submit Stable Audio's multipart-only request format and normalize Windows file URLs. A small Groq adapter adds strict structured output, retry-after handling, token pacing, and observable physical attempts for the planner and vision judge.

The remaining integrations use GenBlaze providers for GMICloud image-to-video and ElevenLabs narration. Local ffmpeg handles deterministic caption rendering, compositing, and audio muxing after those runs complete.

Challenges we ran into

The hardest part was making several providers behave like one reliable pipeline. APIs differed in authentication, request shapes, response formats, polling behavior, and error codes. Cloudflare could return raw image bytes or base64 JSON; Stable Audio required multipart form fields; and a malformed Windows file:// URL could prevent a generated asset from being found later.

We also had to make private B2 assets usable by external providers without giving up durable provenance. The solution was to keep stable unsigned URLs in manifests and issue short-lived signed URLs only to the browser, vision model, or ffmpeg process that needs to read an asset.

Long-running POV renders created another reliability problem. A worker restart must not submit the same billed video request twice, so provider job IDs are checkpointed and polling can resume. SQLite leases and replayable SSE events give the single-node deployment a predictable recovery story.

Finally, generated images often contain unreadable text, which is why captions are rendered locally. Escaping ffmpeg's drawtext syntax, preserving safe zones, and keeping all output assets in the same provenance graph took more care than expected.

Accomplishments that we're proud of

• Built a complete generate → judge → refine → assemble → verify workflow rather than a one-shot generation demo.
• Used GenBlaze as the real orchestration and provenance layer, including Pipeline, AgentLoop, provider fallbacks, sinks, and manifest verification.
• Added custom GenBlaze providers for Cloudflare image generation and Stability Audio compatibility.
• Made provider selection interchangeable: Cloudflare can be used for stills while GMICloud handles POV video, without changing the campaign pipeline.
• Preserved every attempt and evaluator decision through parent_run_id lineage.
• Delivered durable B2-backed assets, signed playback URLs, reconnectable progress streams, and a verification endpoint.
• Kept captions deterministic and legible by rendering them with ffmpeg instead of asking image models to draw text.

What we learned

We learned that a provider abstraction is valuable only when it normalizes more than method names. Inputs, outputs, capabilities, retries, error taxonomies, cost metadata, and asset URLs all need a consistent contract. We also learned that provenance has to be designed into the first pipeline step; adding hashes and lineage after assembly would lose the most useful context.

The project reinforced the difference between application retries and provider retries. A retry must be bounded, observable, and aware of whether a remote job was already submitted. We also learned that private object storage is compatible with AI workflows when durable URLs and temporary read URLs are treated as separate concerns.

What's next for ReelProof

The next step is production deployment on a persistent VPS with Dokploy, followed by replacing the single-node SQLite/in-process worker with PostgreSQL and a managed job queue for horizontal scale. We also want to add:

• More image, video, and audio providers that can be selected per campaign.
• A richer creator editor for beat-level prompt and caption overrides.
• C2PA or similar signed disclosures for distribution outside the verification API.
• Better cost, latency, and quality dashboards built from GenBlaze's optional lineage analytics.
• Provider-backed moderation and organization-level policies for teams and brands.

The long-term goal is a media studio where creators can move quickly while still being able to answer: which model made this, what changed during refinement, and can I verify the final file?

Built With

• b2
• cloudlfare
• fastapi
• genblaze
• gmi
• python
• react
• shadcn
• tailwind
• vite