---
reliability: 4.3 # 5 − .3 scene gen ×8 − .2 music bed − .2 6th-stage overflow; bible/anchor/beats LLM or deterministic, export chain ffmpeg deterministic; cover + social teaser OPTIONAL; no-LoRA anchor recipe holds ~85–90% identity over 8 scenes; no proven E2E showcase yet
---

# Episodic pilot — agent playbook ⭐ flagship

> Paste this whole file (with the BRIEF filled in) into Claude cowork, chat, or Code. **This is the no-LoRA flagship for episodic narrative creators.** Build a same-day pilot episode of a serialized story — 8 scenes, 90 seconds, anchored to a single character reference, exported to cinematic 2.35:1 + a 9:16 social cut. The pipeline a Cartoon Saloon proof-of-concept reel uses, run on Storyboard in an afternoon.

## What you'll get

A pilot-grade narrative deliverable, structured the way a serial creator works:

- **Series bible anchor** — palette + cast + setting locked once via a brand kit. Reusable across every future episode.
- **8 storyboarded scenes** — narrative beats, locked to your character reference, with auto-critique per scene to catch any identity drift before it ships.
- **2.35:1 anamorphic cut** — cinematic widescreen, film-grain LUT, episode card, end card.
- **9:16 social teaser** — 30-second teaser pulled from the strongest 3 beats, with the same brand chain so the social feels like the show.
- **Cover keyframe** — the protagonist on a hero pose at 1920×1080, for posters / press kits / Episode 0 carousels.
- **Pilot HTML** — single shareable page with all 8 scene cards + hero + bible reference, ready for a producer or platform pitch.

**Time**: 2-3 hours wall clock. **Your attention**: about 18 minutes across 8 gates. **Cost**: $4-7 end to end. *This is the easy-mode flagship* — no LoRA training, no multi-week production, just a single reference image and an afternoon.

## Tell the agent about the pilot

```yaml
series_title:        # e.g. "Neon Saigon" — the show's name. Used in title cards + episode cards.
episode_title:       # e.g. "Pilot — The Bicycle Repairman". Used in episode card overlay.
series_logline:      # 1-sentence elevator pitch. Drives the agent's narrative beat planner.
setting_world:       # 1-2 sentence world description — informs colour, era, weather, costume, props.
protagonist_name:    # The lead character's name. Becomes the entity_name in the registry.
protagonist_brief:   # 1-2 sentences describing the lead — what makes them visually distinct.
protagonist_ref:     # URL or local path to ONE clean reference image of the protagonist.
supporting_characters: # OPTIONAL — 1-3 named supporting characters (name + 1-line each).
narrative_arc:       # 1-paragraph synopsis of this pilot's beat sequence. Agent uses to plan 8 scenes.
visual_style:        # e.g. "noir, anamorphic, neon-saturated", "Studio Ghibli watercolour", "60s anime cel".
cinematic_aspect:    # 2.35:1 (default) / 1.85:1 / 16:9. Anchors the cinematic export aspect.
social_cut_aspect:   # 9:16 (default) / 1:1. Anchors the social teaser aspect.
brand_kit_slug:      # kebab-case (used in filenames + future episodes). e.g. neon-saigon-pilot.
pilot_slug:          # kebab-case for HTML output filename. e.g. neon-saigon-pilot-ep0.
```

---

## Quality controls (auto-applied)

This playbook is built on the closed quality loop. The agent applies these by default:

- **Cost upfront.** Before the 8-scene batch fires, the agent shows you the proposed plan + total cost. Nothing runs until you approve.
- **Per-scene critique with drift gate.** Every protagonist scene runs the cross-asset critic; identity similarity below 0.85 pauses production. You see the failing scene, you decide: re-render, or accept the variation as art direction.
- **End-of-batch critic verdict.** After the 8 scenes render, the cross-asset critic runs again on the whole set — surfaces face-consistency score across every scene where the protagonist appears.
- **One-click recovery.** Any step failure surfaces a recovery plan you can approve.
- **Brand chain on every export.** The 2.35:1 hero, the 9:16 social, and the cover all run through the same brand kit so they read as one show.

> **Why the no-LoRA route works here:** with a single character anchor + per-scene critique + a tight visual style, 8 scenes is short enough that reference-image identity holds. The moment you scale past one episode, train a LoRA (see playbook `episodic-series.md`).

## How this works

