Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Video Pipeline

    1

    Stills to captioned short video: push-in/pull-out motion per image, timed voiceover, burned subtitles, then a verified 9:16 MP4. Two ffmpeg scripts, no API keys, deterministic.

    Free

    Security scanned
    video-pipeline

    video-pipeline

    Example session with this skill installed

    I have two stills (1600x900 frames from an image model), two voiceover lines and an SRT. Turn each still into a 3-second camera move — first push in, then pull out — and cut them into one 8-second 9:16 video with the narration and captions in place. Then show me how to check it actually came out right.

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

    Summary

    Turned two 1600×900 stills into two 3-second camera moves and cut them into an 8.00 s 720×1280 MP4 with narration, burned captions, and a verification pass that proves the audio landed where the manifest said.

    What the agent ran

    python scripts/image2video.py --in scene-01.png --out shots/s01.mp4 --seconds 3 --dir in
    python scripts/image2video.py --in scene-01.png --out shots/s02.mp4 --seconds 3 --dir out
    python scripts/compose.py manifest.json
    
    OK shots/s01.mp4 5704B (3.00s@25fps, zoom in, 720x1280)
    OK shots/s02.mp4 5704B (3.00s@25fps, zoom out, 720x1280)
    OK final.mp4 58219B (total=8.0s, shots=2, voices=2, 720x1280@24fps)
    

    The manifest

    {
      "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"
    }
    

    Verification (the part most pipelines skip)

    CheckResult
    Container duration00:00:08.00 — equals total
    Streamsh264 720×1280 24 fps + aac mono
    Narration window 0.5–1.5 sRMS −21.08 dB
    Gap 2.2–3.0 sRMS −inf
    Narration window 3.4–4.4 sRMS −21.08 dB
    Captionsvisible in a frame grab at t=1.0 s, above the bottom third

    Notes for the buyer

    • Source aspect ratio never distorts: each still is scaled to cover the target box and center-cropped.
    • Rendering happens at 2× the target size before downsampling, which is why the push-in looks smooth rather than shimmery.
    • total is a hard cut — keep it at or past the end of the last voiceover line.
    • If libass or the chosen font is missing, the subtitle burn falls back to the same cut without captions instead of failing the render.
    • No TTS and no image generation: bring stills and audio from whatever model you already use.

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

    About this skill

    Video production workflows often break when audio drifts, aspect ratios stretch, or captions get obscured by platform UI. This skill provides a deterministic Python-based pipeline for turning static images and scripts into high-quality, captioned short videos. It uses ffmpeg to handle complex tasks like center-cropping, push/pull motion effects, and precise audio-visual synchronization without relying on heavy third-party libraries.

    What it does

    • Image-to-motion conversion applies push-in or pull-out zoom effects to static images to prevent visual stagnation.
    • Deterministic composition assembles multiple video clips, WAV audio files, and SRT subtitles into a single MP4.
    • Aspect ratio management uses cover and center-crop logic to ensure images never stretch regardless of output resolution.
    • Subtitle burning integrates captions directly into the video using libass with customizable positioning to avoid platform UI overlap.
    • Audio synchronization handles precise millisecond-based delays for voiceover lines to prevent narrative drift.
    • Quality verification uses ffprobe and astats to validate final durations and ensure audio energy exists in expected windows.

    How it works

    1. Generate shots by running image2video.py on your stills, specifying duration and zoom direction for each clip.
    2. Define timing in a manifest JSON file, mapping audio files to specific millisecond delays and listing the generated clips.
    3. Execute composition using compose.py to render the final video with burned-in subtitles and mixed audio.
    4. Validate output by checking file duration and RMS audio levels via ffmpeg commands to ensure a perfect cut.

    Frameworks & tools

    Python 3.8+ (no third-party packages required). Requires ffmpeg and ffprobe on the system path with libx264, libass, and adelay support.

    Why this beats prompting it yourself

    Writing raw ffmpeg filter strings for zooming, cropping, and audio mixing is error-prone and often leads to mismatched pixel formats or broken concats. This skill handles the complex math of center-cropping any aspect ratio and provides a reliable manifest-based workflow that works every time.

    Use cases

    • Social media shorts for automated 9:16 content with safe-zone captions.
    • Educational videos turning slide exports and TTS into narrated lessons.
    • Batch processing for episodic content where consistent timing and layout are required.
    • Marketing trailers from product photography and voiceover scripts.

    Known limitations

    Does not perform text-to-speech synthesis or image generation. Requires ffmpeg to be pre-installed on the host environment. Subtitle burn-in falls back to no-subtitle render if fonts are missing.

    Requires ffmpeg/ffprobe on PATH. No built-in TTS or image generation. manifest total must be manually calculated to avoid cutting audio. Subtitles require libass support.

    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 still images, WAVs and an SRT; writes shot clips, one MP4 and a temporary build directory it cleans up. Calls ffmpeg/ffprobe as local subprocesses. Optional FFMPEG env var. No network access.

    Listed20 days ago

    What's inside

    Frequently Asked Questions

    Stills to captioned short video: push-in/pull-out motion per image, timed voiceover, burned subtitles, then a verified 9:16 MP4. Two ffmpeg scripts, no API keys, deterministic.

    This skill uses the open SKILL.md standard. Use it through an MCP-compatible agent connected to Agensi, and check the compatibility information on this page for confirmed agents and required capabilities.

    Connect your AI agent to Agensi through MCP, then ask it to use video-pipeline on your task. Your agent loads the latest approved version each time. Paid skills require a purchase or active subscription. Skill files are not available for download; your licence does not allow you to save, copy or export any part of a skill.

    New in Image & Video