OpenMontage Quality Gates and Review Protocols for Video Production: The 4-Stage Pipeline

OpenMontage implements a mandatory four-stage validation system—DeliveryPromise classification, pre-compose validation, HyperFrames workspace verification, and post-render self-review—that automatically aborts rendering when videos fail to meet motion ratio requirements, technical specifications, or pipeline-specific quality criteria.

OpenMontage enforces rigorous quality gates and review protocols for video production through a multi-layered pipeline that validates content from proposal to final render. According to the calesthio/OpenMontage source code, this architecture prevents "garbage" video delivery by checking delivery promises against edit cuts, validating workspace compositions, and performing automated post-render analysis before any asset reaches the viewer.

Stage 1: DeliveryPromise Enforcement for Production Quality

The first quality gate activates during the proposal stage, before any provider selection occurs. In lib/delivery_promise.py, the DeliveryPromise class locks the intended video type—such as motion_led, source_led, or screen_demo—and validates that planned edit cuts satisfy the specific rules defined in the PROMISE_RULES configuration and PromiseType enum.

Validating Motion Ratios and Fallback Rules

The validate_cuts method computes motion ratios and checks for violations such as insufficient motion percentage or unauthorized still-led fallbacks. For example, a motion_led promise requires a minimum motion ratio of 70%, while other types may permit different thresholds or fallback allowances.

from lib.delivery_promise import classify_from_brief, DeliveryPromise

promise = classify_from_brief(
    pipeline_type="cinematic",
    user_intent={"tone_mode": "cinematic", "quality_floor": "presentable"},
)
print(promise.to_dict())

# → {'promise_type': 'motion_led', 'motion_required': True, ...}

cuts = [
    {"source": "clip1.mp4", "type": "video"},
    {"source": "slide1.png", "type": "text_card"},
    {"source": "clip2.mov", "type": "video"},
]
validation = promise.validate_cuts(cuts)

if not validation["valid"]:
    print("❌ Violations:", validation["violations"])
else:
    print("✅ Motion ratio:", validation["motion_ratio"])

Stage 2: Pre-Compose and HyperFrames Quality Protocols

Before rendering begins, the system runs two consecutive validation layers. The pre-compose quality gate aborts rendering if the plan contains critical violations such as delivery-promise non-compliance or missing assets. This checkpoint is documented in the README under Production-grade quality gates and serves as the final safeguard before compute-intensive rendering begins.

HyperFrames Workspace Verification

The hyperframes_compose tool in tools/video/hyperframes_compose.py executes the _check method to evaluate workspace completeness, contrast levels, and optional strictness checks immediately after HTML and Remotion composition but before final rendering.

from tools.video.hyperframes_compose import HyperFramesTool

hf = HyperFramesTool()
result = hf._check({"workspace": Path("/tmp/workspace"), "skip_contrast": False})
if not result.success:
    raise RuntimeError(f"HyperFrames check failed: {result.error}")
print("✅ HyperFrames quality gate passed")

Stage 3: Post-Render Review and Executive Gates

After the final video file generates, automated self-review analyzes the rendered output using ffprobe to extract metadata, sample representative frames for visual fidelity checks, and perform audio analysis to verify codec integrity, bitrate sanity, and audio-video synchronization.

Pipeline-Specific Executive-Producer Criteria

Each pipeline definition in skills/pipelines/*/executive-producer.md contains domain-specific quality criteria. For example, the avatar-spokesperson pipeline enforces lip-sync quality checks and call-to-action (CTA) placement validation, while podcast-repurpose pipelines verify translation accuracy and emotional pacing consistency.

Summary

OpenMontage's quality architecture ensures that only production-ready videos reach users through systematic validation at every production phase. The key safeguards include:

• DeliveryPromise enforcement in lib/delivery_promise.py that validates motion ratios and fallback rules before provider selection
• Pre-compose validation that aborts rendering for critical plan violations or missing assets
• HyperFrames verification via tools/video/hyperframes_compose.py checking workspace integrity and visual quality before final render
• Post-render self-review using ffprobe and frame analysis to confirm technical specifications and audio integrity
• Executive-producer gates defined in pipeline-specific markdown files enforcing domain criteria like lip-sync accuracy

Frequently Asked Questions

What triggers a quality gate failure in OpenMontage?

A quality gate failure occurs when content violates any mandatory checkpoint, such as motion ratios falling below the PROMISE_RULES threshold or audio-video sync errors detected during post-render ffprobe analysis. The system halts immediately, reports the specific violation, and either requests human approval or falls back to a safe alternative like a still-led version.

How does the DeliveryPromise system prevent mismatched video styles?

The DeliveryPromise class in lib/delivery_promise.py locks the video type at the proposal stage using the classify_from_brief function and PromiseType enum. This ensures that subsequent edit cuts processed by validate_cuts adhere to style-specific constraints like minimum motion requirements before any rendering resources are committed.

Where are pipeline-specific quality criteria defined?

Pipeline-specific criteria reside in skills/pipelines/*/executive-producer.md files. Each pipeline maintains its own checklist for domain-specific requirements including lip-sync quality, translation timing accuracy, and emotional pacing consistency.

What happens when a video fails the post-render self-review?

When post-render analysis detects codec errors, insufficient bitrates, or audio clipping through ffprobe metadata extraction, the system prevents delivery and logs the specific technical failure. It then triggers either automatic re-rendering with adjusted parameters or manual review depending on the severity and pipeline configuration.

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