Eight stages. The first two — series bible + protagonist anchor — are the load-bearing decisions; everything else cascades from them. The agent stops after the 8-scene critique to let you triage drift before spending on the export.

## How the agent should run this (interaction contract)

1. **CONFIRM (one message, ≤1 question):** restate in 1 line ("8-scene pilot of '<series>', anchored to your reference, 2.35:1 + 9:16 cuts, ~$4–7, 2–3 hrs") and fold Step 0's two taste questions into that one message (cold-open vs one-shot · restraint vs maximalist). Missing `protagonist_ref` is the only blocker worth a question.
2. **PREVIEW CHECKPOINT:** the **8-beat outline ($0.02) + Step 4 cost preview** BEFORE the ~$3.50 scene batch; then the 8 scenes + critic verdict BEFORE any export spend. Never let drift triage happen after the export.
3. **NARRATE:** 1-liner per stage with ETA ("rendering 8 scenes, ~5 min, per-scene critique on", "export chain: concat → letterbox → LUT → cards, ~3 min"); poll `get_create_media` every 10–15s, report each critic score as it lands, never silent >2 min.
4. **FAIL GRACEFULLY:** scene identity <0.85 → `director_re_render` that scene with the anchor at full strength (≤2 retries) → offer "accept as art direction" or LoRA; gpt-image 422/timeout → soften the prompt → flux-dev/nano-banana; music sings the brief → re-run with `lyrics_prompt:"[Instrumental]"`; export chain aborts mid-step → deliver the `partial_url` concat without the LUT. 7 good scenes + a note beats a stalled run.
5. **DELIVER:** pilot HTML + both cuts + scorecard + one honest line ("face consistency 0.XX — single-reference anchor, ~85–90% grade; LoRA is the 95% path") + ONE next step ("train the protagonist LoRA from these 8 scenes before Episode 2").

## The steps

### Step 0 — Confirm the brief

The agent reads back the BRIEF and asks two taste questions:
- "Is this episode the cold-open of a longer series, or a self-contained one-shot?"
- "Cinematic restraint or genre-maximalist?"

The answers tune the agent's beat-planner — restraint pulls toward Cartoon Saloon, maximalism pulls toward Trigger.

**STOP**: "Brief looks right? (approve / edit [field] [new value])"

### Step 1 — Series bible + brand kit (~1 min, ~$0.05)

The agent calls `brand_kit_create({ slug: brand_kit_slug, palette, keywords: visual_style })` — the kit holds palette swatches, the visual_style keywords, the setting_world line, and the cinematic_aspect target. It then calls `brand_kit_set_finishing_chain` to seed the finishing chain (letterbox to cinematic aspect, film-grain LUT via `ffmpeg-export`, episode card, end card). Saved to series memory so future episodes inherit automatically.

**STOP**: "Palette + brand keywords approved? (approve / shift [direction])"

### Step 2 — Protagonist anchor lock (~1 min, ~$0.05)

The agent registers your `protagonist_ref` URL as the character anchor for the project. From here, every scene where the protagonist appears auto-binds to this anchor — no per-call reference passing. If the reference is low-res or has busy background, the agent offers to clean it with a quick subject-isolate pass before locking.

**STOP**: "Anchor locked. Continue to scene planning? (continue / refine the reference)"

### Step 3 — Beat planning (~2 min, ~$0.02)

The agent reads your `narrative_arc` and proposes an 8-beat structure — opening (1), inciting incident (2-3), rising action (4-5), turning point (6), climax (7), resolution (8). Each beat gets a 1-sentence shot description, locked to the protagonist anchor where they appear, plus any supporting cast you named.

> **For the agent**: bias the beat structure toward the visual_style — noir lingers on solitude (more close-ups), action escalates kinetic energy (wider shots, more figures-in-frame). Use the genre cue from Step 0.

**STOP**: "8-beat outline shown. Approve, refine, or rewrite a beat? (approve / refine [#] [direction] / rewrite [#] [new beat])"

### Step 4 — Cost preview + render gate (~5 sec)

Before any image renders, the agent calls the planner to surface: 8 scene renders × $0.40 + 1 cover render × $0.50 + finishing chain × $0.30 = ~$4 total. You see the breakdown, you approve.

**STOP**: "Plan total $X.XX. Approve render? (approve / cap-at [$amount] / stop)"

### Step 5 — Generate the 8 scenes (~5 min, ~$3.50)

