OpenMontage and what it gets right about agentic pipelines

A repo called OpenMontage crossed my desk this week — more than 18,000 stars, billed as "the first open-source, agentic video production system." The pitch: point an AI coding assistant — Claude Code, Cursor, Copilot, Codex — at the project, describe a video in plain language, and the agent handles the rest: research, scripting, asset generation, editing, and final render. The demos come with real numbers attached — a 60-second animated short for $1.33, a product ad for $0.69, anime sequences for $0.15 each.

The video is the part that gets attention. It is not the part that interested me. I want to talk about the architecture, because OpenMontage is one of the cleaner public examples of how you make an agent reliable when the task is creative and the output is non-deterministic. Those patterns generalize well past video.

The agent doesn't improvise

The first thing the project gets right is that it refuses to let the agent freestyle. Its own guide is blunt: do not improvise the production workflow; OpenMontage is pipeline-driven. Real work goes through declared pipelines, stage-director skills, and a tool registry the agent queries before it acts.

This is the inversion most "agent does X" demos miss. The naive design hands the model a goal and a pile of tools and hopes the reasoning chain holds for forty steps. It rarely does. OpenMontage instead treats every request as a pipeline-selection problem: the agent's first job is to pick the right pipeline, read its manifest, then read the stage skill, then call tools — in that order. The creative latitude lives inside a fixed skeleton. The model decides what goes in each slot; it does not get to invent the slots.

I have built production agents both ways. The constrained-pipeline version is the one that survives contact with real users.

The skeleton is fixed; the model fills the slots. The two emphasized stages — scored asset generation and the verification gate — are where most of the engineering lives.

Provider selection as a scored decision

The second thing worth stealing is how it chooses tools. OpenMontage can reach dozens of providers — FLUX and Imagen for images, Veo and Kling and Runway for motion, ElevenLabs and Piper and Google for voice, Suno for music — and any of them might be right for a given shot. Rather than hard-code a favorite or let the model pick on vibes, the system scores every provider selection across seven dimensions and writes an auditable decision log.

That last clause is the one that matters. When an agent makes a choice you cannot inspect, you cannot debug it, you cannot defend its cost, and you cannot improve it. An auditable log turns "the agent picked Veo" into "the agent picked Veo over Kling for these reasons at this price." In production, the gap between those two sentences is the gap between a system you operate and a system that operates you.

Verification around a non-deterministic core

This is the pattern I care about most. Generative output cannot be trusted on faith: a text-to-speech call can clip, a render can drop frames, subtitles can drift off the audio, a model can quietly deliver 40 seconds when you asked for 75. So before OpenMontage shows you anything, it runs a multi-point self-review — ffprobe validation, frame sampling, audio-level analysis, a delivery-promise check that the output matches the request, and a subtitle check.

That is deterministic verification wrapped around a non-deterministic core. The generation is probabilistic; the gate is not. You let the creative part be loose precisely because the checking part is strict. It is the same discipline I apply to LLM systems that emit structured artifacts: you do not ask the model "did you do it right?" — you measure the artifact against a spec it cannot talk its way past. OpenMontage just measures with ffprobe instead of a schema validator.

Degrade by capability, not by failure

Every key is optional. The agent reads its support envelope at runtime and plans inside it, so it never promises a tool it doesn't have.

The last choice is the capability envelope. Every API key is optional. With zero keys, make setup still produces a real video — Piper for offline narration, Archive.org and NASA and Wikimedia for open footage, Remotion for composition. Add free stock keys and Pexels and Unsplash come online. Add paid keys and the premium image and motion providers light up. Have a GPU and local video generation unlocks with no per-call cost at all.

The agent discovers what it can actually do at runtime by querying the registry's support envelope, then plans within it. It does not promise a Veo shot and fail when the key is missing; it plans for the tools that are present. That is graceful degradation as a first-class design property rather than an afterthought, and it is why "more keys, more tools" is an honest claim rather than a marketing one.

What I would take from it

Strip away the medium and OpenMontage is a reference implementation for a problem I see constantly: an agent producing an artifact a human will judge, where the work is creative but the stakes are real. Its answers — constrain the agent to a declared pipeline, make tool selection a scored and logged decision, gate the output with deterministic checks, and plan inside a discovered capability envelope — are the same four answers I would give for a document generator, a data pipeline, or a code agent.

That it produces a watchable 60-second film for the price of a coffee is the headline. That it does so behind a verification gate and an audit log is the reason it works. If you build agentic systems, the repo is worth an afternoon — not for the videos, for the scaffolding around them. It is AGPL-3.0 on GitHub.