• 

• 

• 

STILL Afterwords

The conversation after what you’ve seen—not what comes next.

STILL turns watched story moments into an evolving two-host AI podcast without letting the future spoil the meaning.

Try it	Link
Live application	https://still-afterwords-2026.web.app
Public cumulative Afterword (shared link) — no login required	https://still-afterwords-2026.web.app/#/share/9_Cm3naftLPkvCnvEVgr1ZyFflXpNIG5
Source code and setup	https://github.com/PrathmeshAdsod/STILL-Afterwords

Private judge access instructions are supplied separately. No secret or credential is embedded in the application, repository, or public submission text.

The problem

A story gives us meaning in sequence. A look changes a line. A later reveal changes a motive. Yet most AI experiences ignore that sequence: search takes the viewer away from the scene, a chatbot knows the whole plot, a recap starts from the ending, and a conventional podcast is already complete before the viewer presses play.

That creates a real gap. Viewers often want to ask “What did that choice mean?” at the exact point when a story has moved them—but the available tools either spoil what comes next or flatten the story into a generic summary.

STILL Afterwords creates a new media format for that moment: an episode that can grow, but cannot run ahead.

Inspiration

The idea began with a simple observation: interpretation has a timestamp.

Two people can watch the same scene and reasonably disagree because the story has not resolved every tension yet. That ambiguity is not missing information to be “fixed” by an all-knowing model; it is part of the experience. We wanted AI to respect the audience’s position inside a story instead of treating the source as a finished database.

Our first STILL prototype explored time-bounded reflection in a Scripture-focused setting. For this hackathon we rebuilt that foundation into an independent generative-media product: new positioning, new interface, two consistent co-hosts, real media generation, append-only continuation, Genblaze orchestration and lineage, private B2 persistence, download, chapters, transcript, and revocable sharing. The earlier competition repository and deployment remain separate and frozen.

What it does

1. Validates a real source. A signed-in user adds a public or unlisted, embeddable YouTube story up to six minutes. Server-side metadata validation happens before quota is reserved.
2. Understands the story in presentation order. Gemini on Vertex AI reads audio and visuals together in bounded chronological windows. Each window appends narrative state and may create an evidence-backed meaning moment with an exact cutoff.
3. Records what the viewer truly reached. YouTube player events are merged into server-saved watched ranges and a furthest frontier. The user cannot type a timestamp and claim to have watched it.
4. Builds a spoiler-safe evidence set. An Afterword request permanently freezes the viewer’s frontier. Only moments whose cutoff is at or behind that frontier are eligible; later evidence is absent from the dialogue request.
5. Generates an actual two-host episode. Maya and Jonah test motives, tensions, spirituality, inner life, and competing interpretations. Both voices cite reached source moments. If the evidence is thin, the system is instructed to remain proportionate rather than manufacture profundity.
6. Creates durable media through Genblaze. Each dialogue turn is an explicit ElevenLabs step, FFmpeg assembles the ordered audio, and Genblaze writes an auditable manifest.
7. Persists the media graph in private B2. Per-turn clips, cumulative MP3s, manifests, hashes, and parent lineage live in Backblaze B2. Playback uses short-lived access; sharing is opt-in and revocable.
8. Continues without rewriting. Watching farther unlocks only new moments. A continuation reads its parent cumulative MP3 from B2, appends new Genblaze voice steps, and produces one longer episode with traceable lineage.

The result includes private playback, MP3 download, a speaker-labelled transcript, chapters that jump to source timestamps, a visible manifest-verification fingerprint, a personal Library, and an optional anonymous share link.

Why it is not “just another AI podcast”

Conventional generated recap	STILL Afterwords
Starts from the completed plot	Freezes the viewer’s real position in time
Treats all source facts as equally available	Excludes every future moment by construction
Produces one disposable output	Produces immutable generations and cumulative lineage
Hides media steps behind one API response	Records explicit Genblaze voice, assembly, and storage steps
Stores a final file	Stores clips, MP3, manifest, hashes, and parent relationships in B2
Invents a strong take even when evidence is weak	Can abstain or stay deliberately tentative

The system is allowed to understand the source once for efficiency. The product innovation is the spoiler firewall between what the system may know and what a particular conversation is allowed to use.

How we built it

Experience and identity

The responsive client is built in React, TypeScript, and Vite and deployed on Firebase Hosting. Firebase Authentication supplies verified user identity. Projects, quotas, playback state, and sharing remain owner-bound; the browser never receives provider credentials and cannot access Firestore directly.

Causal story intelligence

FastAPI runs on Cloud Run. The worker sends sequential audiovisual windows to Gemini on Vertex AI while carrying forward append-only prior state. Every accepted moment stores its source timestamp, evidence, confidence, and window cutoff. Both the API and the dialogue writer independently filter eligible IDs against the frozen watched frontier.

Durable jobs

Analysis and media generation are persisted before dispatch. Cloud Tasks invokes internal worker routes using a verified service-account OIDC token. Checkpoints make jobs resumable and idempotent, and failures are exposed as retryable states rather than published as finished episodes.

Genblaze media graph

Structured Maya/Jonah dialogue becomes one Genblaze ElevenLabs provider step per turn. A deterministic FFmpeg fan-in preserves exact speaker order. For a continuation, the prior private B2 MP3 is an explicit graph input. The run records its parent ID instead of silently overwriting the earlier generation.

Backblaze B2 as the media system of record

Genblaze’s object-storage sink persists voice clips, the cumulative MP3, and the run manifest to a private B2 bucket. The app retains canonical manifest hashes, verify() results, asset SHA-256 values, and parent lineage. Signed playback URLs expire, public shares are revocable, and owned project deletion removes generated B2 objects before metadata is removed.

