Assetflow

• 

  Landing page

• 

  Workflow create

• 

  workflow page

• 

  Assets management

• 

  Provenance

Inspiration

Every few months a new model makes the current favourite obsolete, and apps built tightly around a single model age just as fast. What actually lasts is the workflow layer: how you chain models together, pass media between them, and keep a record of what happened at each step. We wanted to build the app around that layer instead of around any one model, and GenBlaze gave us exactly the right foundation for it.

The second driver was provenance. Anyone doing creative AI work ends up with hundreds of generations scattered across tabs and tools, with no reliable answer to basic questions: what prompt made this, which model, what edits came after. Worse, the moment a file is downloaded and shared, its history is gone for good. We set out to make history a core feature of the product itself: kept safely in B2, viewable as a graph, and traveling inside the exported file.

What it does

AssetFlow is a visual workflow studio for generative media. You drop nodes on a canvas (text, image, video, music, speech, SFX, lipsync, 3D, LLM, upload, composition), wire them together, and run the whole graph. One brief can flow through an LLM, into an image model, into a video model, get scored with music, and end as a composited MP4. Swapping providers is a dropdown, not a rewrite.

The canvas. Ports are model-aware: a video model that accepts a start frame shows a start-frame port, a lipsync model shows avatar + speech ports. Runs stream live over SSE, so each node shows queued / generating / progress as it happens. Nodes keep a carousel of takes, and you can set fallback models that auto-retry a failed generation on another model.

Agent mode. Describe what you want in the prompt bar and a workflow-builder agent asks one round of quick questions, then proposes a full graph on the canvas. It only knows models that are actually configured, so it never proposes something that can't run. Quick chains do the same for simple image/video jobs without a conversation.

Editing, not just generating. A multi-track composition node (video bed + audio lanes with faders) renders through ffmpeg. A captions tool transcribes with ElevenLabs Scribe and burns styled, draggable captions. Magic Text decomposes a poster into an editable text layer so you can retype the actual text in an AI image. An Edit Studio adds camera-angle and relighting edits to any take. 3D generations get a real orbit viewer.

Provenance, end to end. Every run writes a hash-verified GenBlaze manifest to B2. Any asset in the library can show its full lineage graph across runs, one hop per generation or edit. It can also be reconstructed back into the exact canvas graph that made it, or remixed: the agent takes the reconstructed chain and reworks it for a new brief. Exports can be stamped: the derivation chain is written into the file's own metadata (PNG/JPEG/WebP/MP4/MP3). Anyone can drop a stamped file on our public /inspect page, no account needed, and see where it came from. If a platform stripped the metadata, we fall back to a sha256 match against the library.

AI search. Every asset is auto-enriched in the background (vision captions, tags, OCR, palette for images; keyframe analysis for video) and embedded into one vector space, so you can search your whole library, images, video and audio together, by meaning or by keyword.

How we built it

Stack. Next.js 16 (App Router, React Flow canvas) + a FastAPI backend in one monorepo. Postgres for the queryable index, Clerk for auth. The backend is split into a pure graph compiler (no I/O, and the same function powers canvas validation and run planning), a GenBlaze engine layer, a YAML-driven provider catalog, and Postgres-as-queue workers (FOR UPDATE SKIP LOCKED + leases, so a killed worker's runs get picked up again).

GenBlaze is the engine. It's the only place in the codebase that talks to AI providers. The compiler turns a canvas graph into GenBlaze steps; GenBlaze handles provider adapters, fallback models, streaming events, hash-bound manifests, and the B2 sink. Adding a provider is a YAML entry plus a connector install, and the canvas, agent, and provenance features pick it up automatically. We run its ObjectStorageSink with hierarchical keys (so the bucket stays browsable) and lazy transfer (so users see results from the provider CDN while the archival upload to B2 finishes in the background).

B2 is the system of record. Postgres is just an index over it. The bucket is private; the app stores only durable URLs and mints short-lived presigned URLs per request. Manifests, generated media, upload originals, enrichment metadata (written as JSON right beside each object), caption sidecars, and Magic Text layers all live in B2. The manifest endpoint deliberately re-reads and re-verifies from B2 instead of echoing our own database row, and lineage can be rebuilt from the bucket alone if the database disappears.

Providers & models. 6 providers, 30+ models through one pipeline:

• GMI Cloud does the heaviest lifting for us: Seedance 2.0 / Kling v3 for video, Seedream 5.0 for images, Kling Lip Sync, and Hunyuan 3D Pro for 3D. On top of that, its OpenAI-compatible endpoint powers our workflow-builder agent (Gemini 3.6 Flash) and vision enrichment (Gemini 3.1 Flash-Lite). One provider covering generation, chat, and vision made a real difference.
• Replicate: Nano Banana Pro/2, GPT Image 1.5/2, Sora 2, PixVerse Lipsync, Kimi K2.6 (LLM node), Qwen edit models (camera angles / relight), Ideogram Layerize (Magic Text).
• Runway: Gen-4.5, Gen-4 Turbo, Gen-4 Image, plus Runway Recipes (ad localization, marketing stock).
• Luma: Ray 3.2 (video), Uni-1 (image).
• ElevenLabs: Eleven v3 / Flash speech, Music v2, sound effects, Scribe transcription.
• Decart: Lucy 2.5 video editing, virtual try-on, image edit.

Accomplishments that we're proud of

• The full provenance loop actually closes. Generate, then a hash-verified manifest in B2, then the lineage graph, then a stamped export, then the public verify page. A file you made in AssetFlow can prove its own history on another machine, with no account.
• Reconstruct and Remix. Turning a finished asset back into its editable graph, then handing that graph to an agent to rework, is the feature we haven't seen anywhere else.
• One compiler, three front doors. The agent, quick chains, and hand-drawn canvas all produce the same graph spec and go through the same validation. No drift.
• It's production-shaped, not demo-shaped. Crash-safe job queue, idempotency keys, replayable SSE event log, RFC 9457 errors, cancellation and retry, a b2_doctor script that names your exact misconfiguration, and 20 credential-free unit test files.

What we learned

• Build around the workflow, not the model. We swapped models several times during the hackathon (including our house defaults) and nothing downstream changed: the manifest format, the canvas, the search, and the provenance all held. Betting on the orchestration layer paid off in a very concrete way.
• Treat the bucket as the database. Putting metadata and manifests beside the media in B2, with Postgres as a rebuildable index, made the whole system simpler and more honest. If a claim matters, verify it from storage, not from your own cache.
• Declare capabilities server-side. Model-gated ports, a YAML catalog, and an agent that only sees configured models eliminated a whole class of "this can't actually run" bugs.

Built With

• b2
• backblaze
• clerk
• decart
• elevenlabs
• fastapi
• genblaze
• gmicloud
• luma
• nextjs
• replicate
• runway
• supabase