# Live cast member — agent playbook ⭐ flagship

> Paste this whole file (with the BRIEF filled in) into Claude cowork, chat, or Code. **This is the live flagship for episodic narrative creators.** Bind a trained character LoRA to a live-streamed AI persona that broadcasts on Twitch / YouTube, takes audience chat, and feeds the best live moments back into the writers' room as episode-canon beats. The brand beacon no incumbent can ship in a quarter.

## What you'll get

A live-broadcast-grade deliverable, structured the way a streamed serialized narrative house works:

- **A persona graph** — your trained character LoRA bound into a Scope LV2V graph: webcam in → LoRA-conditioned style transfer → output stream. Saved as a reusable preset.
- **A 90-min show plan** — five mood beats with prompt-travel cues (opening monologue → fan Q&A → guest interview → reflection → outro), scripted in advance, live-overridable.
- **A live stream session** — the persona broadcasts to your platform of choice with audience chat driving mood transitions. KV-cache attention bias holds temporal stability through head turns and gestures.
- **Post-show highlight reel** — the strongest 60-90 sec of the stream rendered as still + animated keyframes through the SAME brand kit as the recorded episodes. Viewers can't tell which moments were live and which were post-produced.
- **Episode-canon ingest** — the host marks 1-3 moments as canonical; the agent files them into the writers' room board for the next episode's beat plan.
- **Live HTML kit** — the stream's title card, banner, and lower-third overlay set; all branded by the series brand kit.

**Time**: 30 min one-off setup, then live as long as the host wants. 20 min post-show clipping. **Cost**: per-minute Livepeer rate during stream + ~$1.50 for the post-show clipping pass. *This is the live flagship* — it's a brand beacon, not a primary revenue line; the value is the show getting press attention, not minutes-billed.

## Tell the agent about the live show

```yaml
series_title:        # The parent series this persona belongs to. e.g. "Hollow Reign".
persona_name:        # The character going live. Must match a trained LoRA bound to the series.
show_title:          # This stream's title. e.g. "Aiko answers questions for an hour".
show_runtime_min:    # Target runtime. e.g. 90.
show_arc:            # 4-6 named mood beats with prompts. See template below.
audience_platform:   # Twitch / YouTube / X / custom. Drives output resolution + stream URL format.
audience_chat_source: # Twitch chat / YouTube chat / X replies / off. The agent pulls from here for mood cues.
brand_kit_id:        # The series brand kit (from episodic-series.md). Locks watermark, end card, LUFS.
lora_id:             # The persona LoRA (from episodic-series.md or a one-off training).
preset_name:         # Scope preset name. e.g. "anime-soft", "cinematic-mood". See skills/livecast-persona.md.
fallback_clip_url:   # OPTIONAL — a 10-sec b-roll clip the agent plays if the LV2V drops mid-stream.
stream_slug:         # kebab-case for the show HTML + clip filenames. e.g. aiko-live-2026-06-08.
```

### show_arc template

```yaml
show_arc:
  - beat_1: { name: "monologue",   minutes: 0-10,  prompt: "calm focus, soft lighting, anime-soft preset, noise_scale 0.5" }
  - beat_2: { name: "fan_qa",      minutes: 10-40, prompt: "engaged conversation, slight smile, noise_scale 0.55" }
  - beat_3: { name: "guest",       minutes: 40-65, prompt: "alert, leaning in, broadcast-bright lighting, noise_scale 0.6" }
  - beat_4: { name: "reflection",  minutes: 65-80, prompt: "introspective, low-key lighting, anime-soft, noise_scale 0.7" }
  - beat_5: { name: "outro",       minutes: 80-90, prompt: "warm closure, soft golden tone, noise_scale 0.55" }
```

---

## Quality controls (auto-applied)

This playbook leans on the LV2V chassis + the same brand chain as the recorded series:

- **Persona-LoRA-locked LV2V.** Character identity at <250 ms latency. The LoRA holds face / costume / signature; the Scope graph holds temporal stability.
- **Mood-cue listener.** The agent transcribes the host's voice with `nemotron-asr` (low-latency streaming ASR — also doubles as live captions) and parses audience chat for trigger phrases ("let's get serious", "lighten up", "fan question"). Cue phrases shift `noise_scale` + `prompt` via `scope_control` per the show arc.
- **30-min p99 > 95% reliability gate.** Before the playbook will start a stream over 30 min, the agent runs a 60-second smoke check against the Scope orchestrator. Fail = abort + diagnosis. The host gets a clear-eyed go/no-go before going live.
- **Auto-fallback on disconnect.** If the LV2V drops mid-stream, the agent plays `fallback_clip_url` as a holding pattern while attempting reconnect. The audience sees "technical pause" not "dead stream."
- **Post-show same-brand finish.** The highlight reel runs through the SAME brand kit as the recorded episodes. Watermark, LUFS, end card identical. Viewers cannot tell live moments from recorded ones in the final cut.
- **Canon ingest.** Host-marked moments (1-3 per stream) become file entries in the writers' room board: which character, what they did/said, the rough timestamp. The next `episodic-series.md` run reads from this.

## How this works

Four phases. **Prep** (one-off per persona) builds the Scope graph. **Plan** (15 min before show) scripts the arc. **Stream** is hands-on for the host. **Post** is hands-off for the agent — it clips, scores, finishes, and files canon.

## The steps

### Step 0 — Confirm the brief + persona check

The agent checks that `lora_id` is trained and ready, `brand_kit_id` exists, and `series_title` has at least 1 recorded episode it can stylistically anchor against.

**STOP**: "Persona '{persona_name}' ready (LoRA trained, brand kit linked). Continue to graph build? (continue / cancel)"

