• 

Inspiration

I was reading the EU AI Act's Article 50 late one evening in June and something clicked. On August 2, 2026 — a date that landed exactly one day before this hackathon's submission deadline — every provider and deployer of generative AI on the EU market becomes legally required to mark AI-generated content in a machine-readable format and detectable as artificially generated. The penalty for getting it wrong: €15 million or 3% of global annual turnover.

Then I opened Backblaze Genblaze's docs and read trust-modes.md. Their own roadmap laid out three modes: Mode 1 (integrity hash) shipping today, Mode 2 (Ed25519 signing) not yet built, Mode 3 (C2PA standards-verifiable) not yet built. Backblaze was telegraphing, in their own SDK documentation, the exact primitives Article 50 was about to make legally mandatory.

The gap was unmistakable. Adobe Content Credentials locks you into Adobe's stack. Resemble AI does voice only. Truepic focuses on citizen journalism. Kontainer bolts watermarks onto existing DAMs after the fact. Nobody had wrapped the entire multi-provider generation pipeline with signing, embedded provenance, tamper-evident storage, and public verification in one gateway — priced and shaped for the mid-market EU companies who'd need an answer in weeks, not quarters.

Article 50 wasn't a compliance problem waiting for a lawyer. It was a systems problem waiting for infrastructure. ATTEST is that infrastructure.

What it does

ATTEST is a compliance-grade gateway for AI-generated media. Every asset that leaves the pipeline ships with:

• A cryptographically Ed25519-signed provenance manifest binding the asset's SHA-256 hash, model, prompt, parameters, and timestamps into a single verifiable record
• Tamper-evident storage on Backblaze B2 under Object Lock, so the audit trail cannot be altered after the fact
• A public verifier anyone can hit — no login, no account — to check any asset URL and get a green Certificate of Provenance or a red tamper alert in seconds

The demo walks through four beats. First, the Console accepts a brief and runs a real Genblaze pipeline on GMI Cloud — DeepSeek-V4-Pro classifies the request, Seedream generates the image, our custom ComplianceSink signs the manifest and writes to B2. Second, the public verifier fetches the asset and manifest, checks the Ed25519 signature and the hash, and returns a Certificate of Provenance showing the signer's public key and the B2 Object Lock status — exactly what an EU auditor will ask for. Third, the tamper playground flips one pixel of the image. The hash breaks. The signature invalidates. The seal goes red in real time. Fourth, we close on the upstream Genblaze PR — Mode 2 Ed25519 signing, shipped to Backblaze's SDK itself during the hackathon.

Provenance is not a promise. It is a proof.

How we built it

Frontend is Next.js 14 with Tailwind. Two surfaces: the Compliance Console for the operator, and a public verifier that runs entirely off durable B2 URLs — no login, no server session, judge-pasteable. An SSE-driven pipeline visualizer streams each step of the compliance run left-to-right with a live B2 operations sidebar, so viewers see the primitives working rather than reading about them.

Backend is FastAPI wrapping Backblaze Genblaze. The compliance logic lives entirely inside a custom ComplianceSink subclass of Genblaze's Sink, so signing, hashing, manifest construction, and B2 upload are one atomic pipeline step rather than an afterthought. Every generation writes a signed manifest under B2 Object Lock. Every state transition — generated, signed, uploaded, verified, tampered — writes an event to the audit log.

The Genblaze pipeline runs a real multi-step chain on GMI Cloud: DeepSeek-V4-Pro classifies the brief (checking for deepfake risk and Article 50(4) public-interest text categories at cents per call, so the $5 GMI credit stretches far), then Seedream 5.0-lite generates the image. Fallback chains are configured on each Step so a provider stall doesn't kill the run — the reactive architecture pattern Genblaze's product team publicly said would define winning submissions.

The compliance primitives are the heart of the project. Ed25519 signing over canonical-JSON manifests using PyCA cryptography — audited, non-exotic, court-defensible. SHA-256 binding between the manifest and the asset bytes. A manifest schema that mirrors C2PA claim structure so full C2PA library integration is a drop-in future step rather than a rewrite.

Backblaze B2 is doing real work at every stage. Object Lock on signed manifests provides the tamper-evident storage layer that makes the compliance claim legally meaningful. Event Notifications drive the audit log without polling. Lifecycle Rules retire draft assets while preserving signed manifests indefinitely. Durable URLs power the public verifier — an Article 50 audit that arrives three years from now still resolves against the original B2 URL, and the manifest still verifies. Four B2 features, each doing necessary work, none decorative.

The upstream contribution. During the hackathon we forked backblaze-labs/genblaze, implemented the Mode 2 Ed25519 signer per Backblaze's own trust-modes.md design, added a Signer abstract base, an Ed25519Signer concrete implementation, a Manifest.verify_signature(public_key) method, genblaze sign and genblaze verify CLI commands, unit and integration tests, and updated the trust-modes documentation moving Mode 2 from roadmap to ships. Every future builder on the SDK now inherits what we shipped this month.

Challenges we ran into

The scope temptation. Every audit of the codebase revealed features we could add — full C2PA library integration, TrustMark pixel watermarking, AssemblyAI hash-verified transcripts, AudioSeal, VideoSeal, multi-tenant workspace UI, Postgres migration. We deferred all of them. The judgment call was hard: the audits were correct that these were missing, but the demo script was the real spec, and every hour spent on a deferrable feature was an hour stolen from making the four beats of the demo work end-to-end on live URLs. The discipline of writing "no" was harder than the code.

