# Animation Duration Rules in video-use: Guidelines for Timing Overlays

> Discover video-use animation duration rules: 3-14s for narration, 0.5-2s for accents, and 1s+ holds. Optimize your video timing with these guidelines.

- Repository: [Browser Use/video-use](https://github.com/browser-use/video-use)
- Tags: how-to-guide
- Published: 2026-08-06

---

**Video-use enforces soft duration guidelines—specifically 3–14 seconds for narration-synced animations, 0.5–2 seconds for beat-synced accents, and mandatory ≥1 second final frame holds—rather than hard-coded length limits.**

These rules live in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md) and propagate through the entire rendering pipeline, from LLM planning to final video assembly. Understanding how video-use handles animation timing helps you create overlays that feel natural and professional.

## Core Duration Guidelines in video-use

The `video-use` repository, developed by browser-use, structures animation timing around **communication purpose** rather than arbitrary seconds. The guidelines in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md) serve as a contract between the LLM planner and the rendering engine.

### Sync-to-Narration: 3–14 Seconds

Animations that explain spoken content need time to be absorbed at normal reading speed. The typical range spans **3 seconds to 14 seconds**, with simple information cards landing in the **5–7 second sweet spot**.

This rule directly shapes the `duration` field in the EDL. In [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) (lines 498–503), each overlay entry carries this value, and the pipeline trims or pads clips to match.

### Beat-Synced Accents: 0.5–2 Seconds

For fast-paced montages or music-driven sequences, animations function as **visual punctuation** rather than information delivery. These flash quickly—half a second to two seconds—creating rhythm without demanding attention.

### Mandatory Hold Final Frame: ≥1 Second

Every animation must display its final frame for **at least 1 second** before the next cut begins. This prevents jarring transitions and gives viewers mental closure. The Manim example below demonstrates this with `self.wait(1.0)`.

### Over Voice-Over: Narration Length + 1 Second

When audio narration accompanies an animation, total duration must equal **spoken length plus 1 second**. This buffer guarantees the voice completes before visual transition, avoiding the common error of cutting mid-sentence.

### One-Thing-At-A-Time Rule

Never reveal two independent visual elements simultaneously. The human eye tracks single new objects; overlapping introductions create confusion. The animation should **focus, pause, transition**—sequential revelation only.

### Payoff Timing for Narrative Beats

When an animation illustrates a specific "payoff" word in narration, scheduling requires special handling. Start the reveal **`reveal_duration` seconds earlier** so the final frame aligns precisely with the spoken payoff word, creating synchronized impact.

## How the Rendering Pipeline Enforces Durations

These guidelines are **soft rules**—recommendations for the LLM—not engine-enforced hard limits. The actual enforcement happens through data flow:

### EDL Duration Field in helpers/render.py

The rendering engine reads planned durations from the Edit Decision List:

```python

# Example EDL structure from helpers/render.py

edl = {
    "overlays": [
        {
            "file": "edit/animations/slot_3/render.mp4",
            "start_in_output": 12.5,
            "duration": 6.0      # Planned 6-second animation

        }
    ]
}

```

The `duration` value originates from the LLM's plan that followed the sync-to-narration guidelines. The pipeline uses this to trim source clips and assemble the final timeline.

### Manim run_time Requirements

The Manim reference at [`skills/manim-video/references/animations.md`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/references/animations.md) requires explicit `run_time` on every animation object. Omitting it defaults to 1 second—often violating the 3–14 second narration rule and producing unreadable overlays.

```python
from manim import *

class ExplainGraph(Scene):
    def construct(self):
        axes = Axes()
        self.play(Create(axes))
        graph = axes.plot(lambda x: x**2, color=BLUE)
        # Explicit 7-second duration follows sync-to-narration guideline

        self.play(Create(graph), run_time=7.0)
        self.wait(1.0)   # Hold final frame per ≥1s rule

```

### HyperFrames and Remotion Duration Flags

For HTML/CSS-based animations, slot-generation scripts pass duration directly to render commands:

```bash

# HyperFrames slot generation with explicit duration

npx --yes hyperframes init . --example blank --non-interactive --skip-skills

# ... animation creation ...

npx --yes hyperframes render . -o render.mp4 --duration 6

```

The `--duration 6` flag ensures the rendered output matches the LLM's planned timing.

## Key Source Files for Duration Logic

| File | Function |
|------|----------|
| [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md) | Central repository of duration guidelines and production rules |
| [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) | Reads EDL `duration` fields and assembles final video with trimmed overlays |
| [`skills/manim-video/references/animations.md`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/references/animations.md) | Mandates explicit `run_time` for all Manim animations |
| [`helpers/pack_transcripts.py`](https://github.com/browser-use/video-use/blob/main/helpers/pack_transcripts.py) | Supplies transcript timestamps for calculating animation start times and payoff alignment |

## Common Duration Mistakes to Avoid

- **Defaulting to Manim's 1-second run_time** — Always set explicit `run_time` to match your narration timing
- **Cutting before final frame hold** — The ≥1 second rule exists because audiences need closure; violating it feels rushed
- **Synchronizing payoff to animation start rather than end** — Calculate `reveal_duration` backward from the spoken word
- **Stacking simultaneous reveals** — The one-thing-at-a-time rule prevents cognitive overload; sequence your elements

## Summary

- **Video-use duration rules are guidelines, not hard limits** — The LLM plans timing; the rendering pipeline executes via EDL `duration` fields
- **Narration-synced animations run 3–14 seconds** (typically 5–7s); beat-synced accents run 0.5–2 seconds
- **Every animation requires ≥1 second final frame hold** and total duration exceeding voice-over length by 1 second
- **Source files enforce timing through data**: [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md) documents rules, [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) executes them, and skill-specific references like Manim's [`animations.md`](https://github.com/browser-use/video-use/blob/main/animations.md) require explicit parameters

## Frequently Asked Questions

### Does video-use automatically calculate animation durations based on transcripts?

No. The [`helpers/pack_transcripts.py`](https://github.com/browser-use/video-use/blob/main/helpers/pack_transcripts.py) module provides transcript timestamps that the LLM uses for planning, but duration calculation remains a **planning decision** by the LLM following the guidelines in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md). The rendering pipeline executes what the EDL specifies without re-computing timing.

### What happens if I omit run_time in a Manim animation for video-use?

Manim defaults to **1 second**, which frequently violates the sync-to-narration guideline. The reference at [`skills/manim-video/references/animations.md`](https://github.com/browser-use/video-use/blob/main/skills/manim-video/references/animations.md) explicitly requires setting `run_time` to ensure animations respect the planned duration strategy.

### Are the duration rules enforced by code or just documented?

Both, but at different stages. The rules in [`SKILL.md`](https://github.com/browser-use/video-use/blob/main/SKILL.md) are **soft guidelines** for LLM planning. Hard enforcement occurs when [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) reads the `duration` field from the EDL and trims clips accordingly—if the LLM followed guidelines, the output matches intent; if not, the engine still renders what was planned.

### How does payoff timing work with non-Manim animation tools?

The same mathematical principle applies: begin the reveal early enough that the final frame aligns with the payoff word. In HyperFrames or Remotion, this means setting `--start` or equivalent offsets so the animation completes at the target timestamp, with the duration flag matching the calculated `reveal_duration` plus final hold time.