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

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, 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: "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 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 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":

{
  "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 – Full specification covering the classifier logic, endpoint discipline rules, and continuity lock mechanics.
• 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 – The manifest driving the prompt-compilation pipeline, including dense_multishot profile injection and shot generation sequences.
• 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, 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}