A $5 GMI credit budget. Real generation costs real money. We had to design a pipeline where the expensive step (image generation on Seedream) ran once for the pinned hero asset, while the cheap step (DeepSeek classification at cents per call) could run repeatedly during development. Every architectural decision had a budget dimension.

Backblaze B2 native SDK versus Genblaze's abstraction. Genblaze's ObjectStorageSink provided a clean interface, but Object Lock configuration required dropping down to the native b2sdk. We built a thin wrapper that lets the compliance layer apply Object Lock parameters on top of what Genblaze writes — preserving the SDK's abstraction for regular objects while giving the compliance-critical manifests the tamper-evident treatment they legally need.

The temptation to fake the tamper beat. The most demo-hostile part of the project was tamper detection. It would have been easy to hardcode a red state and move on. Instead we built a real tamper.py that downloads the asset, re-encodes it via Pillow, re-uploads to B2, and lets the verifier fail honestly against the mismatched hash. When a judge pastes the tampered URL themselves, the red seal is real.

Working from Lagos while targeting an EU regulatory deadline. Distribution to the actual customer — mid-market EU marketing and compliance teams — is a real question a Nigerian solo builder can't answer with proximity. We treated the hackathon submission as the top of a public-writing funnel instead: dev.to posts and LinkedIn long-form on Article 50 implementation, so that when EU compliance teams search for a reference implementation in the weeks after August 2, ATTEST is what they find.

Accomplishments that we're proud of

• A live, judge-pasteable public verifier at attest-black-two.vercel.app that anyone can hit, right now, with no login. Most hackathon submissions are localhost demos. Ours is a URL you can send to a stranger.
• Real end-to-end generation on real infrastructure — GMI Cloud DeepSeek + Seedream, Backblaze B2 with native b2sdk, no mocked provider calls in the winning path.
• A live tamper detection loop where flipping one pixel produces a red seal in the verifier in real time. This is the emotional peak of the demo and it is not narration.
• An upstream contribution to Genblaze itself — the Mode 2 Ed25519 signer, implemented against Backblaze's own published trust-modes roadmap. Every builder on the SDK inherits it going forward.
• 12 passing tests on the backend, continuous integration green, failsafes on every pipeline step. Not a throwaway demo — production-minded from the first commit.
• A polished Console UI with an SSE-driven pipeline visualizer, audit log, asset thumbnails, and a lineage tree — showing the compliance workflow rather than describing it.
• Written scope discipline. Multiple audits over the build. Every deferred feature is documented in the README with an honest rationale. Judges reading the codebase see intentional scope, not accidental gaps.

What we learned

Regulatory deadlines are engineering deadlines. When a specific date creates a specific legal obligation, the market shape becomes readable. Article 50's August 2 enforcement date wasn't background context for ATTEST — it was the product spec. The Code of Practice's explicit reference to C2PA, multi-layered marking, and machine-readable provenance told us exactly which primitives to build.

Provenance is a systems problem, not a cryptography problem. Ed25519 signing takes forty lines of Python. The hard parts are: making the manifest canonical so signatures survive JSON re-encoding, binding the manifest to the asset bytes so tampering breaks verification, wrapping the whole thing in a Sink so signing happens as a pipeline step rather than a bolt-on, storing the manifest somewhere legally tamper-evident, and giving anyone a URL they can paste to check. Any one of those alone is a feature. All five together is a product.

A hackathon can be the top of a distribution funnel. Writing about the build publicly during the hackathon — explaining Article 50, the Mode 2 signer implementation, the tamper detection loop — created content that will keep working long after judging closes. The technical proof and the market positioning were built in parallel.

Backblaze Genblaze is architected for exactly this deployment shape. The changelog Backblaze published mid-June — hash-verified AssemblyAI transcripts, per-tenant step cache isolation, resource cleanup on teardown, SSRF protection, refusing manifests without a SHA-256 — was reading like a specification for the exact product we were building. The SDK didn't need to be bent to serve the compliance use case. It was already shaped for it.

What's next for ATTEST

Full C2PA library integration. The manifest schema is already C2PA-compatible in structure. Landing the Rust-backed c2pa-python binding into the ComplianceSink moves ATTEST from Mode 2 (signed) to Mode 3 (standards-verifiable) — the last item on Genblaze's own trust-modes roadmap, and the item the EU Code of Practice explicitly names.

Multi-modal watermarking. TrustMark for images has a clean integration path. AudioSeal and VideoSeal from Meta AI research add invisible marking that survives compression for the audio and video modalities. Each layer adds redundancy to the Article 50 marking requirement.

Bidirectional provenance. Right now ATTEST attests generation. AssemblyAI's hash-verified transcripts with word-level timings open a path to attesting human origin — signed audio depositions, executive communications, podcast verification. ATTEST V1 answers "is this AI?". V2 answers both "is this AI?" and "is this really you?".

Editorial review workflow. Article 50(4) provides an exemption for AI-generated text on matters of public interest if a human reviewer bears editorial responsibility. ATTEST already tracks parent_run_id lineage through Genblaze; the next step is a full editorial review queue where compliance officers approve or reject iterations, and every decision is signed and archived.

CMS and DAM adapters. WordPress, Sanity, Contentful, Bynder. Every AI-generated asset published through those systems should carry an ATTEST signature by default. The gateway is the wedge; the adapters are the distribution.

Enterprise deployment. Multi-tenant workspace UI, Postgres audit log, scoped B2 application keys, SOC 2 groundwork. The compliance officer at a European mid-market fintech should be able to spin up an ATTEST workspace in five minutes and have their entire marketing team's AI output covered by August 2.

Article 50 is one day after this hackathon closes. ATTEST is the reference implementation of the answer.

Built With

• b2
• genblaze
• python