# Animated-Explainer Pipeline Stage Progression in OpenMontage: A Complete Technical Guide

> Discover the animated-explainer pipeline's nine-stage progression in OpenMontage. Learn how AI automation and human oversight ensure quality from concept to publication.

- Repository: [Calesthio/OpenMontage](https://github.com/calesthio/OpenMontage)
- Tags: how-to-guide
- Published: 2026-08-29

---

**The animated-explainer pipeline executes through nine distinct stages—from research and proposal generation through scriptwriting, scene planning, asset creation, editing, composition, and final publication—with strategic human checkpoints at critical decision points to balance AI automation with quality oversight.**

The `animated-explainer` pipeline in OpenMontage transforms raw topics into polished explainer videos through a structured, AI-driven workflow defined in [`pipeline_defs/animated-explainer.yaml`](https://github.com/calesthio/OpenMontage/blob/main/pipeline_defs/animated-explainer.yaml). This orchestration coordinates specialized director skills to manage everything from research briefs to final renders while enforcing strict budget constraints. Understanding the exact stage progression helps developers customize checkpoints, manage the default **$2.00 budget limit**, and integrate human oversight where it matters most.

## Pre-Production Phase

The workflow begins with foundational stages that establish factual accuracy and creative direction before any assets are generated.

### Research and Brief Generation

The pipeline initiates at the **research** stage, invoking the `pipelines/explainer/research-director` skill. Operating without human checkpoint requirements, this stage consumes no initial artifacts and produces a comprehensive `research_brief` that grounds the video in verified information. According to the source definition at lines 64-80 of [`pipeline_defs/animated-explainer.yaml`](https://github.com/calesthio/OpenMontage/blob/main/pipeline_defs/animated-explainer.yaml), this stage runs autonomously to gather contextual data before creative decisions commence.

### Proposal Development and Sampling

Next, the **proposal** stage executes via the `pipelines/explainer/proposal-director` skill, consuming the `research_brief` to generate both a `proposal_packet` and `decision_log`. This stage triggers a **mandatory human checkpoint** by default (lines 82-99), requiring explicit reviewer approval before the pipeline advances.

Embedded within the proposal stage is the **sample** sub-stage, which conditionally executes when the `video_analysis_brief_exists` condition evaluates true. This sub-stage leverages `tts_selector`, `image_selector`, `video_selector`, `video_compose`, and `audio_mixer` tools to generate a preview clip, also requiring human approval (lines 106-115). This mechanism allows stakeholders to validate visual and auditory styles before committing resources to full production.

## Production Phase

Once pre-production artifacts are approved, the pipeline enters the intensive production sequence comprising six major stages that transform text into final video output.

### Script Development

The **script** stage, handled by `pipelines/explainer/script-director`, transforms the `proposal_packet` (optionally referencing the `research_brief`) into a structured `script` artifact. requiring human checkpoint approval (lines 118-135) to ensure narrative accuracy and tone alignment before visual production begins.

### Scene Planning

Following script approval, the **scene_plan** stage invokes `pipelines/explainer/scene-director` to break the script into discrete visual segments. Consuming the `script` and optionally the `proposal_packet`, it produces a `scene_plan` artifact with mandatory human review (lines 140-158) to confirm shot sequencing and visual flow coherence.

### Asset Generation

The **assets** stage represents the most resource-intensive production step, executed by `pipelines/explainer/asset-director`. This stage consumes the `scene_plan` and `script` to produce an `asset_manifest` containing all visual and audio elements. With a broad `tools_available` declaration including text-to-speech selectors, image generators, and video creation tools (lines 170-186), this stage requires human checkpoint approval (lines 160-197) to verify asset quality against JSON schema validation and **review focus** criteria.

### Video Editing

Moving into post-production, the **edit** stage utilizes `pipelines/explainer/edit-director` to assemble raw materials. Consuming the `scene_plan` and `asset_manifest` (optionally the `script`), it produces `edit_decisions` that determine final sequencing. Unlike previous stages, this runs without default checkpoint requirements (lines 199-217), allowing AI-driven autonomous editing unless explicitly overridden by modifying `checkpoint_required` to `true`.

### Composition and Rendering

The **compose** stage, managed by `pipelines/explainer/compose-director`, executes the actual video rendering using `video_compose` and `audio_mixer` tools. Processing `edit_decisions` and the `asset_manifest` (optionally the `scene_plan`), it generates both a `render_report` and `final_review` artifact (lines 220-250). This stage proceeds without mandatory human checkpoints by default, though outputs undergo automated validation against success criteria defined in the stage configuration.

### Publication

The final **publish** stage, orchestrated by `pipelines/explainer/publish-director`, handles distribution logistics. Consuming the `render_report`, `final_review`, and optionally the `proposal_packet`, it produces a `publish_log` documenting distribution metrics. This stage defaults to requiring human checkpoint approval (lines 252-270), ensuring final quality assurance before public release.

## Architectural Controls

Beyond the linear stage progression, the pipeline implements sophisticated control mechanisms defined in the YAML configuration.

### Executive Orchestration and Budget Enforcement

The pipeline operates under **executive-producer** orchestration mode (`orchestration.mode`), with the top-level skill `pipelines/explainer/executive-producer` coordinating cross-stage communication. This architecture enforces strict financial constraints, defaulting to a **$2.00 limit** with defined revision caps (lines 45-52). The executive producer monitors cumulative costs across all tool invocations, automatically halting execution if thresholds are exceeded.

### Human Checkpoint System

Stages marked with `checkpoint_required: true` trigger explicit approval gates within the execution flow. While the research, edit, and compose stages proceed autonomously by default, the proposal, sample, script, scene_plan, assets, and publish stages require explicit human sign-off. Developers can override these defaults by modifying the boolean value in the respective stage definitions within [`pipeline_defs/animated-explainer.yaml`](https://github.com/calesthio/OpenMontage/blob/main/pipeline_defs/animated-explainer.yaml).

### Tool Availability and Skill Integration

Each stage declares available tools via the `tools_available` parameter, enabling flexible substitution of concrete implementations without altering pipeline logic. The assets stage accesses the broadest toolkit including diagram generators and multimedia selectors, while the compose stage specifically requires `video_compose` and `audio_mixer` capabilities. This modular design pattern ensures individual skills can be updated as AI models evolve without disrupting the broader stage progression.

## Running the Pipeline Programmatically

Developers interact with the stage progression through the OpenMontage Python API. The following example demonstrates initializing the pipeline, monitoring stage transitions, and handling checkpoint approvals:

```python
from openmontage import PipelineRunner

# Initialise a runner for the animated-explainer pipeline

runner = PipelineRunner(pipeline_name="animated-explainer")

# Start the pipeline with a high-level prompt

run_id = runner.start(
    input_topic="How quantum computing works",
    reference_video=None,            # optional reference video

    budget_usd=2.0,
)

# Poll for stage completions (simplified loop)

while not runner.is_complete(run_id):
    status = runner.status(run_id)
    print(f"Current stage: {status['stage']}")
    # Handle human checkpoints at proposal, script, or publish stages

    if status.get("needs_approval"):
        # Present status['artifact'] to reviewer for approval

        runner.approve(run_id, approve=True)

print("Pipeline finished! Output:", runner.output(run_id))

```

This implementation leverages the `PipelineRunner` class to instantiate the workflow defined in [`pipeline_defs/animated-explainer.yaml`](https://github.com/calesthio/OpenMontage/blob/main/pipeline_defs/animated-explainer.yaml). The polling loop monitors the active stage while checking for `needs_approval` flags that correspond to the checkpoint-enabled stages identified in the YAML configuration. The script [`scripts/kling_official_animated_explainer_e2e.py`](https://github.com/calesthio/OpenMontage/blob/main/scripts/kling_official_animated_explainer_e2e.py) provides a complete command-line demonstration of this pattern.

## Summary

- The **animated-explainer** pipeline executes through nine sequential stages defined in [`pipeline_defs/animated-explainer.yaml`](https://github.com/calesthio/OpenMontage/blob/main/pipeline_defs/animated-explainer.yaml), progressing from research through final publication.
- **Human checkpoints** are strategically positioned at the proposal, sample, script, scene_plan, assets, and publish stages, while research, edit, and compose stages run autonomously by default.
- Each stage invokes a specific director skill (e.g., `pipelines/explainer/script-director`) and produces typed artifacts (e.g., `script`, `asset_manifest`) that feed subsequent stages in the chain.
- The **executive-producer** orchestration mode enforces a default **$2.00 budget limit** and manages tool availability declarations (`tools_available`) across the workflow.
- End-to-end execution is available via the `PipelineRunner` Python API, with stage-specific implementations located in `skills/pipelines/explainer/*-director.py` files.

## Frequently Asked Questions

### What triggers the sample sub-stage during the proposal phase?

The **sample** sub-stage executes conditionally when the `video_analysis_brief_exists` parameter evaluates to true within the proposal stage context. This allows the pipeline to generate preview clips using `tts_selector`, `image_selector`, and `video_compose` tools only when reference video analysis is available, requiring human approval before proceeding to full production.

### How does the pipeline enforce budget constraints across stages?

The **executive-producer** orchestration mode monitors cumulative tool invocation costs against the default **$2.00 budget limit** defined in lines 45-52 of [`pipeline_defs/animated-explainer.yaml`](https://github.com/calesthio/OpenMontage/blob/main/pipeline_defs/animated-explainer.yaml). If a stage's tool calls approach this threshold, the executive producer skill halts execution, preventing expensive operations in the assets, edit, or compose stages from exceeding financial constraints.

### Can human checkpoints be disabled for fully automated workflows?

Yes, developers can modify the `checkpoint_required` boolean in the YAML stage definitions to bypass human approval gates. While the proposal, script, and assets stages default to `checkpoint_required: true`, setting these to `false` allows the `PipelineRunner` to proceed automatically through the research, edit, compose, and modified stages without invoking `runner.approve()`.

### Which artifacts are required versus optional at each stage?

Required artifacts form a strict dependency chain: **research** produces `research_brief` (no input); **proposal** requires `research_brief`; **script** requires `proposal_packet`; **scene_plan** requires `script`; **assets** requires both `scene_plan` and `script`; **edit** requires `scene_plan` and `asset_manifest`; **compose** requires `edit_decisions` and `asset_manifest`; **publish** requires `render_report` and `final_review`. Optional artifacts like `proposal_packet` and `research_brief` provide additional context to downstream stages but do not block execution.