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

> Master the Seedance 2.0 retake protocol for generated takes. Learn the five verdict triage system and the one-variable rule for efficient, reproducible results.

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

---

**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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/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:

```python
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`](https://github.com/Emily2040/seedance-2.0/blob/main/scripts/generation_run_check.py):

```bash
$ 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`](https://github.com/Emily2040/seedance-2.0/blob/main/references/retake-protocol.md) | Full protocol specification with verdict definitions and budget rules |
| [`SKILL.md`](https://github.com/Emily2040/seedance-2.0/blob/main/SKILL.md) | High‑level workflow integration and state management |
| [`skills/seedance-troubleshoot/SKILL.md`](https://github.com/Emily2040/seedance-2.0/blob/main/skills/seedance-troubleshoot/SKILL.md) | Troubleshooting skill referencing the protocol |
| [`scripts/generation_run_check.py`](https://github.com/Emily2040/seedance-2.0/blob/main/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`](https://github.com/Emily2040/seedance-2.0/blob/main/SKILL.md) and `seedance‑troubleshoot` maintain project state continuity
- **Code paths** in `seedance.workflow.triage_take()` and [`generation_run_check.py`](https://github.com/Emily2040/seedance-2.0/blob/main/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.