deterministic demo video

    1

    Automated, frame-accurate demo video rendering for headless simulations and game loops.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    deterministic demo video

    Example session with this skill installed

    I need to render a 10-second demo of my canvas-based pulse animation at 60fps and verify that the audio onsets match the visual pulses. Generate the config and show the render command.

    • Read your context and instructions
    • Compiled the deterministic demo video

    I have generated the configuration for your 10-second pulse animation. This configuration includes a timeline of events and the necessary verification probes to ensure audio-visual synchronization.

    Demo Configuration

    {
      "adapter": "./examples/pulse/adapter.mjs",
      "outDir": "./out/pulse-demo",
      "settings": {
        "fps": 60,
        "duration": 10.0,
        "width": 1280,
        "height": 720
      },
      "timeline": [
        { "time": 0.0, "type": "start" },
        { "time": 2.5, "type": "pulse", "params": { "frequency": 440 } },
        { "time": 5.0, "type": "pulse", "params": { "frequency": 880 } },
        { "time": 7.5, "type": "pulse", "params": { "frequency": 440 } }
      ],
      "expect": {
        "onsets": [2.5, 5.0, 7.5],
        "probes": [
          { "time": 2.5, "x": 640, "y": 360, "color": "#FF0000" }
        ]
      }
    }
    

    To render the video, run the following command in your terminal:

    node scripts/render.mjs --config pulse-config.json
    

    After rendering is complete, you can verify the output accuracy using:

    node scripts/verify.mjs --dir out/pulse-demo
    

    Next steps

    1. Verify your adapter.mjs implements the readFrame() and readAudio() methods correctly.
    2. Ensure ffmpeg is accessible in your current environment path.
    3. Check the manifest.json in the output directory for detailed render metadata.

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

    About this skill

    Screen recording is unreliable for automated pipelines because it drops frames, depends on window focus, and produces inconsistent results across runs. This skill replaces manual capture by driving your simulation or game loop directly, ensuring frame-accurate synchronization between audio and video via a two-pass deterministic rendering process.

    What it does

    • Deterministic rendering Ensures the same input timeline always produces a bit-identical or functionally identical output.
    • Frame-accurate sync Uses content-time emission logic to prevent audio drift over long durations.
    • Two-pass capture Captures audio and video in separate runs using a shared clock to maintain perfect alignment.
    • Automated verification Measures the final encoded MP4 for frame count, duration, and audio onset accuracy.
    • Headless support Works with WASM modules, Node.js scripts, Canvas animations, and game loops.

    How it works

    1. Implement the adapter Create a script following the adapter-api.md contract to bridge your simulation to the renderer.
    2. Configure the run Define the event timeline, duration, FPS, and verification probes in a config.json file.
    3. Execute the render Run the render.mjs script to generate the audio, silent video, and final muxed MP4.
    4. Run verification Use verify.mjs to validate the output against your expectations and catch regression errors.

    Frameworks & tools

    This skill requires Node.js 18+ and ffmpeg. It is designed to interface with simulations built in WASM, Canvas, or generic JavaScript game loops.

    Why this beats prompting it yourself

    Writing a two-pass renderer from scratch usually leads to tiny rounding errors that cause audio to drift out of sync after 30 seconds. This skill implements specific invariants for content-time frame emission and instance isolation that are difficult to get right through trial and error.

    Use cases

    • Generating product demo videos automatically during CI/CD release pipelines.
    • Producing high-quality, perfectly synced visualizers for WebAudio or generative music.
    • Creating reproducible bug reports for visual simulations or game mechanics.
    • Batch rendering marketing assets from a headless canvas engine.

    Known limitations

    Does not support live screen capture or manual human-in-the-loop interaction. Requires a programmatic adapter for the target simulation.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Game Development.

    Requires an adapter implementation for each project. Not for live screen capture. Needs ffmpeg installed on the system or via environment variables.

    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 buying a skill.

    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 to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    • Free with an Agensi account

    Software
    Node.jsFFmpeg

    Permissions

    Read Files
    Write Files
    Terminal / Shell
    Listed3 days ago

    What's inside

    Frequently Asked Questions

    Unlike screen recording which captures what happens in real-time, this skill drives your simulation frame-by-frame. This eliminates frame drops and 'jitter' caused by CPU spikes, ensuring a perfectly smooth 60fps (or higher) output even on low-end hardware.

    This skill is designed for programmatic environments and is compatible with any AI agent capable of executing Node.js scripts and interacting with the command line. It is ideal for agents tasked with automated video production or CI/CD pipeline management.

    You receive the core rendering engine (render.mjs), the automated verification suite (verify.mjs), documentation for the adapter API, and several template configurations to get your simulation connected quickly.

    Yes, the skill is designed for headless environments. It can run on remote servers or in Docker containers, provided Node.js and FFmpeg are installed, making it perfect for automated cloud rendering.

    The skill uses a 'content-time' shared clock to lock audio and video together. By rendering in two passes and then muxing the results, it prevents the millisecond-level rounding errors that typically cause audio to drift in long-form videos.

    You must provide a programmatic bridge (the adapter) that allows the renderer to tell your simulation exactly when to 'tick' forward. It cannot capture existing closed-source software that lacks an external control API.

    New in Game Development

    Free