making videos with kineto

    1

    Generate deterministic MP4 and animated WebP videos from code, terminal sessions, and data using Kineto.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    making videos with kineto

    Example session with this skill installed

    Create an animated bar chart video showing our monthly user growth: Jan 100, Feb 150, Mar 300. Export it as an MP4.

    • Read your context and instructions
    • Compiled the making videos

    I have generated the scene document for your user growth chart, validated the schema, and rendered the final video. I checked the frames at the 50% and 90% marks to ensure the bars and labels transitioned correctly without overlapping.

    Video Asset Details

    MetricValue
    Filenameuser_growth_chart.mp4
    Dimensions1920x1080
    Duration3 seconds (2,116,800,000 ticks)
    FormatMP4 (H.264)
    Scene Count1 (Animated Bar Chart)
    {
      "width": 1920,
      "height": 1080,
      "scenes": [
        {
          "shot": "metric",
          "duration": 2116800000,
          "elements": [
            {
              "type": "chart",
              "kind": "bar",
              "data": [
                {"label": "Jan", "value": 100},
                {"label": "Feb", "value": 150},
                {"label": "Mar", "value": 300}
              ],
              "reveal": {"kind": "drawOn", "at": 300}
            }
          ]
        }
      ]
    }
    

    Next steps

    1. Run open user_growth_chart.mp4 to view the final render.
    2. If you want to change the colors, I can apply a gradient fill to the bars.
    3. I can also add a "Statement" scene at the end to highlight the 3x growth.

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

    About this skill

    Generating high-quality video content for technical documentation or social media usually requires manual screen recording or complex motion graphics software. This skill solves that by allowing you to generate deterministic MP4 and WebP videos directly from code, terminal sessions, or data.

    What it does

    • Code-to-video conversion transforms text-led points, code snippets, or quotes into animated scene documents.
    • Data visualization builds animated line, area, or bar charts from raw numbers.
    • Terminal rendering converts .cast terminal recordings into high-fidelity video files.
    • Automated changelogs generates release videos by analyzing version ranges.
    • Storyboarding turns sequences of screenshots into cohesive video presentations.
    • Visual validation provides tools to check document schema and preview specific timestamps before final rendering.

    How it works

    1. Initialize the scene by calling a specific builder tool like build_scenes or build_chart based on your input data.
    2. Refine the generated document by adding specific motion reveals like fadeUp, popIn, or drawOn for SVG paths.
    3. Validate the work using check_document to catch schema errors and preview_document to inspect frame layouts.
    4. Compile the final asset using render_document to produce the MP4 or WebP file.

    Frameworks & tools

    This skill utilizes the kineto MCP server and requires ffmpeg on the system PATH for final video encoding.

    Why this beats prompting it yourself

    Writing the JSON scene documents manually is prone to schema errors and timing mistakes. This skill handles the specific tick-based duration math, SVG path construction, and layout logic required to produce a professional, non-overlapping visual output.

    Use cases

    • Generate animated terminal walkthroughs for GitHub READMEs.
    • Create data-driven video reports for stakeholders.
    • Produce social media "teaser" clips for new software releases.
    • Build animated architecture diagrams for technical documentation.

    Known limitations

    Requires a local installation of the Kineto MCP server and ffmpeg. Large WebP files can be significantly larger than MP4 equivalents.

    Requires local installation of Kineto MCP server and ffmpeg. WebP output is resource-intensive for long sequences. Layouts require sampled frame previews to ensure no text overlap.

    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 19 days ago

    • Free with an Agensi account

    Requires

    Kineto MCP
    Node.js

    Permissions

    Network Access
    Listed19 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the creation of high-fidelity MP4 and WebP videos from technical inputs like terminal recordings (.cast), code snippets, and raw data, eliminating the need for manual screen recording or complex motion graphics software.

    The skill requires the Kineto MCP server and ffmpeg installed on your system PATH to handle the final video encoding and rendering process.

    Absolutely. The skill includes dedicated tools to generate animated bar, line, and area charts directly from your raw datasets, making it ideal for automated data reporting.

    The skill includes a 'preview_document' function that allows you to inspect specific timestamps and frame layouts to ensure everything looks perfect before you commit to the final render.

    While MP4 is the standard for high-quality video, the skill also supports animated WebP generation, which is perfect for lightweight, looping technical animations in GitHub READMEs or documentation.

    Manual JSON scene creation is highly susceptible to timing and schema errors; this skill automates the complex tick-based duration math and SVG path logic required for professional results.

    New in Workflow Automation