Seedance 2.0 Retake Protocol for Generated Takes: Complete Guide to the Five‑Verdict Triage System

The Seedance 2.0 retake protocol evaluates every generated take through a structured five‑verdict system—Keep, Fix in Post, Edit, Re‑roll, or Rewrite—and enforces a one‑variable‑per‑retake rule to maintain reproducibility and cost control.

The Seedance 2.0 retake protocol governs how the system handles generated takes (clips, frames, or audio segments) after they return from the generation pipeline. Rather than simple accept‑or‑reject decisions, the protocol implements a disciplined triage workflow that balances creative quality against compute costs. This design is codified in references/retake-protocol.md and integrated throughout the repository's skill system.

The Five‑Verdict Triage System

When a take completes generation, the protocol routes it through one of five possible verdicts. Each verdict triggers a specific action path:

Verdict	Definition	Action Taken
Keep	Quality meets requirements; usable as‑is	Record in project canon and proceed
Fix in Post	Minor defects correctable after generation	Apply post‑production fixes (color, sync, etc.)
Edit	Generally good but needs targeted adjustment	Perform single‑variable edit on existing asset
Re‑roll	Fundamentally unsatisfactory; prompt is sound	Regenerate with same prompt, new seed
Rewrite	Prompt itself is faulty (ambiguous, over‑specified)	Modify one prompt clause and regenerate

The triage_take() function in the workflow layer returns these verdicts as standardized strings, as shown in scripts/generation_run_check.py.

One‑Variable‑Per‑Retake Rule

Reproducibility demands controlled experimentation. The protocol enforces that only one variable may change per retake attempt—either a single prompt clause, the random seed, the generation mode, or a reference asset.

This rule prevents confounding variables that obscure causality:

• Same prompt + different seed → pure re‑roll
• Same seed + different prompt clause → controlled rewrite

Violating this rule—changing multiple aspects simultaneously—makes it impossible to attribute improvement or regression to any specific change, as documented in references/retake-protocol.md.

Attempt Budgets and Cost Awareness

Compute costs scale directly with generation duration and resolution:

• 720p: ≈ $0.30 per second
• 1080p: ≈ $0.68 per second

The retake-protocol.md specification mandates attempt budgets with explicit stop conditions—typically capped at 5 retakes per take. This prevents runaway spending and forces disciplined decision‑making at each triage point.

The cost factor particularly influences the Fix in Post and Edit verdicts: when minor corrections suffice, avoiding regeneration preserves budget for subsequent creative decisions.

Integration with Seedance Workflow

The retake protocol connects to three core system components:

Take Triage Invocation The seedance‑troubleshoot skill and generic take‑review workflow both invoke protocol logic, as referenced in skills/seedance-troubleshoot/SKILL.md.

Project State Updates After any verdict execution, the canonical project state updates via the "observed end state" mechanism described in SKILL.md. This ensures deterministic continuity across generation sessions.

Continuation Handoff Subsequent prompts read the updated canon, maintaining narrative consistency without state contamination.

Code Implementation Examples

The repository ships helper scripts demonstrating protocol usage:

from seedance.workflow import triage_take

# Generate and evaluate a take

take = generate_take(prompt, seed, mode, reference)
verdict = triage_take(take)  # Returns: keep, fix_in_post, edit, reroll, rewrite

# Route based on verdict

if verdict == "keep":
    register_canon(take)
elif verdict == "fix_in_post":
    post_process(take)
elif verdict == "edit":
    edit_take(take, changes="single_prompt_clause")
elif verdict == "reroll":
    take = generate_take(prompt, new_seed(), mode, reference)
elif verdict == "rewrite":
    new_prompt = modify_prompt(prompt, clause="only_one_change")
    take = generate_take(new_prompt, seed, mode, reference)

Command‑line interface from scripts/generation_run_check.py:

$ python scripts/generation_run_check.py --prompt "..." --mode cinematic

# Output:

# > Verdict: rewrite – change one prompt clause and retry

Key Source Files

File	Purpose
references/retake-protocol.md	Full protocol specification with verdict definitions and budget rules
SKILL.md	High‑level workflow integration and state management
skills/seedance-troubleshoot/SKILL.md	Troubleshooting skill referencing the protocol
scripts/generation_run_check.py	CLI utility implementing verdict suggestions

Summary

• Five verdicts (Keep, Fix in Post, Edit, Re‑roll, Rewrite) structure every take evaluation
• One‑variable rule ensures reproducible experimentation across retakes
• Attempt budgets enforce cost discipline with explicit generation caps
• Integration points in SKILL.md and seedance‑troubleshoot maintain project state continuity
• Code paths in seedance.workflow.triage_take() and generation_run_check.py implement the protocol

Frequently Asked Questions

What triggers a "Rewrite" versus a "Re‑roll" verdict?

A Rewrite applies when the prompt contains defects—ambiguous wording, over‑specification, or logical conflicts that prevent quality output regardless of random seed. A Re‑roll applies when the prompt is sound but the specific generation produced unsatisfactory results; changing only the seed generates a new stochastic variation without altering the creative intent.

Why does Seedance 2.0 restrict changes to one variable per retake?

Changing multiple variables simultaneously creates confounded experiments where improvement or regression cannot be attributed to any specific change. The one‑variable rule mirrors scientific methodology: isolate cause and effect to build reproducible understanding of how prompts, seeds, modes, and references influence output quality.

How does the attempt budget prevent cost overruns?

The protocol caps retakes—typically at 5 attempts per take—based on generation costs scaling at $0.30–$0.68 per second depending on resolution. Hard stop conditions force decisive verdicts rather than incremental tweaking, preserving budget for the broader project pipeline rather than exhausting resources on single takes.

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