How to Use OpenMontage: A Real, No-Fluff Setup Guide (2026)

OpenMontage blew up for a reason. It hit #1 on GitHub Trending and racked up almost 29k stars by calling itself "the world's first open-source, agentic video production system", basically, it turns your AI coding assistant into a full video studio. 12 pipelines, 52 tools, 500+ skill packs. If you've ever wished you could just describe a video and have an agent research, script, source, edit, and compose it, this is the project doing that in the open.

This guide is the honest version of how to use it: what it actually is, what you need installed, how you drive it, and what it costs. No hype, no bait.

What OpenMontage actually is

OpenMontage (github.com/calesthio/OpenMontage - you'll also see it written as "Open Montage") is open source under AGPL-3.0 and self-hosted only: there's no cloud version, no website you log into. You clone the repo, run it on your own machine, and operate it through an AI coding assistant.

Under the hood it's a clean architecture: declarative YAML pipeline definitions, a Python tool registry, markdown "skills" knowledge packs the agent reads, a scored provider-selection system that picks generators across seven dimensions, and budget/cost governance so jobs don't run away from you. Composition happens through Remotion (React) or HyperFrames (HTML/GSAP).

It's general-purpose video. Animated explainers, documentary montages, talking heads, avatar spokespeople, cinematic shorts, screen demos, dubs and localizations, podcast repurposing: it spans a lot more than short-form. That breadth is the whole point, and it's a genuinely impressive piece of open-source engineering.

What you need before you start

OpenMontage assumes some terminal comfort. Here's the real prerequisite list:

• Git: to clone the repo.
• Python 3.10+: the tool registry and pipeline engine run on it.
• Node.js 18+: Remotion composition is React-based.
• FFmpeg: the workhorse for encoding, trimming, and stitching.
• An AI coding assistant: Claude Code, Cursor, Copilot, Windsurf, or Codex. This is non-negotiable; the agent is the operator.

If you've never opened a terminal, this is a steeper climb than a hosted tool. That's not a knock on the project, it's just who it's built for. If that list already makes you wince, jump to the honest note near the end.

Installing it

Once your prerequisites are in place, install is short:

git clone https://github.com/calesthio/OpenMontage
cd OpenMontage
make setup

make setup wires up dependencies and gets the project ready. Then you open the project folder in your AI coding assistant (Claude Code or Cursor, for example) and that's where you actually work. You don't run a separate app; the agent reads the repo's skills and tools and acts inside it.

How you actually drive it

Here's the part people miss: you don't click buttons. You describe the video in natural language to your AI assistant, and the agent runs the pipeline end to end.

A typical flow the agent walks through:

1. Research: it gathers context on your topic.
2. Script: it drafts the narration and structure.
3. Scene plan: it breaks the script into shots.
4. Assets: it generates or fetches footage, images, voice, and music.
5. Edit: it assembles the timeline.
6. Compose: it renders the final video through Remotion or HyperFrames.

So a prompt like "make a 60-second explainer about how compost works, documentary style, calm narration" kicks off the whole chain. You review, give notes, and the agent re-runs the parts that need it. If you want a deeper look at how an AI assistant runs a video job like this, we wrote about the Claude Code video skill pattern separately.

Using OpenMontage with Claude Code, Cursor, or Codex

The assistant you pick changes the ergonomics more than the capability - the repo's skills are markdown files any coding agent can read, so the pipeline itself runs the same everywhere. What differs is how each tool handles permissions and long-running renders:

• Claude Code: open the OpenMontage folder and just describe the video. You'll be prompted to allow shell commands the first time the agent runs make, FFmpeg, or Node - approve those once and the pipeline flows. Renders can run several minutes; let the agent run them in the background rather than watching the terminal.
• Cursor: use Agent mode (not inline chat) so it can execute commands, not just propose them. Same permission pattern: the first render will ask for shell access.
• Codex: works as the operator too, and the flow is identical - point it at the project root so it discovers the skills directory, then describe the job. If a run stalls, ask the agent to re-run just the failed pipeline stage; you rarely need to restart from scratch.

One habit that helps in all three: keep one video per conversation. Agents keep pipeline state in context, and mixing two video jobs in one session is the most common way outputs get crossed.

Free local path vs. paid API keys

OpenMontage's pricing model is "bring your own keys." It plugs into providers like Kling, Runway, Google Veo, FLUX, ElevenLabs, and Suno, you supply the API keys and pay those vendors directly.

But there's a genuinely useful 100% free local path: Piper for text-to-speech, FFmpeg for processing, Remotion for composition, and free stock footage from Archive.org, NASA, Wikimedia, Pexels, and Pixabay. You can produce real video without paying any generator vendor, you just trade premium AI footage for stock and local synthesis.

On the paid side, the project cites example costs of roughly $0.02 to $1.33 per short video, depending on which generators you call. That's the cost of the API calls, not a subscription. OpenMontage itself is free.

Realistic expectations

Be clear-eyed about the trade-off. OpenMontage is powerful and free, but it expects you to manage Python, Node, FFmpeg, API keys, and an agent workflow. Renders can take iterations, and quality depends heavily on which providers you wire up. For a developer who wants to self-host and customize anything (swap providers, edit pipelines, add tools) it's a fantastic foundation.

A short, honest note

If you're a non-technical short-form creator (a TikTok Shop seller, an ad buyer, a faceless-account operator) and you mainly want to riff a winning short video into your own without cloning a repo or wiring API keys, the calculus is different. That's the focused, hosted lane. We laid out the comparison fairly in our OpenMontage alternative post: OpenMontage if you want to self-host and tinker; a hosted path if you want short-form riffs with zero setup.

That hosted path is Riffkit. You give it one source (a link, an upload, or a saved template) and it studies the formula (hook, pacing, emotional beats) and generates brand-new footage with your product woven in. It never re-uploads the source clip. Output is post-ready: voiceover, captions timed to the audio, a cover frame, and a caption with hashtags - generated natively in any of 9 languages (English, Spanish, Portuguese, Indonesian, German, French, Italian, Japanese, Mandarin). It's billed by the second of finished video (a few dollars) so you re-roll until it's right, with full commercial rights to what you make. And it also installs as an agent skill, so the same assistant running OpenMontage can run Riffkit.

Don't copy. Riff. Start riffing if short-form is your whole game, and go star OpenMontage if you want to build a studio from the ground up. Both are real tools doing real work.

Get the Riffkit skill

Riffkit runs as an agent skill: point your assistant at the live skill and let it set itself up:

Read https://riffkit.ai/SKILL.md and follow the instructions to set up Riffkit.

Then just ask in plain language: "riff this TikTok into a video for my product." The skill is open source at github.com/riffkit/skill and listed on ClawdHub. Prefer buttons? The same backend runs in your browser at riffkit.ai.