Vanta Studio

The agentic creative workspace that transforms ideas into production-ready AI media

Comment

Inspiration

Every creative professional in 2026 is drowning in tabs.

You open Midjourney to generate an image. Then Runway to animate it. Then ElevenLabs to add a voiceover. Then Tripo3D to build a matching 3D asset. And when you're done, your work is scattered across four different dashboards, four different accounts, and four different pricing plans — with zero unified audit trail of what you made, which AI model made it, or what prompt you used.

Generative AI has given creative teams superpowers. But the workflow is completely broken.

We started Vanta Studio because we realized the tools were all amazing — but the infrastructure holding them together was virtually nonexistent. There was no single "home" for AI-generated creative media. Files lived in chat histories. Assets expired. Prompts were forgotten. Projects had no memory.

We asked a simple question: What if your entire AI creative pipeline lived in one place, and every single thing you generated was permanently, safely vaulted to the cloud the moment it was created?

That question became Vanta Studio.

What it does

Vanta Studio is a unified, chat-driven AI creative workspace that lets users generate images, video, audio, and 3D models through a single interface — with every asset automatically secured in a private Backblaze B2 cloud vault.

Here's the core workflow in three steps:

Vanta Studio UI

1. Create a project and open the chat Users create a named project (e.g., "Nike Spring Campaign") and immediately land in a sleek, dark-mode chat interface. They type a natural language prompt like "Generate a slow-motion product shot of a running shoe on a neon-lit track" and select the media type (image, video, audio, or 3D).

2. AI generates the asset The backend routes the request to the appropriate provider — Runway Gen-4.5 for video, ElevenLabs for audio, Tripo3D for 3D models, or Pollinations.ai for images. The UI shows a premium animated skeleton loader while the asset is being generated asynchronously.

3. Every asset is automatically vaulted The moment generation completes, the raw bytes are streamed directly into a Backblaze B2 bucket. A provenance JSON sidecar file is stored alongside it, containing the exact prompt, model version, provider, and timestamp. The user receives a pre-signed URL back in the chat to view their asset immediately.

The Cloud Vault dashboard lets users see their total storage used, project count, and recent uploads — all pulled live from B2. Assets can be browsed in the Asset Library, bundled into a ZIP file for download, or shared via a pre-signed public URL — all in one click.

Vanta Studio is the first creative workspace that treats Backblaze B2 not just as storage — but as the actual database.

How we built it

Architecture: B2 as the Ground Truth

Vanta Studio Architecture

The most important architectural decision we made was to eliminate a traditional database entirely. There is no SQL, no Redis, no Firebase. Backblaze B2 IS the project management system.

  • projects.json — stored in B2 root — acts as the live project index.
  • Every generated asset (.mp4, .mp3, .glb, .png) is uploaded as a B2 object, organized into virtual projects/{name}/assets/ directories.
  • Every asset has a JSON sidecar file stored alongside it with full provenance metadata.
  • The frontend is completely stateless — it fetches fresh pre-signed URLs from the B2 vault on every page load. Nothing expires from the user's perspective.

The Genblaze Orchestrator (genblaze_client.py)

The AI routing layer is a single GenblazeOrchestrator class that abstracts all four providers behind one interface. The FastAPI router calls orchestrator.generate_video(prompt) or orchestrator.generate_audio(prompt) — it doesn't care which SDK is running underneath.

For async providers like Runway (video) and Tripo3D (3D), the orchestrator initiates the generation task and then drops into a non-blocking asyncio.sleep polling loop, monitoring task status until completion. This means the backend handles multiple concurrent generations without blocking.

Tech Stack

Layer Technology
Frontend React 19 + Vite 8
Styling Vanilla CSS (dark mode glassmorphism, custom micro-animations)
Backend FastAPI (Python 3.11)
AI Routing runwayml SDK + httpx async client
Cloud Storage Backblaze B2 via boto3 (S3-compatible)
Deployment Render (backend) + Vercel (frontend)

