AURA: Authenticated, Unalterable Record of Assets

One backbone for every kind of AI media. Nine pipelines, one guarantee: every output is born sealed, provenance-stamped, content-addressed to Backblaze B2, and locked in a tamper-evident WORM ledger.

Comment

Inspiration

Two things collided for us.

First, the flood of generative-media tools, one for video, one for voice, one for images, each a silo, none of them able to answer the question that is about to become law: "Is this real, and how was it made?" The EU AI Act's transparency obligations (Article 50) become applicable around August 2026, and AI-content disclosure is shifting from a nice-to-have to a mandate. We didn't want provenance bolted on at the end. We wanted it to be the first thing every output is born with.

Second, we were tired of re-plumbing the same orchestration every time a new model shipped. Swapping Sora, Runway, or Veo shouldn't mean rewriting a pipeline.

So we made a bet: don't build nine demos, build one production backbone and prove it nine ways.

What it does

AURA (Authenticated, Unalterable Record of Assets) is a creator-first studio where any generative-media pipeline runs through one hardened path (build, run, seal, lock, verify) and every output is born sealed: provenance-stamped with a genblaze Manifest, content-addressed into Backblaze B2, and written to a separate Object Lock (WORM) ledger that makes the record physically immutable.

Nine pipelines share that one core:

Pipeline Category What it does
Verified Generation (flagship) create prompt to image to video to voiceover, all sealed
PolyCast transform localize/dub a script into many languages
ReelForge create brief to finished ad, with an agentic retry loop
Director create best-of-N candidates, ranked
Audible transform document to accessible narrated audio
AdaptiveAds create one brief to a per-segment variant matrix
PreFlight govern same prompt across models, cost/latency compared
MediaMind govern semantic search over everything you've sealed
NewsProof govern verify and tamper-check any incoming media

Every result ships with a provenance "nutrition label," an embeddable Verified badge, and a public Verifier. Drag any sealed file in and get a green check. Change a single byte and get a red cross, Tampered. That contrast, proof versus forgery, live, in two seconds, is the whole thesis in one gesture.

How we built it

  • genblaze is the orchestration and provenance SDK at the heart: Pipeline / AgentLoop / Manifest / ObjectStorageSink / SmartEmbedder. We treated its primitives as load-bearing and never reinvented them.
  • A uniform PipelineSpec registry. Every pipeline is a small config object with a declarative input form and a build() that returns a genblaze Pipeline or AgentLoop. The runner, the auto-generated Studio form, the sealed result view, and the verifier are written once against this contract, so a tenth pipeline is about 20 lines, not a new app.
  • A trust and storage spine on B2. A single seal_and_store() is the mandatory exit path for every run: build the manifest, embed it into the media file, write assets to a content-addressable B2 bucket, then write the manifest JSON to a second, Object-Lock-protected bucket with a COMPLIANCE retention date.
  • FastAPI (async) backend with a SQLAlchemy 2.0 index that sits over the B2 source of truth (B2 holds the authoritative bytes and locked manifests; the DB just makes the Studio and Library fast). Live progress streams over SSE straight from genblaze's pipeline events.
  • Next.js (App Router) plus TypeScript studio, consuming the @genblaze/spec manifest types so the UI and the Python models never drift.
  • Offline mode. genblaze's MockProvider runs the entire platform, including B2-style content-addressing and tamper detection, with zero API keys, so the demo is always green and any missing provider key gracefully falls back per-capability.

Challenges we ran into

  • Making "nine pipelines" read as depth, not breadth. The fix was architectural: push all the polish into the shared core so every pipeline inherits the same hardened run/seal/verify experience. Breadth becomes the proof point ("one backbone, proven nine ways") instead of nine half-demos.
  • Object Lock is irreversible by design. WORM objects can't be deleted until retention expires, which is exactly the point, and a hazard in dev. We separated a short-retention dev ledger from the long-retention production ledger via .env profiles so testing immutability doesn't accumulate undeletable objects.
  • Provenance without CA-backed C2PA signing. Sealing proves an existing asset is untampered, but a determined adversary could mint a fresh valid manifest for their own media. Our mitigation: the immutable, timestamped B2 Object Lock ledger is an independent source of truth to diff against, which defeats the in-scope threat (altering a published asset's provenance). Full C2PA certificate signing is a documented seam (c2patool), already isolated in the code.
  • Keeping the live demo bulletproof. On-stage API rate limits and outages are real. Per-capability mock fallback means a missing key or a flaky provider never breaks a run.

What we learned

  • Provenance is dramatically more compelling as an architecture (a mandatory exit path every run flows through) than as a feature you can forget to call.
  • Content-addressable storage hands you cross-pipeline dedup for free, which is a storage company's favorite story.
  • One well-designed contract (PipelineSpec) beats nine bespoke UIs, for both implementers and users.

What's next

  • Full C2PA certificate signing at the already-isolated c2patool seam.
  • Multi-tenancy: the tenant_id placeholder is already threaded through models, storage keys, and the API.
  • pgvector-backed semantic search for MediaMind at scale.
  • Webhooks and a hosted verification API so any third party can check an AURA-sealed asset.

Built on genblaze plus Backblaze B2 for the Backblaze Generative Media Hackathon. MIT licensed.

Built With

Share this project:

Updates

Submission history