Pipeline System

OpenMontage defines complete video production workflows through declarative YAML manifests stored in pipeline_defs/. These manifests replace any central Python orchestrator: the LLM agent reads the manifest to determine stage order, then follows the corresponding stage-director skill for each step.

Manifest Structure

A manifest is a JSON-schema-validated YAML document. Key top-level fields include:

name: animated-explainer
version: "2.0"
category: generated
default_checkpoint_policy: guided

orchestration:
  mode: executive-producer
  skill: pipelines/explainer/executive-producer
  budget_default_usd: 2.00
  max_revisions_per_stage: 3

compatible_playbooks:
  - clean-professional
  - flat-motion-graphics

stages:
  - name: research
    skill: pipelines/explainer/research-director
    produces: [research_brief]
    tools_available: []
    checkpoint_required: false
    human_approval_default: false
    review_focus: [...]
    success_criteria: [...]
  # ... additional stages

The orchestration block sets global rules such as budget defaults and revision limits. The stages array declares the exact sequence, required artifacts, available tools, and approval gates. Each stage references a Markdown skill file that the agent must read before executing work.

Standard Stage Progression

Most pipelines follow this canonical 8-stage flow:

research → proposal → script → scene_plan → assets → edit → compose → publish
  • research and proposal establish scope, concepts, and production plan.
  • script produces timestamped narration with cues.
  • scene_plan defines visual cuts and timing.
  • assets generates or sources media.
  • edit produces edit_decisions.
  • compose renders the final video via the locked runtime.
  • publish records delivery.

Creative stages typically default to human_approval_default: true. Technical stages default to false unless the checkpoint policy overrides them. See Checkpoint System for how policies interact with these gates.

Available Pipelines

OpenMontage ships 12 pipelines. Each declares a category that influences compatible playbooks and default behavior:

Pipeline Category Notes
animated-explainer generated Research + proposal flow for explainer videos
animation animation Motion graphics and kinetic typography
avatar-spokesperson talking_head Avatar-driven presenter videos
character-animation animation SVG rigs and HyperFrames rendering
cinematic cinematic Mood-led trailers with optional reference input
clip-factory custom Batch short-form clips from long source
hybrid hybrid Source footage plus generated support visuals
localization-dub custom Subtitle, dub, and translate existing video
podcast-repurpose hybrid Podcast highlights to video
screen-demo screen_recording Software walkthroughs
talking-head talking_head Footage-led speaker videos
framework-smoke custom Minimal validation pipeline

Full details, including stability levels and extension flags, live in the reference. See Available Pipelines.

Agent Orchestration Rules

The agent loads a manifest with lib/pipeline_loader.py helpers such as load_pipeline(), get_stage_order(), and get_required_tools(). For each stage it:

  1. Reads the stage's director skill.
  2. Calls only tools listed in tools_available (or selectors when appropriate).
  3. Produces the declared artifacts.
  4. Writes a checkpoint before advancing.

Specialized pipelines insert domain stages (for example, character-animation adds character_design and rig_plan). Reference-input support is declared per-manifest via the reference_input block and activates analysis tools when a video_analysis_brief is present.

Manifests also declare compatible_playbooks, which the proposal stage uses to lock a visual style. The chosen playbook travels forward in checkpoints and edit_decisions.

Updated June 24, 2026