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

> OpenMontage risk scoring prevents animated PowerPoint outputs by evaluating video plans on key metrics. Learn how it ensures quality before composition begins.

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

---

**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`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/main/backlot/server.py)** — Entry point where the risk score is evaluated before committing to a composition job
- **[`main/tests/tools/test_scoring.py`](https://github.com/calesthio/OpenMontage/blob/main/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:

```python
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:

```python
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:

```python
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`](https://github.com/calesthio/OpenMontage/blob/main/main/lib/slideshow_risk.py)
- Integration at [`main/backlot/server.py`](https://github.com/calesthio/OpenMontage/blob/main/main/backlot/server.py) and [`main/lib/scoring.py`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/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`](https://github.com/calesthio/OpenMontage/blob/main/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.