---
title: "Native Multishot Commercial — 2–5 shot continuous ad via model-native multi_prompt"
tier: hero
format: short-form-video
theme: commercial | brand | launch | advertising | motion
persona: brand marketer, creative director, agency producer, DTC founder, video ads team
duration: "1 brief → 10–15s continuous commercial in ~5–12 min"
budget_usd: "$0.75–$2.50 (one native multi_prompt call on kling-v3-turbo-pro-t2v; fallback scenes mode ~$1.50–$4.00)"
caps: ["submit_creative_job", "get_creative_job", "kling-v3-turbo-pro-t2v", "create_media", "generate_project", "sonilo-t2m", "music", "ffmpeg-mux", "ffmpeg-export", "director_export"]
skills: ["commercial", "short-form-video", "storytelling"]
showcases: ["/chapters/native-multishot-commercial-example.html"]
status: "live (2026-08-03) — Wave 1 showcase rendered E2E via MCP. See /chapters/native-multishot-commercial-example.html"
reliability: 3.9 # first E2E showcase; curated (≥4.0) deferred until a second successful run
---

# Native Multishot Commercial — one call, one continuous take

Point this at a short commercial brief — *"A runner laces up → sprints city dawn → product hero → logo hold"* — and Livepeer Agent renders a **2–5 shot continuous commercial** in a **single native inference call**. Kling 3.0 Turbo Pro's `multi_prompt` engine holds temporal continuity across shots — same character, same light, same wardrobe — instead of stitching N independent per-scene renders that drift apart.

When the brief qualifies, pass `generation_mode: "native"` through `submit_creative_job`. When it doesn't — or native fails — fall back to standard **scenes mode** fan-out without silent degradation.

## What you'll get

- **One continuous 10–15s commercial MP4** — 2–5 shots rendered with model-native continuity
- **A qualification check upfront** — the agent verifies your brief meets native rules before spending
- **Automatic scenes fallback** — if native fails, per-scene renders stitch into the same storyboard
- **Optional soundtrack** — sonilo-t2m or music bed muxed under the full clip
- **Platform exports** — 9:16 (Reels/TikTok), 16:9 (YouTube pre-roll), 1:1 (feed)

## Fill in your BRIEF

```yaml
product_or_brand:      # e.g. "NovaRun V3 trail shoe"
commercial_hook:       # one-line sell — e.g. "Built for the miles no one sees"
shots:                 # 2–5 shot prompts, one per line — THIS IS THE multi_prompt payload
                       # e.g. "Close-up hands lacing trail shoe at dawn"
                       #      "Runner sprints empty city street, golden side light"
                       #      "Low-angle shoe hitting wet pavement, splash"
                       #      "Product hero on rock, mist behind, logo hold"
delivery_promise: motion_led   # REQUIRED for native — must signal video intent
generation_mode: auto          # auto (DEFAULT) | native (force) | scenes (force per-scene)
aspect_ratio: 9:16             # 9:16 | 16:9
duration_seconds: 12           # total ≤15s — native hard cap (see qualification rules)
music_brief:           # e.g. "cinematic sports energy, ~110 BPM, instrumental, no vocals"
voiceover:             # OPTIONAL — if set, native may NOT qualify (voice adds scenes complexity)
launch_slug:           # kebab-case, e.g. novarun-v3-launch
brand_kit_id:          # OPTIONAL — ckit_… for palette + voice keyword stickiness
```

## Native qualification rules (non-negotiable)

The agent MUST verify ALL of these before firing native mode:

| Rule | Requirement | Why |
|------|-------------|-----|
| Shot count | **2–5 shots** (not 1, not 6+) | Kling multi_prompt max under 15s duration cap |
| Total duration | **≤15 seconds** | 5 shots × 3s floor = 15s hard ceiling |
| Video intent | `delivery_promise: "motion_led"` OR explicit video `global_model_override` | Without signal, default routes to image caps |
| No per-scene model overrides | Zero `model_override` on individual scenes | Native uses ONE model for the whole take |
| No source-led delivery | `delivery_promise` ≠ `"source_led"` | Source-led briefs stay in scenes/edit mode |

If ANY rule fails → route to **scenes mode** and tell the user why in one line. Do not waste a native call on a disqualified brief.

## CONVENTIONS

1. **HITL gates:** at every STOP, ask exactly one specific question with concrete options.
2. **Cost ceiling:** total < $10. After each stage, print running cost.
3. **Output paths:** write HTML to `public/launches/{launch_slug}-commercial.html`. Print full paths at end.
4. **Brand stickiness:** activate brand kit in Stage 1; palette + voice keywords thread into every shot prompt.
5. **MCP envelope gaps:** ffmpeg tools with array params → direct SDK POST when needed.
6. **On capability failure:** native failure → scenes fallback (automatic, with `native_fallback: <reason>` warning). Scenes failure → retry once per scene.
7. **Polling:** poll `get_creative_job` every 10–15s until status is `done`, `partial`, or `failed`.
8. **Bearer token:** cowork injects it; SDK curl reads `~/.daydream/credentials`.

## The cap chain

### Path A — Native multishot (RECOMMENDED when qualified)

```
shots[2–5] + delivery_promise:motion_led + duration ≤15s
  → submit_creative_job
       generation_mode: "native"   # or "auto" — auto decides via decideGenerationMode
       brief: { scenes with shot prompts, NO per-scene model_override }
       delivery_promise: "motion_led"
       global_model_override: "kling-v3-turbo-pro-t2v"  # optional explicit signal
  → get_creative_job             # poll until done
       success → ONE terminal scene with shot_prompts[] stamped
       failure → native_fallback reason → Path B
  → sonilo-t2m | music            # music_brief bed
  → ffmpeg-mux audio_fill:"loop"
  → ffmpeg-export                 # aspect_ratio exports
```

