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

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. 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, 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.

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:

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. 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 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, 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. 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.

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