OpenMontage Slideshow Risk Scoring: How It Prevents "Animated PowerPoint" Outputs

OpenMontage prevents "animated PowerPoint" outputs by scoring every video plan across six quantitative dimensions—such as typography overreliance, repetition, and weak cinematic intent—before composition begins, automatically aborting the pipeline when the averaged risk score exceeds 4.0.

OpenMontage enforces cinematic quality through automated risk analysis that blocks slide-heavy video plans before they reach the renderer. The slideshow risk scoring system evaluates generated scene plans in main/lib/slideshow_risk.py to ensure outputs feel like directed films rather than static slide decks with motion effects.

How the Six-Dimension Risk Scorer Works

The score_slideshow_risk() function inspects planned scenes along six quantitative dimensions that reliably indicate whether a video will resemble a static slideshow. Each dimension receives a score from 0 to 5, where lower values indicate stronger cinematic quality.

Repetition Analysis

The scorer detects over-use of identical scene types, descriptions, or shot sizes by counting the most common scene type and measuring description similarity. High frequency ratios increase the risk score. This logic resides in main/lib/slideshow_risk.py at lines 92-122.

Decorative Visuals Detection

Scenes lacking communicative roles—those with no information_role, narrative_role, or shot_intent—are flagged as purely decorative. The system computes the ratio of decorative scenes and scales it to a 0-5 score as implemented in lines 126-147.

Weak Motion Identification

Camera movement without explicit narrative purpose triggers this penalty. The scorer looks for camera_movement values that are not marked "static" while checking for the presence of shot_intent. Purposeless motion inflates the score according to the logic in lines 150-176.

Weak Shot Intent Measurement

This dimension measures the proportion of scenes lacking a defined shot_intent. Low coverage of explicit framing purpose yields a higher risk score, as detailed in lines 179-194.

Typography Overreliance Scoring

Excessive text-centric cards such as text_card, stat_card, or kpi_grid trigger penalties. The system calculates the fraction of text-only scenes and assigns a penalty when the ratio exceeds 20%, implemented in lines 198-216.

Unsupported Cinematic Claims

When the renderer family includes "cinematic", the scorer validates that the plan actually contains cinematic structure. It checks for hero moments, purposeful movement, and lighting presence. Missing elements add issues that raise the score in lines 221-255.

The Verdict Threshold System

After scoring all six dimensions, OpenMontage averages the results and assigns a final verdict that determines whether composition may proceed. The verdict logic in main/lib/slideshow_risk.py lines 73-80 defines four thresholds:

• Strong (average < 2.0) — Safe to compose immediately
• Acceptable (average < 3.0) — Minor tweaks allowed before composition
• Revise (average < 4.0) — Must improve the plan before composing
• Fail (average ≥ 4.0) — Pipeline aborts composition automatically

By forcing a fail verdict when the averaged risk exceeds 4.0, OpenMontage blocks any plan that would generate a slide-heavy, text-first video.

Pipeline Integration Points

The risk scorer operates at critical architectural boundaries to enforce quality gates:

• main/lib/scoring.py — General-purpose scoring utilities that invoke the slideshow risk scorer as part of the overall quality pipeline
• main/backlot/server.py — Entry point where the risk score is evaluated before committing to a composition job
• main/tests/tools/test_scoring.py — Unit tests verifying risk thresholds and ensuring slide-heavy inputs are rejected

Practical Implementation Examples

Scoring a Scene List Before Composition

Use the score_slideshow_risk() function to evaluate a scene plan programmatically:

from openmontage.lib.slideshow_risk import score_slideshow_risk

# Example minimal scene plan

scenes = [
    {"type": "image", "description": "Sunset over mountains",
     "shot_language": {"camera_movement": "pan"},
     "shot_intent": "establish"},
    {"type": "text_card", "description": "Key metrics",
     "shot_language": {"camera_movement": "static"},
     "information_role": "data"},
]

result = score_slideshow_risk(scenes, renderer_family="hyperframes_cinematic")
print(result["verdict"])          # → "revise", "acceptable", or "fail"

print(result["average"])          # numeric risk score (0-5)

print(result["dimensions"])       # detailed per-dimension breakdown

Guarding the Compose Step with Risk Validation

Integrate the scorer into your pipeline to prevent low-quality renders:

from openmontage.lib.slideshow_risk import score_slideshow_risk
from openmontage.lib.pipeline_loader import compose_video

def safe_compose(scenes, **kwargs):
    risk = score_slideshow_risk(scenes, renderer_family=kwargs.get("renderer_family"))
    if risk["verdict"] == "fail":
        raise RuntimeError(
            f"Slideshow risk too high (avg={risk['average']}). "
            "Refine scene plan before composing."
        )
    return compose_video(scenes, **kwargs)

# safe_compose aborts if the plan resembles an animated slide deck

Interpreting Dimension Scores for Debugging

Extract specific failure reasons when refining scene plans:

def explain_risk(risk):
    for dim, details in risk["dimensions"].items():
        print(f"{dim.title():<25} → Score {details['score']}: {details['reason']}")

explain_risk(result)

Running this on a slide-heavy draft typically yields high scores for Typography Overreliance and Repetition, triggering a fail verdict before rendering resources are wasted.

Summary

• OpenMontage evaluates every video plan using six quantitative dimensions that detect slideshow-like characteristics before composition begins
• The Repetition, Decorative Visuals, Weak Motion, Weak Shot Intent, Typography Overreliance, and Unsupported Cinematic Claims dimensions each score from 0 to 5
• Averaged scores ≥ 4.0 trigger an automatic fail verdict that aborts the composition pipeline in main/lib/slideshow_risk.py
• Integration at main/backlot/server.py and main/lib/scoring.py ensures cinematic quality gates are enforced before rendering
• Developers can call score_slideshow_risk() directly to validate scene plans and prevent "animated PowerPoint" outputs programmatically

Frequently Asked Questions

What is OpenMontage slideshow risk scoring?

OpenMontage slideshow risk scoring is an automated quality gate implemented in main/lib/slideshow_risk.py that evaluates video scene plans across six dimensions to detect static, slide-like characteristics before rendering begins. The system assigns numerical scores and verdicts that determine whether a plan may proceed to composition or requires revision.

How does the risk scoring system prevent PowerPoint-style videos?

The system prevents PowerPoint-style outputs by measuring typography overreliance, decorative visuals, and weak cinematic intent, then aborting the pipeline when the averaged score exceeds 4.0. This forces the addition of genuine visual storytelling, purposeful camera movement, and varied shot composition before final rendering.

What are the six dimensions of slideshow risk?

The six dimensions are Repetition (scene type frequency), Decorative Visuals (lack of communicative roles), Weak Motion (purposeless camera movement), Weak Shot Intent (undefined framing purpose), Typography Overreliance (excessive text cards), and Unsupported Cinematic Claims (missing cinematic structure when claimed). Each dimension contributes to a 0-5 score detailed in specific line ranges of main/lib/slideshow_risk.py.

What happens if a video plan fails the slideshow risk check?

When a plan receives a fail verdict (average ≥ 4.0), the pipeline aborts composition immediately, preventing the generation of slide-heavy videos. Developers must refine the scene plan to reduce risk scores—typically by adding shot_intent values, reducing text cards, or increasing shot size variety—before the system will allow rendering to proceed.

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