# Seedance 2.0 Dense Storyboard Mode for Multi-Shot Prompts: A Complete Technical Guide

> Explore Seedance 2.0 dense storyboard mode for multi-shot prompts. Learn how this profile breaks down complex narratives into stateful sequences with strict continuity.

- Repository: [Iamemily2050 /seedance-2.0](https://github.com/Emily2040/seedance-2.0)
- Tags: deep-dive
- Published: 2026-08-03

---

**Dense Storyboard Mode is the `dense_multishot` profile in Seedance 2.0 that breaks complex, multi-panel narratives into stateful, labeled sequences with strict continuity locks between shots.**

The `Emily2040/seedance-2.0` repository implements this mode to handle generation requests containing multiple cuts, storyboard beats, or shot changes within a single structured workflow. Unlike the alternative `phased_single_take` profile used for continuous takes, dense storyboard mode enforces disciplined endpoint visibility and provisional generation to maintain visual coherence across clip boundaries.

## What is Dense Storyboard Mode?

Dense Storyboard Mode activates when the Seedance 2.0 **classifier** detects explicit cut instructions—terms like "cut," "scene," or "beat"—in user prompts and confirms the target surface supports multi-shot structures. According to the reference specification in [`references/dense-storyboard-mode.md`](https://github.com/Emily2040/seedance-2.0/blob/main/references/dense-storyboard-mode.md), the system injects `"profile": "dense_multishot"` into the prompt JSON only when users explicitly request cuts inside one generation.

When activated, the mode treats each narrative beat as a discrete **shot** with deterministic labels (e.g., `Shot 1`, `Shot 2`) and applies strict architectural rules to prevent visual discontinuities. If the request should remain a single continuous take, the compiler automatically selects the `phased_single_take` profile instead, ensuring the prompt format matches both user intent and surface capabilities.

## Core Architectural Pillars

The dense multishot implementation rests on seven foundational pillars defined in the repository's sequence compiler manifest and skill documentation.

### Classifier-Driven Profile Selection

The **classifier** determines whether to invoke `dense_multishot` or `phased_single_take` by scanning natural language input for segmentation cues. This guarantees that multi-shot prompts only reach generation engines capable of handling stateful sequences, preventing incompatible requests from entering the pipeline.

### Shot Labels

Every beat receives a deterministic **shot label** (e.g., `Shot 1`, `Shot 2`). These labels serve as anchors for the generation engine and downstream continuity checks, creating reference points that persist across the compilation and review stages.

### One Action + One Endpoint per Shot

Each shot must describe exactly **one action** and one **concrete visual endpoint**. This constraint prevents the model from overloading individual clips with excessive location changes, multiple actions, or character shifts that could destabilize short-form generation. The endpoint represents the visible state that concludes the shot—critical for the next shot's inheritance logic.

### Continuity Locks

**Continuity locks** preserve visual state information—such as character pose, object location, or environmental lighting—across shot boundaries. When shot *n* completes, its endpoint data propagates into the "starting state" of shot *n+1*, ensuring the next clip inherits the previous visual foundation reliably.

### Endpoint Discipline

As specified on line 27 of [`references/dense-storyboard-mode.md`](https://github.com/Emily2040/seedance-2.0/blob/main/references/dense-storyboard-mode.md): *"Every dense storyboard beat must end in a completed visual state. If the endpoint is not visible, the next clip cannot inherit it safely."* This **endpoint discipline** prevents broken hand-offs where subsequent shots lack visual context, eliminating cascading errors in sequential generation.

### Provisional Later Generations

Prompts for shots beyond the current active clip remain **provisional** until the previous clip is accepted and reviewed. This iterative approach allows users to validate visual outputs before locking endpoints, stopping error propagation before it affects downstream shots.

### 2D-Animation Vocabulary

For 2D, anime, or cel-style work, the mode switches to animation-specific terminology—including references to layers, parallax, holds, and smear frames. This vocabulary swap gives the generation model the appropriate lexicon for non-photographic media while maintaining the same structural constraints.

## How the Prompt-Compilation Pipeline Works

The sequence compiler manifest at [`V6_SEQUENCE_PROMPT_COMPILER_MANIFEST.md`](https://github.com/Emily2040/seedance-2.0/blob/main/V6_SEQUENCE_PROMPT_COMPILER_MANIFEST.md) defines a five-stage pipeline for transforming user requests into dense storyboard outputs:

1. **User Input → Classifier** – The system scans natural language for explicit cut instructions.
2. **Profile Selection** – If cuts are required and the surface supports them, the compiler injects `"profile": "dense_multishot"` into the prompt JSON.
3. **Shot Generation** – For each beat, the compiler builds a sub-prompt containing a `label`, single `action`, and concrete `endpoint`.
4. **Continuity Lock Propagation** – The endpoint from shot *n* copies into the starting state of shot *n+1*.
5. **Iterative Review** – Post-generation, users review the visual output; only after acceptance does the compiler lock the endpoint and proceed to the next provisional shot.

This workflow is further described in the [`skills/seedance-sequence/SKILL.md`](https://github.com/Emily2040/seedance-2.0/blob/main/skills/seedance-sequence/SKILL.md) file, which outlines how the seedance-sequence skill activates dense storyboard handling.

## Practical Implementation Example

Below is a minimal JSON structure that triggers Dense Storyboard Mode. This example mirrors the compiler output for a request like "Create a three-panel chase sequence":

```json
{
  "profile": "dense_multishot",
  "surface": "default",
  "shots": [
    {
      "label": "Shot 1",
      "action": "A rogue sprints through a neon-lit alley",
      "endpoint": "Rogue at the alley's dead-end, neon glow reflected on his face"
    },
    {
      "label": "Shot 2",
      "action": "He flips over a dumpster",
      "endpoint": "Rogue airborne, dumpster below, city skyline in background"
    },
    {
      "label": "Shot 3",
      "action": "He lands on a moving hover-bike",
      "endpoint": "Rogue perched on bike, both heading toward a distant tower"
    }
  ],
  "continuityLocks": [
    "Rogue at the alley's dead-end",
    "Rogue airborne",
    "Rogue perched on bike"
  ]
}

```

Each shot follows the one-action-plus-one-endpoint rule, while the `continuityLocks` array demonstrates how endpoints become start states. For 2D animation requests, the same structure applies but replaces photographic vocabulary with animation-specific terms.

## Key Repository Files and References

The following files constitute the architectural backbone of Dense Storyboard Mode in the `Emily2040/seedance-2.0` repository:

- **[`references/dense-storyboard-mode.md`](https://github.com/Emily2040/seedance-2.0/blob/main/references/dense-storyboard-mode.md)** – Full specification covering the classifier logic, endpoint discipline rules, and continuity lock mechanics.
- **[`skills/seedance-sequence/SKILL.md`](https://github.com/Emily2040/seedance-2.0/blob/main/skills/seedance-sequence/SKILL.md)** – High-level description of the seedance-sequence skill that activates dense storyboard handling and multi-shot workflows.
- **[`V6_SEQUENCE_PROMPT_COMPILER_MANIFEST.md`](https://github.com/Emily2040/seedance-2.0/blob/main/V6_SEQUENCE_PROMPT_COMPILER_MANIFEST.md)** – The manifest driving the prompt-compilation pipeline, including `dense_multishot` profile injection and shot generation sequences.
- **[`tests/test_sequence_eval.py`](https://github.com/Emily2040/seedance-2.0/blob/main/tests/test_sequence_eval.py)** – Test suite validating correct handling of multi-shot sequences, continuity locks, and endpoint propagation across stateful clips.

## Summary

- **Dense Storyboard Mode** uses the `dense_multishot` profile to handle multi-shot generation requests with explicit cuts, while `phased_single_take` manages continuous takes.
- The **classifier** automatically selects the appropriate profile based on user intent and surface capabilities.
- **Shot labels** and **continuity locks** ensure deterministic state inheritance across clip boundaries.
- **Endpoint discipline** requires every shot to conclude with a visible visual state that the next shot can safely inherit.
- **Provisional generations** prevent error propagation by requiring user review before locking endpoints and proceeding to subsequent shots.
- The mode supports specialized **2D-animation vocabulary** for non-photographic media while maintaining the same structural constraints.

## Frequently Asked Questions

### What triggers Dense Storyboard Mode versus Single Take mode?

The **classifier** scans user prompts for explicit cut instructions like "cut," "scene," or "beat." If the request contains segmentation cues and the active surface supports multi-shot structures, the system selects `dense_multishot`. For continuous narratives without cuts, it defaults to `phased_single_take` as defined in the sequence compiler manifest.

### How does Seedance 2.0 maintain visual consistency between shots?

The system implements **continuity locks** that copy the concrete visual endpoint of shot *n* into the starting state of shot *n+1*. As documented in [`references/dense-storyboard-mode.md`](https://github.com/Emily2040/seedance-2.0/blob/main/references/dense-storyboard-mode.md), every beat must end in a completed visual state; if the endpoint is not visible, the next clip cannot inherit it safely, preventing broken hand-offs.

### Can I use Dense Storyboard Mode for 2D animation projects?

Yes. When the target surface indicates 2D, anime, or cel-style output, the mode automatically switches to animation-specific vocabulary including layers, parallax, holds, and smear frames. The structural requirements—single action per shot, concrete endpoints, and continuity locks—remain identical to photographic modes.

### What happens if I need to modify a shot after generation?

Dense Storyboard Mode treats subsequent shots as **provisional** until you review and accept the current clip's visual output. This iterative workflow allows you to reject or refine a shot before its endpoint locks into the continuity chain, preventing errors from propagating forward through the sequence.