### Path B — Scenes fallback (when disqualified or native fails)

```
shots[2–5]
  → submit_creative_job
       generation_mode: "scenes"
       brief: { per-scene prompts, animate each independently }
  → get_creative_job             # poll; scenes populate url per scene as they finish
  → director_export              # stitch + optional soundtrack:"auto"
  → ffmpeg-export
```

## STAGE 0 — Confirm + qualify (~0 min, $0)

Read back shot count, total duration, and delivery_promise. Run the qualification checklist. State path: "native (qualified)" or "scenes (reason: …)".

**STOP:** "Brief looks right, and path is {native|scenes}? (approve / edit-shots / force-native / force-scenes)"

## STAGE 1 — Lock brand + shot list (~1 min, ~$0.05)

Activate brand kit. Show the 2–5 shot prompts as a numbered list with estimated seconds per shot (even split to stay ≤15s total). Thread palette keywords into every shot description.

**STOP:** "Shot list OK? (approve / rewrite-shot-[N] [new prompt])"

## STAGE 2 — Cost preview (~30s, $0)

Quote native cost (~$0.75–$2.50 for one multi_prompt call) vs scenes fallback (~$1.50–$4.00 for N animates). Show running estimate.

**STOP:** "Spend ~${estimate} on {native|scenes} render? (approve / switch-path / abort)"

## STAGE 3 — Render the commercial (~3–8 min, ~$0.75–$4.00)

Fire `submit_creative_job` with the chosen generation_mode. Poll `get_creative_job` every 10–15s. Post heartbeats every 2 min with elapsed time and status.

If native fails mid-flight, automatically fall back to scenes mode and note `native_fallback: <reason>` — do not silently retry native indefinitely.

**STOP:** "Commercial render OK? (approve / redo / fallback-accepted)"

## STAGE 4 — Soundtrack (~1 min, ~$0.15–$0.50)

Mux music bed under the clip unless the user opted out. Prefer sonilo-t2m for commercial licensing.

**STOP:** "Music OK? (approve / retry-music [direction] / skip-music)"

## STAGE 5 — Export + package (~30s, ~$0.02)

Export to requested aspect ratios. Write showcase HTML to `public/launches/{launch_slug}-commercial.html` with embedded reel, shot list, and generation path (native vs fallback).

## Quality bar (definition of done)

- ✅ **2–5 distinct shots** read as one continuous commercial — character/wardrobe/lighting held across cuts.
- ✅ Total duration **≤15s** — no padding, no dead air.
- ✅ Native path: ONE inference call, `shot_prompts[]` preserved on the terminal scene.
- ✅ Fallback path: scenes stitched cleanly; user told which path shipped.
- ✅ Music covers the full clip (unless explicitly skipped).
- ✅ Honest path disclosure in deliverable: "Rendered via native multishot" or "Scenes fallback: {reason}".

## Watch-outs

- **Qualification is strict for a reason.** Six shots, a 20s duration, or per-scene model picks all disqualify native — scenes mode still delivers, just without cross-shot continuity magic.
- **motion_led is required.** An image-default brief with 3 scenes will NOT auto-route to native — the codebase default for unspecified model is flux-dev (image). Set delivery_promise or global_model_override explicitly.
- **Native failure is normal under load.** fal latency, content filters, and duration enum mismatches happen. Scenes fallback is a feature, not a bug — ship the fallback reel and note the reason.
- **Voice-over complicates native.** A VO track usually means scenes mode + TTS + mux is cleaner. If voiceover is set, warn the user native may not be the best path.
- **Re-render whole take.** `director_re_render` on a native scene with `shot_prompts` and no new prompt regenerates the entire multi_prompt take — not a single shot in isolation.

## FINAL OUTPUT

```
✅ Native multishot commercial: public/launches/{launch_slug}-commercial.html
✅ Final MP4 ({duration}s, {aspect_ratio}): <URL>
✅ Generation path: {native | scenes (fallback: {reason})}
✅ Shots: {N}/{N}
✅ viewer_url: <URL if persisted>

Total spent: $X.XX
Total wall-clock: MM:SS
```

## AFTERCARE

1. **HQ upgrade** — same shot list, force scenes mode with balanced/HQ animate tier per shot for maximum fidelity (trades continuity for quality).
2. **Extend to 30s** — split into two native calls (shots 1–3 + shots 4–5) and concat — only if each segment qualifies independently.
3. **Platform cuts** — 9:16, 1:1, 16:9 exports from the same master via ffmpeg-export.
4. **Director pass** — swap one shot via scenes-mode `director_re_render` if native continuity held but one beat missed.

---

## Notes for the agent (only read if a step fails)

**decideGenerationMode logic:** 2–5 scenes, no per-scene model_override, delivery_promise motion_led OR video global_model_override, not source_led. See `lib/mcp-server/native-multishot.ts`.

**Native call bypasses create_media** — goes direct to `/inference` with multi_prompt. Still runs spend-cap preflight.

**Polling:** `get_creative_job` every 10–15s. Per-scene urls populate before job-level `done` in scenes mode — show partial progress.

**Duration enum:** Kling shot durations are whole-second enums with 3s floor. 5 shots × 3s = 15s max — do not plan 6 shots.