Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Video Compose

    1

    One manifest in, one finished MP4 out: normalize and concat shots, place each voiceover line at its millisecond, burn subtitles with a fallback. Needs only ffmpeg and Python.

    Free

    Security scanned
    video-compose

    video-compose

    Example session with this skill installed

    I have three shot clips in shots/ (any resolution, mixed), two voiceover lines, and subs.srt. Compose them into one 9:16 MP4 at 24 fps, 32 seconds total, with the captions burned in. The second voiceover line starts at 5.5 s.

    • Read your context and instructions
    • Compiled the video-compose

    Summary

    Built final.mp4 from a manifest and verified the audio actually landed in the right windows — 8.00 s, 720×1280, 24 fps, H.264 + AAC, subtitles burned.

    The manifest it wrote

    {
      "out": "final.mp4",
      "total": 8,
      "fps": 24,
      "size": "720x1280",
      "shots": [{"file": "shots/s01.mp4"}, {"file": "shots/s02.mp4"}],
      "audio": [{"file": "vo0.wav", "delay_ms": 0}, {"file": "vo1.wav", "delay_ms": 3200}],
      "subtitles": "subs.srt"
    }
    

    The command

    python scripts/compose.py manifest.json
    
    OK final.mp4 58219B (total=8.0s, shots=2, voices=2, 720x1280@24fps)
    

    Verification (not just exit code 0)

    CheckCommandResult
    Durationffmpeg -i final.mp400:00:08.00 — matches total
    Streamsffmpeg -i final.mp4h264 720×1280 24 fps + aac 24 kHz mono
    Speech windowffmpeg -ss 0.5 -t 1.0 -i final.mp4 -af astats -f null -RMS −21.08 dB
    Gap windowffmpeg -ss 2.2 -t 0.8 …RMS −inf (silence)
    Second lineffmpeg -ss 3.4 -t 1.0 …RMS −21.08 dB
    Captionsframe grab at t=1.0 stext visible, above the bottom third

    What to change next

    • total is a hard cut: keep it ≥ the end of the last voiceover line, or the last sentence loses its tail.
    • Mixed clip sizes/fps are handled: every shot is re-encoded to one geometry before concat.
    • If you want the captions lower or larger, pass style in the manifest (FontSize, MarginV, Outline).
    • Burn-in failing (missing font, no libass) falls back to the same cut without subtitles instead of losing the render.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Most "AI video" tooling stops at generating clips. The last mile — putting clips, narration and captions together so the timing actually holds — is where pipelines break, and it is pure shell work.

    video-compose is that last mile as one deterministic step.

    Give it a manifest:

    {
      "out": "final.mp4",
      "total": 32,
      "fps": 24,
      "size": "720x1280",
      "shots":  [{"file": "s1.mp4"}, {"file": "s2.mp4"}],
      "audio":  [{"file": "vo0.wav", "delay_ms": 0}, {"file": "vo1.wav", "delay_ms": 5500}],
      "subtitles": "subs.srt"
    }
    

    Get one finished video:

    python scripts/compose.py manifest.json
    

    What it does for you

    • Normalizes every shot to one size/fps/pixel format before concat — mixed clip geometry is the classic cause of broken or drifting output.
    • Places each voiceover line at its own delay_ms with adelay + amix=normalize=0, so narration never pumps on top of itself.
    • Burns subtitles with libass; if the font or libass fails it retries the same cut without captions instead of failing the whole render.
    • Keeps captions out of the bottom third, where short-video apps draw their own UI.
    • Copies audio/SRT to ASCII names before they enter the filter graph, so spaces and non-ASCII paths stop breaking ffmpeg.
    • Writes -movflags +faststart, so the file plays before it fully downloads.

    Requirements: ffmpeg on PATH, Python 3.8+. No pip installs, no API keys, no model calls. Same inputs → same output size.

    Includes a verification recipe (ffprobe duration + astats per-window levels) so the agent proves the audio landed where the manifest said instead of trusting exit code 0.

    Requires FFmpeg on PATH. No support for transitions or visual effects. Subtitle rendering fails back to no-subtitle render if libass or fonts are missing.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 20 days ago

    • Free with an Agensi account

    Requires

    ffmpeg (with libx264 + libass)
    ffprobe
    Python 3.8+
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Environment Variables

    Reads shot clips, WAVs and an SRT; writes one MP4 plus a temporary build directory it cleans up. Calls ffmpeg as a local subprocess. Optional FFMPEG env var points at a specific binary. No network access.

    Listed20 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the complex FFmpeg commands needed to normalize shot geometry, sync multi-track audio to specific timestamps, and burn UI-safe subtitles into a final MP4 without manual coding errors.

    The skill requires Python 3.8+ and FFmpeg installed on your system path, specifically compiled with 'libass' for subtitles and 'libx264' for video encoding.

    Yes, the skill uses a manifest-driven approach that handles different source formats by re-encoding and normalizing all clips to a uniform frame rate and resolution using Lanczos scaling.

    You will receive the 'compose.py' script, documentation on the JSON manifest schema, and a set of verification commands to audit your rendered output.

    The skill is designed to work with any AI agent capable of generating structured JSON and executing Python scripts, effectively serving as a deterministic 'rendering engine' for the agent's creative output.

    No, this skill is focused on deterministic, high-performance stitching and normalization; it does not currently support cross-fades, wipes, or complex motion graphics.

    New in Image & Video