# Templated vs Atelier Composition Authoring Modes in OpenMontage

> Explore OpenMontage's templated vs atelier composition authoring modes. Understand how `composition_mode` dictates assembly from stock scene types or bespoke HTML/React creation for flexible development.

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

---

**OpenMontage distinguishes between templated composition (assembling pre-built stock scene-types from a registry) and atelier composition (hand-authoring bespoke React or HTML compositions), with the choice governed by the `composition_mode` field in the proposal packet and enforced through distinct governance rules.**

OpenMontage separates *how* a video composition is built from *which runtime* renders it, creating an orthogonal architecture that supports both rapid stock assembly and bespoke creative work. The `composition_mode` field in the production proposal—defined in [`schemas/artifacts/proposal_packet.schema.json`](https://github.com/calesthio/OpenMontage/blob/main/schemas/artifacts/proposal_packet.schema.json)—determines whether the pipeline assembles pre-registered cut types or executes hand-authored code from the `projects/` directory. Understanding these two composition authoring modes is essential for optimizing token usage, meeting brand requirements, and passing automated governance checks.

## The Orthogonal Architecture of Composition Mode

OpenMontage treats the authoring approach as independent from the rendering engine. While `render_runtime` selects between Remotion, HyperFrames, or FFmpeg, `composition_mode` controls whether the system pulls from the stock component registry or executes custom-authored scripts. This separation ensures that templated efficiency and atelier originality remain distinct paths with clear governance boundaries.

## Templated Composition: Registry-Based Assembly

Templated mode leverages the **Remotion cut-type registry** to assemble videos from reusable stock components. The agent selects predefined `cut.type` entries—such as `text_card`, `stat_card`, or `bar_chart`—and populates their templated inputs (prompt, seed, dimensions) without writing scene-specific code.

The `video_compose` tool in [`tools/video/video_compose.py`](https://github.com/calesthio/OpenMontage/blob/main/tools/video/video_compose.py) routes templated requests through the stock `Explainer` or `CinematicRenderer` components. This approach follows the design philosophy: *"Reuse engine knowledge, never creative components."* The registry provides structural **mechanics**—how transitions and animations work—but offers no visual originality.

### When to Use Templated Mode

- **Batch output**: Generating many similar clips with consistent structure
- **Localization variants**: Translating content while maintaining identical motion design
- **Rapid prototyping**: Internal proof-of-concepts where speed outweighs visual uniqueness

### Governance Requirements

Templated productions must present the choice as a proposal decision with `category: "composition_mode"` and `options_considered: ["templated", "atelier"]`. The reviewer—guided by [`skills/meta/reviewer.md`](https://github.com/calesthio/OpenMontage/blob/main/skills/meta/reviewer.md)—verifies that only stock catalog components were used and flags any unnecessary hand-authored code that slipped into the pipeline.

## Atelier Composition: Bespoke Authoring

Atelier mode bypasses the stock registry entirely, requiring agents to hand-author every pixel. The agent runs `python scripts/scaffold_atelier_project.py <slug>` to generate a minimal scaffold under `projects/<slug>/`, including a placeholder [`Composition.tsx`](https://github.com/calesthio/OpenMontage/blob/main/Composition.tsx) (for Remotion) or [`index.html`](https://github.com/calesthio/OpenMontage/blob/main/index.html) (for HyperFrames) and an [`art-direction.md`](https://github.com/calesthio/OpenMontage/blob/main/art-direction.md) file. The scaffold intentionally starts as a black screen to force explicit creative decisions.

According to [`skills/meta/bespoke-composition.md`](https://github.com/calesthio/OpenMontage/blob/main/skills/meta/bespoke-composition.md), atelier work follows the principle: *"Hand-author every pixel."* The agent must define fresh art direction, visual language, and motion principles before coding. The stock catalog is **off-limits**—frozen looks that would re-introduce sameness are prohibited.

### Distinctness Review and Governance

Atelier productions undergo a strict **distinctness review** documented in [`AGENT_GUIDE.md`](https://github.com/calesthio/OpenMontage/blob/main/AGENT_GUIDE.md). The reviewer asks: *"Could this be any other product's video?"* If any stock component is imported, the gate fails. For hero work (marketing launches, brand pieces), atelier is the default; an explicit reason must be logged if templated is chosen instead.

The proposal decision log must still include `options_considered: ["templated", "atelier"]` to demonstrate deliberate choice, even when atelier is the obvious path for high-stakes deliverables.

## Runtime-Specific Behaviors

The interaction between `composition_mode` and `render_runtime` determines which functions execute the final render.

### Remotion Runtime

When `render_runtime` is `"remotion"`, the distinction is explicit:

- **Templated**: `composition_mode: "templated"` routes to the stock cut-type registry assembly
- **Atelier**: `composition_mode: "atelier"` triggers `_render_via_atelier`, bypassing the registry to execute the bespoke [`Composition.tsx`](https://github.com/calesthio/OpenMontage/blob/main/Composition.tsx)

### HyperFrames Runtime

HyperFrames inherently requires hand-authored compositions. When `render_runtime` is `"hyperframes"`, atelier is effectively the default architecture, though the `composition_mode: "atelier"` value must still be explicitly logged in the proposal packet for governance auditability. The system ignores templated requests in this runtime context.

## Token Economics and Performance Characteristics

**Templated mode** minimizes token consumption and iteration cycles by reusing pre-built motion mechanics. Agents populate JSON configurations rather than authoring new code, resulting in faster turnarounds and lower computational costs.

**Atelier mode** demands higher token investment. Each bespoke scene requires fresh design work, motion-principle documentation, and manual coding, increasing both agent iteration time and rendering complexity. This cost is justified when visual distinctiveness is a project requirement.

## Practical Implementation Examples

### Declaring the Authoring Mode in a Proposal Packet

```json
{
  "production_plan": {
    "render_runtime": "remotion",
    "composition_mode": "atelier"
  },
  "decision_log": [
    {
      "category": "composition_mode",
      "options_considered": ["templated", "atelier"],
      "selected": "atelier",
      "reason": "Hero launch video – needs a unique visual language."
    }
  ]
}

```

### Scaffolding an Atelier Project

```bash
python scripts/scaffold_atelier_project.py phantom-reach-explainer

```

This creates `projects/phantom-reach-explainer/` with a placeholder [`Composition.tsx`](https://github.com/calesthio/OpenMontage/blob/main/Composition.tsx) and [`art-direction.md`](https://github.com/calesthio/OpenMontage/blob/main/art-direction.md). The scaffold is intentionally minimal to ensure the agent replaces it with real content before review.

### Rendering a Templated Composition

```python
edit_decisions = {
    "render_runtime": "remotion",
    "composition_mode": "templated",
    "templated": {
        "cut_type": "text_card",
        "prompt": "Explain quantum entanglement in 30 seconds.",
        "seed": 42,
        "width": 1280,
        "height": 720,
        "duration": 90
    }
}

```

`video_compose` reads the `templated` block, selects the matching `cut.type`, and builds the final video without hand-authored code.

### Rendering an Atelier Composition with HyperFrames

```python
edit_decisions = {
    "render_runtime": "hyperframes",
    "composition_mode": "atelier",
    "bespoke": {
        "workspace_path": "projects/launch-reveal",
        "public_dir": "projects/launch-reveal/public",
        "art_direction": "projects/launch-reveal/art-direction.md",
        "scale": 0.5,
        "crf": 18,
        "concurrency": 8
    }
}

```

HyperFrames treats every composition as hand-authored, requiring the `bespoke` configuration object to locate the manually created project files.

## Summary

- **Templated mode** assembles videos from the Remotion cut-type registry (`text_card`, `stat_card`, etc.) via `video_compose`, offering low token usage and rapid iteration for batch work
- **Atelier mode** requires running [`scaffold_atelier_project.py`](https://github.com/calesthio/OpenMontage/blob/main/scaffold_atelier_project.py) to create bespoke React or HTML compositions under `projects/<slug>/`, enforced by the distinctness review in [`reviewer.md`](https://github.com/calesthio/OpenMontage/blob/main/reviewer.md)
- Both modes require explicit proposal decisions with `category: "composition_mode"` and both options listed in `options_considered`, as mandated by [`AGENT_GUIDE.md`](https://github.com/calesthio/OpenMontage/blob/main/AGENT_GUIDE.md)
- **Remotion** supports both modes explicitly, routing templated work through the stock registry and atelier work through `_render_via_atelier`
- **HyperFrames** implicitly requires atelier mode but still requires the `composition_mode: "atelier"` value in the proposal packet for auditability
- Hero marketing work defaults to atelier mode; choosing templated for these high-visibility projects requires explicit justification in the decision log

## Frequently Asked Questions

### What triggers the distinctness review in atelier mode?

The distinctness review is automatically enforced whenever `composition_mode: "atelier"` is declared in the proposal packet. According to [`skills/meta/reviewer.md`](https://github.com/calesthio/OpenMontage/blob/main/skills/meta/reviewer.md), the reviewer checks whether the composition could belong to any other product by verifying that no stock `cut.type` components from the registry were imported into the bespoke [`Composition.tsx`](https://github.com/calesthio/OpenMontage/blob/main/Composition.tsx) or [`index.html`](https://github.com/calesthio/OpenMontage/blob/main/index.html) files. If standard registry components are detected, the review gate fails.

### Can I use HyperFrames with templated composition mode?

No. HyperFrames inherently requires hand-authored compositions and does not support the stock cut-type registry used in templated mode. While you must still set `composition_mode: "atelier"` in the proposal packet for governance consistency, HyperFrames effectively defaults to atelier behavior regardless of the setting, as documented in [`AGENT_GUIDE.md`](https://github.com/calesthio/OpenMontage/blob/main/AGENT_GUIDE.md).

### How do I switch from templated to atelier mode mid-project?

You must update the `composition_mode` field in your proposal packet and append a new entry to the `decision_log` explaining the change. If rendering has already begun, you need to run `python scripts/scaffold_atelier_project.py <slug>` to generate the required `projects/<slug>/` directory structure, then migrate any custom content from the templated configuration into the new [`Composition.tsx`](https://github.com/calesthio/OpenMontage/blob/main/Composition.tsx) or HTML files before invoking `video_compose` with the updated mode setting.

### Why does atelier mode cost more in tokens than templated mode?

Atelier mode requires the agent to author fresh code for every scene, including defining motion principles, art direction, and component logic in files like [`art-direction.md`](https://github.com/calesthio/OpenMontage/blob/main/art-direction.md) and [`Composition.tsx`](https://github.com/calesthio/OpenMontage/blob/main/Composition.tsx). Templated mode simply populates existing JSON schemas with prompts and seeds, leveraging pre-built `Explainer` or `CinematicRenderer` components. This difference in creative labor—hand-authoring versus configuration—directly impacts token consumption and iteration time.