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

> Discover OpenMontage quality gates and review protocols. Learn about its 4-stage pipeline: DeliveryPromise, pre-compose, HyperFrames, and post-render validation to ensure video production excellence.

- Repository: [Calesthio/OpenMontage](https://github.com/calesthio/OpenMontage)
- Tags: best-practices
- Published: 2026-08-30

---

**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`](https://github.com/calesthio/OpenMontage/blob/main/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.

```python
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, ...}

```

```python
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`](https://github.com/calesthio/OpenMontage/blob/main/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.

```python
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`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/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.