Available Pipelines in OpenMontage for Different Production Workflows: A Complete Guide

OpenMontage provides 13 declarable YAML pipelines—including talking-head, screen-demo, documentary-montage, and localization-dub—that automate end-to-end video production workflows from ingestion to final render.

OpenMontage is an open-source video production automation framework that orchestrates complex media workflows through declarative configuration files. The available pipelines in OpenMontage for different production workflows are defined as YAML manifests stored in the pipeline_defs/ directory, each specifying stage sequences, required tools, and human approval gates validated against schemas/pipelines/pipeline_manifest.schema.json.

Understanding Pipeline Architecture

Every pipeline in OpenMontage is a self-contained manifest that declares its production category, supported file extensions, required skills, and an ordered list of stages. These manifests reside in pipeline_defs/ and are consumed by the core loader in lib/pipeline_loader.py, which validates schema compliance and exposes helper utilities for orchestration.

The manifest structure includes:

• Pipeline metadata: name, version, description, and category
• Extension support: input/output formats handled by the workflow
• Skill requirements: capabilities required from the execution environment
• Stage definitions: ordered processing steps with optional sub-stages and tool assignments

Complete Catalog of Production Pipelines

The repository ships with 13 production-ready pipelines targeting distinct creative scenarios:

talking-head (pipeline_defs/talking-head.yaml) Category: talking_head End-to-end creation of polished talking-head videos from raw footage. The workflow handles transcription, automated edit decisions, subtitle generation, audio mixing, and final rendering.

screen-demo (pipeline_defs/screen-demo.yaml) Category: screen_recording Generates screen-recording demonstrations from either live application captures or synthetic terminal animations (Remotion). Includes automated call-outs, zoom crops, subtitle overlay, and audio cleanup.

documentary-montage (pipeline_defs/documentary-montage.yaml) Category: documentary Retrieval-first thematic montage builder that constructs a semantic corpus from public stock sources (Pexels, Archive.org, NASA, Wikimedia, Unsplash) and assembles narrative-driven sequences using CLIP-based retrieval.

podcast-repurpose (pipeline_defs/podcast-repurpose.yaml) Category: podcast Transforms existing podcast audio into short promotional video clips with automatic caption generation, waveform visualization, and optional background imagery compositing.

localization-dub (pipeline_defs/localization-dub.yaml) Category: localization Localizes existing video content by replacing audio tracks with newly generated dubs in target languages while preserving lip-sync timing and re-rendering translated subtitles.

hybrid (pipeline_defs/hybrid.yaml) Category: hybrid Combines live-action footage with AI-generated assets—such as background plates and CGI elements—to produce videos leveraging both real and synthetic content.

framework-smoke (pipeline_defs/framework-smoke.yaml) Category: framework_smoke Lightweight validation pipeline that acts as a "smoke test" for new custom pipeline configurations, verifying that tools and skills are correctly wired before full production deployment.

clip-factory (pipeline_defs/clip-factory.yaml) Category: clip_factory Generates short, single-purpose clips including intros, outros, and lower-thirds from source media, applying consistent branding and style templates.

cinematic (pipeline_defs/cinematic.yaml) Category: cinematic Produces high-production-value cinematic sequences using AI-driven storyboarding, scene planning, and visual effects tools, optimized for trailer-type content.

character-animation (pipeline_defs/character-animation.yaml) Category: character_animation Builds animated character-centric videos from text scripts, handling pose generation, lip-sync animation, and background compositing.

avatar-spokesperson (pipeline_defs/avatar-spokesperson.yaml) Category: avatar_spokesperson Creates synthetic avatar presentations for product demos or explainers, combining realistic facial expression synthesis with voice generation.

animation (pipeline_defs/animation.yaml) Category: animation General-purpose pipeline for generating 2-D or 3-D animated sequences from storyboard assets and motion specifications.

animated-explainer (pipeline_defs/animated-explainer.yaml) Category: animated_explainer End-to-end workflow for explainer videos combining animated graphics, kinetic typography, and voice-over narration into cohesive educational content.

Pipeline Discovery and Validation

The lib/pipeline_loader.py module provides the primary interface for discovering and validating these workflows. According to the OpenMontage source code, the loader implements several key utilities:

• list_pipelines() – Returns the complete list of available pipeline names discovered in pipeline_defs/
• load_pipeline(name) – Loads and validates a specific manifest, returning a dictionary used by the orchestration engine
• get_stage_order() – Extracts the ordered list of stages and optional sub-stages from a loaded manifest
• get_required_tools() – Aggregates the toolset required across all stages, enabling the backlot to provision correct executors

Validation occurs against schemas/pipelines/pipeline_manifest.schema.json, ensuring every manifest contains required fields like pipeline name, version, category, and stage definitions before execution.

Querying Pipelines Programmatically

You can inspect available pipelines and load specific manifests using the Python API:

from openmontage.lib.pipeline_loader import list_pipelines, load_pipeline

# List all pipelines shipped with OpenMontage

available = list_pipelines()
print("Available pipelines:", available)

# → ['talking-head', 'screen-demo', 'documentary-montage', ... ]

To load a specific pipeline manifest:

# Load the manifest for the talking-head pipeline

talking_head = load_pipeline("talking-head")
print(talking_head["description"].strip())

# → End-to-end talking-head video pipeline. Takes raw footage of a person speaking, …

Inspecting stage order for workflow planning:

from openmontage.lib.pipeline_loader import get_stage_order

stages = get_stage_order(talking_head, include_sub_stages=True)
print(stages)

# → ['idea', 'script', 'scene_plan', 'assets', 'edit', 'compose']

Summary

• OpenMontage defines 13 production pipelines as YAML manifests in pipeline_defs/, covering workflows from talking-head interviews to AI-generated documentaries.
• Each pipeline specifies categories, supported extensions, required skills, and ordered stages validated against schemas/pipelines/pipeline_manifest.schema.json.
• The lib/pipeline_loader.py module provides list_pipelines(), load_pipeline(), and get_stage_order() utilities for programmatic discovery and validation.
• The orchestration engine referenced in backlot/server.py uses these manifests to drive execution across the appropriate tools and skills.

Frequently Asked Questions

How do I add a custom pipeline to OpenMontage?

Create a new YAML file in pipeline_defs/ following the structure defined in schemas/pipelines/pipeline_manifest.schema.json. Define your pipeline name, version, category, and stage sequence, then validate it using load_pipeline() from lib/pipeline_loader.py to ensure the framework recognizes your configuration before attempting production runs.

Which pipeline should I use for repurposing existing podcast content?

Use the podcast-repurpose pipeline defined in pipeline_defs/podcast-repurpose.yaml. This workflow automatically generates captions, adds waveform visualization, and composites background imagery to convert audio-only podcasts into short-form video clips suitable for social media promotion.

What is the difference between the animation and animated-explainer pipelines?

The animation pipeline (pipeline_defs/animation.yaml) provides general-purpose 2-D or 3-D sequence generation from storyboards, while animated-explainer (pipeline_defs/animated-explainer.yaml) is a specialized end-to-end workflow that combines kinetic typography, graphics, and voice-over specifically for educational explainer content targeted at the animated_explainer category.

How does OpenMontage validate pipeline configurations before execution?

The framework validates every manifest against schemas/pipelines/pipeline_manifest.schema.json using the loader in lib/pipeline_loader.py. Additionally, the framework-smoke pipeline (pipeline_defs/framework-smoke.yaml) serves as a lightweight integration test that verifies custom configurations, tool availability, and skill wiring without executing full production workloads.

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