Provides text-to-speech generation through ElevenLabs for AI voiceovers in media productions.
Provides video composition and rendering via FFmpeg to produce finalized MP4 deliverables.
Provides text-to-speech generation via Google TTS services in the production pipeline.
Provides OpenAI-powered text-to-speech generation for audio in creative productions.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@openmontage-mcp run the CreativeSpec in specs/product-launch.json"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
openmontage-mcp)AI-native creative production runtime with Model Context Protocol (MCP), declarative CreativeSpec, headless worker engine, and autonomous agent operating skills.
CreativeSpec → Headless Runtime → Provider Adapters → Telemetry & QA → Verified Deliverables
↑ │
└───────── Autonomous Agents via MCP (stdio JSON-RPC) ────────────────────┘
Attribution Notice:
This project builds upon and evolves the foundational concepts of OpenMontage created by Calesthio AI Labs. We acknowledge the foundational architecture pioneered by upstream OpenMontage: the modular tool registry, multi-provider abstraction, style playbooks, and the Backlot visual board.
openmontage-mcpwas engineered to solve a fundamental limitation of the prior platform: upstream OpenMontage was designed as an interactive, conversational, human-in-the-loop chat experience requiring manual step-by-step guidance.openmontage-mcppackages and extends the substrate into a reusable, headless, developer-ready creative production platform operable programmatically through the Model Context Protocol (MCP), a unified CLI, durable background workers, declarative specifications, and autonomous agent skills.
Related MCP server: agent-orchestrator
The table below details every major architectural addition and difference between upstream OpenMontage and OpenMontage with MCP, along with the architectural rationale (Why):
Area / Capability | Upstream OpenMontage ( | OpenMontage with MCP ( | Why This Change Was Made (Architectural Rationale) |
Protocol & Agent Interface | None. Relied on conversational chat prompts and ad-hoc script execution inside a chatbot turn loop. | Official Model Context Protocol (MCP) Server: FastMCP 2.x stdio interface exposing 15 typed tools and 2 resources. | External AI assistants (Claude Desktop, Cursor, Antigravity, custom agents) cannot interact reliably with raw Python scripts or multi-turn conversational prompts. MCP provides a standardized, typed, JSON-RPC interface operating across clean OS process boundaries. |
Specification Model | Conversational prompt iteration; stage-by-stage ad-hoc JSON generation across 6 stages. | Declarative | Interactive prompting does not scale to automated workflows or CI/CD pipelines. A declarative specification makes creative intent version-controllable, diffable, repeatable, and compilable without human chat overhead. |
Execution Engine | Human-guided stage-by-stage progression requiring manual reviews and approvals to advance. | Headless Production Runtime ( | Production systems, webhook handlers, and background tasks require headless, unattended execution where a valid spec produces a verified deliverable without conversational stalls. |
Worker Reliability & Resume | In-memory execution. Interrupted runs lost state and had to be restarted from stage 0. | Durable Worker ( | Media generation is expensive and rate-limited. If scene 4 fails or times out, the worker must preserve completed scenes 1-3 and resume cleanly from the exact failure point without re-paying or re-rendering. |
Multi-Variant Campaigns | Single video production at a time; manual re-prompting for different aspect ratios or cutdowns. | Campaign Orchestration ( | Real-world marketing requires coordinated asset bundles for YouTube (16:9), TikTok/Reels (9:16), and Instagram (1:1). Shared asset caching avoids redundant generation and provides unified campaign cost attribution. |
Agent Operating Layer | Unstructured system prompts mixed with Python implementation details. | 7 Runtime Skills & 4 Role-Scoped Agents: Strict 9-section schema; agents and skills never import Python code directly. | Separates agent reasoning from execution code. Agents operate the engine strictly via MCP tools and CLI commands, preventing hallucinated methods and avoiding AGPL license entanglement. |
Offline & Local Guarantees | Generation frequently failed or stalled if third-party API keys (ElevenLabs, fal, OpenAI) were missing. | 100% Zero-Key Offline Execution: Produces a verified, full-frame MP4 deliverable in under 6 seconds using bundled FFmpeg and Piper TTS. | Developers, contributors, and CI systems must be able to run, test, and verify the entire platform immediately upon installation without requiring external cloud accounts or credit cards. |
Developer CLI | Internal | Unified CLI ( | Provides a polished, single-binary feel for developers and automation scripts ( |
Packaging & Public API | Non-standard packaging; internal scripts imported from deep directories. | PEP 517/518 Packaging: | Allows clean installation via |
Licensing Boundary | Standard AGPL-3.0 without operational guidance on output or client isolation. | Explicit Operational Boundary Notice: Clear IPC isolation documentation; media outputs are explicitly confirmed user-owned. | Clarifies for commercial teams and developers that generated video deliverables are free of copyleft restrictions, and external tools communicating over MCP/CLI do not violate AGPL boundaries. |
OpenMontage with MCP is a headless creative-production runtime that transforms structured creative specifications into validated media production runs, with deterministic tooling, provider adapters, durable execution, CLI access, Model Context Protocol (MCP) integration, Skills, and role-scoped Agents.
OpenMontage with MCP is NOT:
- another prompt-to-video chat playground
- a single AI model API wrapper
- a SaaS dashboard or web UI
- a replacement for professional NLE editing software (Premiere / DaVinci)
OpenMontage with MCP IS:
- a headless media production engine
- a structured, schema-validated workflow runtime
- an agent-operable execution layer via MCP and Skills
- a programmable creative substrate for automated campaigns and video pipelinesOpenMontage with MCP enforces a strict, unidirectional dependency hierarchy:
graph TD
subgraph Interfaces["1. Agent and Developer Interfaces"]
A[Autonomous Agents] --> S[Runtime Skills]
S --> M[MCP Server - stdio]
D[Developers and CI] --> C[CLI - openmontage-mcp]
D --> P[Python API - openmontage]
end
subgraph Runtime["2. Production Runtime Engine"]
M --> R[Runtime Engine]
C --> R
P --> R
R --> Comp[CreativeSpec Compiler]
R --> Worker[Durable ProductionWorker]
R --> Camp[CampaignRunner]
end
subgraph Execution["3. Tooling and Media Providers"]
Worker --> PR[Provider Registry - 120 Providers]
PR --> TTS[TTS: ElevenLabs, Piper, Azure, Google, OpenAI]
PR --> VID[Video: Seedance, Kling, LTX-2, Wan, Sora, Veo]
PR --> IMG[Image: FLUX, Imagen, Midjourney, Recraft, SD]
PR --> MUS[Music: Lyria, ACE-Step, MusicGen, Library]
PR --> COMP[Composition: Remotion and FFmpeg]
end
subgraph QA["4. State and Quality Assurance"]
Worker --> CK[Checkpoints and State Store]
Worker --> QAEngine[Technical QA: ffprobe, Audio Normalization]
Worker --> BACK[Backlot State Observer]
endAgents and Skills never import Python modules: Agents interact with the runtime strictly through MCP tools and CLI commands.
Deterministic Composition: Video rendering is reproducible across FFmpeg and Remotion engines.
External Process Isolation: External IDEs and client applications communicate across standard OS process boundaries (stdio MCP IPC or subprocess CLI calls).
# Standard installation (runtime + CLI)
pip install openmontage-mcp
# With MCP server support (recommended for AI agents)
pip install "openmontage-mcp[mcp]"
# For full local GPU video generation
pip install "openmontage-mcp[gpu]"# Check CLI and version
openmontage-mcp --help
# Inspect available media providers on your machine
openmontage-mcp providersopenmontage-mcp validate examples/minimal_creative_spec.json✓ Valid CreativeSpec
version: 1.0
scenes: 1
duration: 3.0s
aspect: 16:9openmontage-mcp run examples/minimal_creative_spec.json✓ Production run COMPLETED
project: run_1a47cdd9cd56
output: projects/run_1a47cdd9cd56/renders/run_1a47cdd9cd56_master.mp4
duration: 5.7sYour rendered 1080p MP4 deliverable is ready under projects/.
A CreativeSpec is a self-contained, schema-validated JSON or YAML document declaring the entire production intent.
{
"version": "1.0",
"title": "Quantum Computing Explained",
"aspect_ratio": "16:9",
"target_duration": 15.0,
"style": {
"playbook": "clean-professional",
"tone": "educational",
"pacing": "steady"
},
"audio": {
"narration": {
"voice": "alloy",
"provider": "piper",
"rate": 1.0
},
"music": {
"mood": "ambient corporate",
"volume": 0.15
}
},
"scenes": [
{
"id": "scene_1",
"order": 1,
"duration": 5.0,
"narration": "Classical computers compute with bits that are either zero or one.",
"visual": {
"type": "motion_graphic",
"prompt": "Binary bits flipping cleanly on a dark slate background, minimalist typography",
"style_override": "clean-professional"
}
},
{
"id": "scene_2",
"order": 2,
"duration": 10.0,
"narration": "Quantum computers use qubits, which can exist as both zero and one simultaneously through superposition.",
"visual": {
"type": "still_image",
"prompt": "Futuristic glowing Bloch sphere showing quantum superposition, 3D render, dark background",
"motion": "slow_zoom_in"
}
}
]
}Validate against the official schema at schemas/creative_spec.schema.json.
OpenMontage with MCP exposes 15 typed tools and 2 resources to AI assistants over stdio JSON-RPC.
Add to your claude_desktop_config.json or agent configuration:
{
"mcpServers": {
"openmontage": {
"command": "openmontage-mcp",
"args": ["mcp"]
}
}
}Tool Name | Purpose | Key Inputs | Expected Output |
| Pre-flight validation |
| Validation status, scene count, estimated duration |
| Compile to canonical brief |
| Compiled brief, scene breakdown |
| Start background worker |
| Job ID, initial state, project dir |
| Resume interrupted run |
| Resumed state, remaining stages |
| Poll live progress |
| Progress %, current scene, completed assets |
| Validate campaign matrix |
| Variant validation, matrix breakdown |
| Execute multi-variant matrix |
| Variant job IDs, total cost attribution |
| Query campaign status |
| Per-variant progress, aggregated cost |
| Initialize workspace |
| Project directory, initialized marker |
| Query stage rail state |
| Completed stages, Backlot board summary |
| List assets and media |
| Artifact inventory, media file paths |
| Inspect capability matrix |
| Available providers and requirements |
| Query specific provider |
| Max resolution, latency, supported formats |
| List canonical artifacts |
| Available stage artifacts |
| Inspect stage artifact |
| Parsed canonical artifact JSON |
The package installs openmontage-mcp, aliased to openmontage and om-mcp:
Subcommand | Usage | Description |
|
| Validates a CreativeSpec or CampaignSpec without side effects |
|
| Executes a full production run headlessly |
|
| Resumes an interrupted run from its last completed checkpoint |
|
| Reports current state, deliverable paths, and errors |
|
| Triggers composition render on an existing project workspace |
|
| Orchestrates a multi-variant campaign run |
|
| Live table of available vs. unconfigured providers |
|
| Inspects artifacts, media files, and event logs |
|
| Launches the FastMCP stdio server for AI agents |
External Python applications import from openmontage:
from openmontage import (
load_creative_spec,
compile_creative_spec,
ProductionWorker,
CampaignRunner,
ProviderPolicy,
)
# 1. Load and validate
spec = load_creative_spec("examples/minimal_creative_spec.json")
# 2. Configure provider policy
policy = ProviderPolicy(
video_preference=["seedance", "kling", "offline"],
tts_preference=["elevenlabs", "piper"],
max_budget_usd=10.0,
allow_fallbacks=True,
)
# 3. Execute with durable worker
worker = ProductionWorker(
creative_spec=spec,
project_id="my_video_project",
policy=policy,
)
job = worker.execute()
print(f"State: {job.state}")
print(f"Deliverable: {job.output_video}")
print(f"Cost: ${job.cost_usd:.4f}")Produce multi-format asset bundles (e.g. YouTube 16:9 + TikTok 9:16 + Instagram 1:1) from one definition:
{
"campaign_id": "product_launch_2026",
"base_spec": "specs/base_launch.json",
"variants": [
{
"variant_id": "youtube_horizontal",
"aspect_ratio": "16:9",
"target_duration": 30.0
},
{
"variant_id": "reels_vertical",
"aspect_ratio": "9:16",
"target_duration": 15.0
},
{
"variant_id": "feed_square",
"aspect_ratio": "1:1",
"target_duration": 15.0
}
]
}Execute via CLI:
openmontage-mcp campaign examples/campaign_product_launch.jsonOpenMontage with MCP integrates 120 discovered provider adapters across all media modalities:
Video Generation: Seedance 2.0/2.5, Kling Direct/API, LTX-2.3, Wan 2.2, Sora, Google Veo, Hunyuan Cloud, ComfyUI
Text-to-Speech: ElevenLabs, Piper (offline), Azure Speech, Google Cloud TTS, OpenAI Voice, fish.audio, Doubao
Image Generation: FLUX.2/FLUX.1, Google Imagen 3, OpenAI GPT Image, Recraft, SDXL, ComfyUI
Music and Sound: ElevenLabs Music & SFX, Google Lyria 3, ACE-Step 1.5, MusicGen, Royalty-Free Library
Composition: Remotion (React motion graphics, spring physics) and FFmpeg (offline video stitching, Ken Burns)
Analysis: Faster-Whisper, Azure STT, OpenCV frame sampling, scene detection
Configure API keys in .env. Inspect active providers anytime with:
openmontage-mcp providersYou can develop, test, and render complete video productions with zero API keys:
Offline Narration: Bundled Piper neural TTS or ambient audio fallback.
Offline Composition: Local FFmpeg engine (motion graphics, Ken Burns, audio mixing).
Offline Speed: 1080p MP4 deliverable generated in under 6 seconds on standard CPU.
OpenMontage with MCP maintains a comprehensive regression suite:
220 passed, 2 skipped, 0 failedRun test suites:
# Run contract tests (CLI, MCP, Skills, Agents)
pytest tests/cli tests/mcp tests/skills tests/agents
# Run runtime regression tests
pytest tests/runtime
# Run provider contract tests
pytest tests/providersOpenMontage with MCP is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-only).
Your Media Deliverables Are Yours: All video files (MP4s), audio tracks, images, and subtitles created by OpenMontage belong entirely to the operator and are not subject to AGPL copyleft restrictions.
External IPC / Process Boundary: Applications communicating with OpenMontage strictly over standard input/output (the MCP stdio protocol) or via CLI subprocesses interact across an external process boundary and do not trigger copyleft requirements on external client code.
Direct Linking: Linking or modifying the internal Python source code (openmontage, lib, tools) in a networked service subjects derivative works to AGPL-3.0 source disclosure.
This server cannot be deployed
Build and run visual creative-production workflows from your AI agent.
Creative-intelligence MCP for campaign strategy, ad builds, QA, and reporting.
Brand-safe MCP for AI agents to create editable, on-brand graphics and automate variants.
Build, run, schedule, and publish AI video pipelines to YouTube and TikTok from any MCP client.