### Step 1 — Build the persona LV2V graph (~5 min, ~$0)

The agent constructs a Scope LV2V graph: source (webcam) → preset(`{preset_name}`) → LoRA-conditioned style transfer (LoRA `{lora_id}` at scale 0.85) → output. Saved with `stream/graphs save {persona_name}-live`. KV-cache attention bias defaults to 0.75 for temporal stability.

> **For the agent**: surface the graph diagram so the host can verify the chain visually before the smoke test. The graph save is idempotent — re-running this step on an existing persona just refreshes the saved graph.

**STOP**: "Graph saved as '{persona_name}-live'. Sample the persona on a 10-sec clip to confirm look? (sample / skip / refine [direction])"

### Step 2 — Show plan finalization (~5 min)

The agent reads back the `show_arc` and asks one taste question: "Mood-progressive (each beat builds on the last) or mood-cyclical (beats return to neutral between intensity peaks)?" This tunes the prompt-travel transition shape.

**STOP**: "Show plan locked. Ready for the pre-show reliability smoke? (continue / edit beat [#] [field] [value])"

### Step 3 — Pre-show reliability smoke (~60 sec, ~$0.10)

The agent runs a 60-sec LV2V test against your orch. Measures: latency p99 (target <250 ms), output frame rate (target >15 fps), KV cache stability (target >0.95 attention-bias consistency). Reports any anomaly.

> **For the agent**: if any metric is below target, surface the specific failure mode and the recovery action. Never start a 90-min stream against a failing orch.

**STOP**: "Smoke passed (latency XXXms, frame rate XX fps, stability X.XX). Go live? (go / cancel / re-run smoke)"

### Step 4 — Start the live stream (~immediate)

The agent fires `scope_start` with the saved graph, the lora, the preset, and beat 1's prompt. Hands control to the host. The agent stays in "listening" mode — listening for cue phrases, chat triggers, and the host's "next beat" command.

**STOP** (host-driven, not agent-driven): the host can say at any time: "next beat", "back to {beat name}", "more / less intensity", "mark this moment as canon".

### Step 5 — In-show mood transitions (live, ~hands-off for the agent's mood routing)

As the host moves through beats, the agent updates `scope_control` with the next beat's prompt + noise_scale. Audience chat is parsed for mood cues — "give us the sad one" might trigger noise_scale 0.7; "lighten up" might trigger 0.5. The agent surfaces a small console showing current beat + current params so the host can see what's running.

> **For the agent**: respect the chat-source cap — only the host's cue or chat from `audience_chat_source` triggers transitions. Random viewer DMs do NOT.

### Step 6 — Stream stop + canon ingest

The host calls "stream done." The agent fires `scope_stop`, archives the stream recording, and asks: "You marked N moments as canon during the stream — confirm each for the writers' room?"

**STOP**: "Confirm canon moments? (confirm-all / drop [#] / edit [#] description)"

### Step 7 — Post-show highlight reel (~15 min, ~$1.50)

The agent pulls the host-marked moments + the top 3 algorithm-picked moments (by audience-chat-spike correlation). For each moment, renders a stylized still (the persona LoRA via `flux-dev`) + a 4-sec animated keyframe via `create_media({ action: "animate", model_override: "seedance-i2v", source_url: <still>, resolution: "auto", duration: 4 })`. Stitches the strongest 6-8 moments into a 60-90 sec highlight reel.

> **For the agent**: target reel runtime ~75 sec. Run the brand kit's finishing chain via `director_export({ project_id, brand_kit_id })` — `ffmpeg-concat` → brand watermark/LUFS/end-card steps → `ffmpeg-mux` (`audio_fill: "loop"`) so the score covers the full reel, identical to the recorded episodes. Surface a one-line metric: "highlight reel: brand-chain match 0.XX vs recorded episodes (should be >0.95)."

### Step 8 — Live HTML kit update + canon file (~1 min)

The agent updates `public/series/{series_slug}.html` to add this stream's card (highlight reel + canon-moments list + audience-chat-stats summary). Files the canon moments into `public/series/{series_slug}/writers-room.md` for the next episode's `episodic-series.md` run.

## Final output

```
✅ Live stream record:    <recording URL>
✅ Highlight reel (75 sec): <URL>
✅ Canon moments filed:   N moments → public/series/{series_slug}/writers-room.md
✅ Live HTML kit:         public/series/{series_slug}.html (updated)
✅ Persona graph:         {persona_name}-live (saved, reusable)

Streamed: MM:SS
Avg latency: XX ms · Avg frame rate: XX fps · Stability: X.XX
Audience: peak NN concurrent · NN chat messages
Brand-chain match (vs recorded episodes): 0.XX
Total cost: per-min stream rate × {minutes} + $1.50 post-show
```

## What to do next

- **Run `episodic-series.md` for the next episode** — the canon moments from the stream become beat #N in the writer's room. The show literally co-writes with the fans.
- **Sponsor / brand integration**: the stream's highlight reel through the brand chain is a clean place to thread sponsor logo without breaking persona immersion.
- **Replay strategy**: post the 75-sec highlight reel as a Short / Reel; clip the canon moments individually as 30-sec teasers; the full recording goes on YouTube as the "uncut" version.
- **Year-2 persona refinement**: train a persona-v2 LoRA from the strongest 30 stream frames. The v2 persona is closer to "what the audience saw live" than the original LoRA which was trained pre-broadcast.
- **Multi-persona streams**: train a second cast LoRA, set up a second persona graph, run two streams in parallel. The brand kit + canon ingest works across both.

---

> *"A VTuber that holds character is rare. A serialized AI persona that holds character AND feeds canon back into the show is unprecedented."* — what this playbook is for.