Challenges we ran into

1. Making B2 behave like a database B2 is object storage — it wasn't designed to be queried like a database. We had to design a careful schema using object key prefixes (projects/{name}/assets/) and a master projects.json index file to simulate relational project management. Keeping this index in sync with individual asset uploads required careful ordering and error handling in the backend.

2. Async polling without freezing the server Runway and Tripo3D are "fire-and-poll" APIs — you start a task, then check back every few seconds until it completes. Running this in a naive synchronous Python loop would block the entire FastAPI server. We rewrote all polling logic using asyncio.sleep() and await throughout, ensuring the server remains fully responsive during long-running generation tasks.

3. Pre-signed URL expiry B2 pre-signed URLs expire after 24 hours. If a user returns to an old project, all their asset URLs would be broken. We solved this by storing media_key (the permanent B2 object key) in every provenance JSON file. When the frontend requests the asset library, the backend automatically re-generates fresh pre-signed URLs on every list call — making assets feel permanently accessible even though the URLs rotate.

4. CORS across multi-platform deployment Deploying the backend to Render and the frontend to Vercel meant dealing with cross-origin requests in production. We had to carefully configure VITE_API_URL environment variables in Vercel and ensure the FastAPI CORS middleware accepted the Vercel domain. The solution was to use import.meta.env.VITE_API_URL || 'http://localhost:8000' in every frontend API call, making the app work identically in both local dev and production.

Accomplishments that we're proud of

B2 as the architecture, not an add-on — We didn't bolt Backblaze on at the end. We designed the entire system around B2 from day one, and it resulted in a genuinely novel architecture: a stateless frontend backed by an object-storage "database."

Four AI providers behind one interface — Runway, ElevenLabs, Tripo3D, and Pollinations.ai all work seamlessly together, routed through a single orchestrator class. Users never see API complexity.

Production-quality UI — We built a full dark-mode design system with glassmorphism effects, custom skeleton loaders with shimmer animations, and a custom-built audio player with animated waveform bars — from scratch in vanilla CSS.

Truly permanent creative provenance — Every single generation has an immutable JSON record in B2 containing the exact prompt, model, timestamp, and provider. This is something no other AI creative tool offers natively.

Fully deployed, live in production — Both the FastAPI backend (Render) and React frontend (Vercel) are live, connected, and serving real traffic right now.

What we learned

  • Object storage can replace a database — when you design carefully around key prefixes and index files, B2 is a remarkably powerful and cheap alternative to a traditional database for media-heavy applications.
  • Async Python is non-negotiable for AI APIs — any AI provider that uses a polling model (Runway, Tripo) will completely break a synchronous server. We now architect all AI backends async-first.
  • Provenance metadata is underrated — storing the prompt and model alongside every generated file turns out to be incredibly useful. Being able to look at an asset 6 months later and know exactly how it was made is something users genuinely care about.
  • Backblaze B2's S3 compatibility is a superpower — being able to use the industry-standard boto3 library against B2 meant zero SDK learning curve and full access to the mature AWS ecosystem of tooling.

What's next for Vanta Studio

Real-time collaboration — Multiple users working inside the same project vault simultaneously, with live updates powered by WebSockets.

Cross-asset pipelines — Automatically chain generations: generate an image → animate it into video → generate a matching voiceover → bundle into a final production package in one prompt.

Prompt history & regeneration — Since every provenance JSON is permanently in B2, we can build a "remix" feature: click any past asset and regenerate a variation of it with the original prompt pre-filled.

Analytics dashboard — Track which prompts, models, and media types your team uses most — all computed directly from the provenance metadata in B2.

Team accounts & SSO — Enterprise teams managing shared B2 buckets with role-based access to specific project folders.

Vanta Studio — Built for the Backblaze Generative Media Hackathon 2026

Built With

  • 3d-model
  • b2
  • backblaze
  • cloud
  • creative
  • image-gen
  • runway
  • workspace
Share this project:

Updates