The agent runs `generate_project({ scenes: 8, style: visual_style, character_anchor: protagonist_ref, aspect_ratio: cinematic_aspect })` — every scene anchored to the protagonist reference and styled by the brand kit, with per-scene auto-critique. Any scene where the protagonist's identity drifts below 0.85 similarity pauses the run.

> **For the agent**: route title-card-text scenes to `gpt-image` (best text-in-image), night-rain scenes to `flux-dev` (photoreal). Drift-gate threshold is 0.85; the `critique_shot` surface should show the failing scene, the anchor, and a one-line diagnosis ("scene 4 lost the jawline — over-stylized; re-render anchored at 1.0"). Use `director_re_render` to fix just that scene.

**STOP**: "8-scene batch + critic verdict shown. Approve all, redo specific, or accept drift on [#]? (approve / redo [#] [direction] / accept [#] / replan)"

### Step 6 — Cover keyframe (~2 min, ~$0.50) — OPTIONAL (poster / press-kit extra)

The agent picks the most kinetic / hero-y scene from the 8 and re-renders it at 1920×1080 with `quality_threshold: 0.9` and one retry. This is the poster / press-kit / Episode 0 carousel image. If you don't like the hero choice, you can override the pick before the render.

**STOP**: "Cover keyframe shown. Ship, refine, or pick a different beat as hero? (ship / refine [direction] / re-pick [#])"

### Step 7 — Cinematic cut (~3 min, ~$0.40)

The agent runs `director_export({ project_id, brand_kit_id })` — it stitches the 8 scenes via `ffmpeg-concat`, then runs the brand kit's finishing chain: letterbox to your cinematic_aspect, film-grain LUT, episode card with series_title + episode_title, end card. To give the cut an audio bed, add one `create_media action:"music"` (`lyrics_prompt:"[Instrumental]"`) and an `ffmpeg-mux` step with `audio_fill:"loop"` so the score covers the full ~90s. Output is a single MP4 at the target aspect.

> **For the agent**: pacing — 12s per scene by default (~90s total). If a scene is a beat (one-second cut), use `director_retime` to shorten it; if it's a landscape establishing shot, lengthen it. Default duration cues come from the beat planner's per-beat weights.

**STOP**: "Cinematic cut shown. Approve, refine pacing, or restart? (approve / re-time [#] [seconds] / restart)"

### Step 8 — Social cut (OPTIONAL) + pilot HTML (~3 min, ~$0.30)

The agent picks the 3 strongest beats (highest critic score on the protagonist) and runs `director_variant({ project_id, scenes: [strongest 3], aspect: social_cut_aspect })` → `director_export` to produce a 30-sec 9:16 social teaser with the same brand chain, then writes a single-page pilot HTML at `public/pilots/{pilot_slug}.html` containing the cover, the 8 scene cards, the cinematic cut, the social cut, and the series bible reference. `get_scorecard({ project_id })` surfaces face-consistency across the run + total cost.

## Final output

```
✅ Pilot HTML:           public/pilots/{pilot_slug}.html
✅ Cinematic cut (2.35:1): <URL>
✅ Social teaser (9:16):  <URL>
✅ Cover keyframe (1920×1080): <URL>
✅ 8 scene stills:        <URL × 8>
✅ Brand kit (reusable):  ckit_{brand_kit_slug}
✅ Project viewer:        <project URL>

Total spent: $X.XX of $7 ceiling
Total wall-clock: MM:SS
Critic verdict: SHIP — protagonist face consistency 0.XX across all 8 scenes
```

## What to do next

- **Ship the pilot.** Upload the cinematic cut to YouTube as Episode 0, the social teaser to TikTok / Reels, the cover as the catalogue thumbnail.
- **Train a protagonist LoRA from these 8 scenes** — they're already on-model, they're already in your style; `submit_lora_train` produces a per-character LoRA in ~5 min. Every future episode at a fraction of the per-scene cost.
- **Run `episodic-series.md` for Episode 2** — the brand kit + LoRA carry forward; the next episode is 50% cheaper and 100% on-brand.
- **For pitch decks**: the pilot HTML doubles as a one-link platform pitch. Send the URL.
- **For Substack / Patreon serial fiction**: the cover + the social teaser go on the post; the cinematic cut is the paywalled bonus.

---

> *"A pilot doesn't have to be perfect — it has to make me want to watch episode 2."* — every showrunner ever. This playbook is built around exactly that bar.