Production guardrails

• Six-minute source maximum and verified embeddability.
• One analysis and one generated Afterword for a Free account; bounded private judge allowances.
• A 3,500-character ElevenLabs input ceiling across a project and all continuations.
• One concurrent media task, at most two delivery attempts, and Cloud Run minimum zero / maximum one instance.
• Verified-email, ownership, quota, idempotency, and worker-identity checks.
• Private B2 objects and secrets mounted only on the server.
• Production startup refuses fixtures, local workers, or missing real-provider configuration.

How it addresses the judging criteria

Criterion	Evidence in the working product
Real-world utility	A clear audience—viewers, film clubs, classrooms, and creators—can reflect at the exact point reached without leaving the story or receiving spoilers.
Production readiness	Authentication, ownership, quotas, durable jobs, idempotency, retry states, private playback, Library, download, sharing, revocation, deletion, and scale-to-zero deployment are implemented.
B2 storage + data orchestration	B2 stores every generated clip, cumulative MP3, manifest, hash, and parent relationship; those objects actively power playback, continuation, download, sharing, verification, and deletion.
Use of Genblaze	Genblaze executes one provider step per dialogue turn, ordered FFmpeg fan-in, the B2 storage sink, manifest verification, and parent-linked continuation in the real production path.

Real deployment proof

We did not stop at unit tests or a prepared interface. In the deployed application, one 5:31 story was analyzed across nine real chronological audiovisual windows. Real playback unlocked moments at 0:40, 1:20, and 2:00.

The first Afterword produced five Maya/Jonah turns and a browser-decoded 92.648-second MP3. After watching farther, Continue Afterword added four new turns and produced a 149.629-second cumulative B2 asset with nine total turns. The second generation’s parent Afterword ID and parent Genblaze run ID match the first generation, and both manifests verify. Private playback, anonymous sharing, immediate share revocation, and a new cumulative share were exercised in separate browser sessions.

The public sample linked above is that real cumulative result—not fixture data.

Regression evidence: 41 API tests, 8 web tests, TypeScript, ESLint, production build, deployed health check, and an exact ignored-secret comparison all passed.

Challenges we ran into

Letting the model understand a source without letting it spoil the viewer

Naively re-prompting the whole story for every timestamp is expensive and lets later facts contaminate earlier meaning. We separated analysis from permission: sequential windows build immutable state once, while a server-side cutoff and eligible-moment IDs control what each conversation may see.

Distinguishing a playhead from genuine watch progress

A timestamp is not proof of attention. We record player events as watched ranges, merge only plausible contiguous coverage, and separately track the furthest reached point. Seeking can reveal a timed card, but continuous coverage plus a natural ending is required to mark a story complete.

Making generated audio extend instead of restart

Continuation is harder than generating a second unrelated clip. We modelled every generation as immutable, made the parent B2 audio an explicit Genblaze input, excluded previously used moments, appended only new voice turns, and persisted a new cumulative manifest with parent lineage.

Keeping provider failures honest

Our first deployed podcast attempt exposed a temporary Gemini client-lifetime bug before synthesis. The job remained safely retryable and no fake result was published. We fixed the lifetime boundary, added a regression test, and the bounded retry passed the complete Vertex AI → Genblaze → ElevenLabs → FFmpeg → B2 path.

Making a judgeable product without creating an abuse surface

Real audiovisual reasoning and voice synthesis have variable costs. We combined verified authentication, account and global quotas, source-duration limits, project character budgets, one-at-a-time media dispatch, limited retries, and scale-to-zero infrastructure.

Accomplishments that we're proud of

• We created a working media format with a product-level temporal constraint, not a prompt-only promise.
• Genblaze is visible and essential: every voice turn, assembly step, storage sink, manifest, and continuation relationship is part of the real execution graph.
• B2 is essential: it is the private durable record that makes playback, download, verification, deletion, sharing, and cumulative continuation possible.
• The deployed public sample contains two real generations, nine dialogue turns, source chapters, a cumulative MP3, verified manifests, and parent lineage.
• The system abstains when a window does not earn a proportionate interpretation.
• The application is usable as a business-shaped product: authentication, Library, quotas, retry states, private media, revocable public links, and owned deletion are implemented.

What we learned

• Order is a product primitive. The same evidence means something different depending on what the audience has reached.
• Model knowledge and product permission must be separate. A model can know a future fact while the application makes it impossible for that fact to enter the current request.
• Object storage can hold meaning, not only bytes. B2 manifests, hashes, asset relationships, and parent lineage turn generated files into a durable media history.
• A workflow graph makes generative media explainable. Genblaze made provider steps, fan-in assembly, storage, and continuation explicit enough to inspect and verify.
• Abstention improves trust. Silence is better than a dramatic but unsupported “insight.”
• Production evidence is different from code evidence. Tests validated contracts; only the deployed cumulative run validated provider behavior, browser playback, private storage, sharing, and lineage together.

What's next for STILL Afterwords

1. Creator-owned uploads and private classroom sources with the same frontier and provenance model.
2. Multilingual co-host pairs while retaining evidence citations and one consistent voice identity per language.
3. Shareable moment cards and embeddable Afterword chapters that return listeners to the exact source scene.
4. A creator review studio for renaming chapters, approving interpretations, and choosing which reached moments enter a public episode—without widening the spoiler boundary.
5. Group frontiers for film clubs and classrooms, so a conversation can open only to the earliest shared watch position.
6. Retention controls and richer deletion receipts for organizations managing private media.
7. Longer-form tiering after cost and latency data justify it, while keeping the current six-minute public surface intentionally bounded.

STILL’s long-term opportunity is not to summarize more media. It is to make generated media respect the audience’s place inside a story.

Built With

• genblaze
• python