Vibeleaderboard
Index / tool
Visit github.com
Category
AI Agents
Rank
Pricing
Open Source
Type
TOOL
Use case
Design & Media
Interfaces
Agent Skill / Plugin
Date

About

Oil Motion is an AI agent skill that turns AI-generated video into scroll-, mouse-, drag-, touch-, or orientation-driven web animations by mapping user input to specific animation frames. It automates keyframe verification, frame cleanup, and asset compression (WebP atlas or green-screen MP4) so the resulting animation responds smoothly on both desktop and mobile.

What it does

Oil Motion is an instruction file that an AI coding agent follows to turn a short AI-generated video clip into a page element that reacts to input. The agent generates a handful of confirmed poses, has a video model fill in the motion between them, then strips dead frames, removes color-key backgrounds where needed, and packs the result into either a sprite sheet or a compressed clip. A companion script picks the delivery format and wires the frame position to whatever is driving it, a pointer, a swipe, a tilt of the device, or a running scroll position.

Why it's ranked here

The system earns attention for the hard gates baked into its pipeline rather than for the AI generation step itself, which is really just a wrapper around a third-party video model. Before batch production starts, a script hashes every approved pilot artifact and refuses to continue if a single byte changed. Adjacent video segments are checked with a similarity and error metric before they ship, not eyeballed. Delivery format, sprite sheet or compressed video, is chosen by a budget script rather than left to guesswork. MIT licensed, which keeps adoption low-friction.

What's good

The byte-level check before batch production is the standout piece: it hashes the exact first frame, last frame, contract file, and pilot clip that a human signed off on, and blocks any run that doesn't match those hashes exactly. The continuity check between video segments compares brightness, structure, and color statistics between the last frame of one clip and the first frame of the next, giving a numeric pass or fail instead of a guess. Credential handling stores generation-service keys through the operating system's own secure store and raises an error rather than silently writing them to a plain configuration file.

Tradeoffs

It only works inside an AI agent environment that can read its instruction file and run shell commands, so it isn't something a person launches directly the way they would a CLI tool or library. The generation step depends on a paid third-party video and image API, ZenMux or MiniMax by default, which is an ongoing external cost and dependency the repository itself doesn't control. Running it locally means installing Python, ffmpeg, and a handful of Python packages, plus a Node.js runtime just for the one page that stores API keys. The documentation is written primarily in Chinese, which will slow down teams that don't read it.

How to use it well

This fits teams already working inside an agent-based coding setup who want a scroll- or pointer-driven hero animation built from AI-generated footage without hand-tuning chroma key thresholds or writing a state machine for playback. It is overkill for a simple looping background video or a one-off social clip, and it doesn't replace a video editor for content that isn't going to respond to user input. Budget for the external generation service's cost and for a first pilot segment before committing to a full multi-segment sequence, since the pipeline is built to block cheaply rather than fail expensively later.

Technical notes+

The instruction file (SKILL.md) drives a nine-step pipeline that treats four YAML and JSON files as the only sources of truth for a shot's requirements, its production plan, its compiled timeline, and its chosen delivery route. production_gate.py implements the hard gate: it SHA-256-hashes the concept contract, first frame, last frame, pilot video, and page-evidence screenshot named in a Pilot approval record, refuses to run without a --decision pass argument, and separately verifies frame-to-frame continuity between output segments by computing SSIM and normalized mean absolute error against fixed thresholds (0.97 and 0.04). motion_pipeline.py implements chroma-key removal itself, pixel by pixel, with a hand-written color-distance and despill routine rather than delegating to ffmpeg's built-in colorkey filter, and compile_scroll_video.py builds a segment-based timeline (frame start, hold, end) and re-validates the color-key edges of the master clip before encoding. secure_credentials.py is a thin wrapper over the keyring library that selects a platform-specific OS backend (SecretService on Linux, Keychain on macOS, Credential Manager on Windows) and raises rather than writing a plaintext fallback if that backend is unavailable. Reference docs (references/runtime.md, references/prompting.md, references/concepts.md, references/motion-patterns.md) lay out the input-mapping rules, video-model prompt templates, and creative heuristics the agent is expected to follow; agents/openai.yaml exposes the same skill as an OpenAI-compatible agent tool; requirements.txt pins Pillow, numpy, and PyYAML alongside a separate credentials requirements file; and evals/evals.json defines eleven scripted prompts used to check the agent's own judgment against expected pipeline choices.

Observed

License
MIT
Interface
Agent skill (SKILL.md) with an OpenAI-compatible agent manifest, not a standalone CLI or library
Runtime dependencies
Python 3 with Pillow, NumPy, and PyYAML, plus system ffmpeg and ffprobe binaries
Credential storage
OS keyring backend (SecretService, Keychain, or Credential Manager); no plaintext fallback if unavailable
Additional platform requirement
Node.js 22.18 or newer for the local API-key configuration page
Documentation language
Primarily Chinese, including the README and skill instructions
Delivery formats produced
WebP sprite atlas, chroma-key MP4, or fully baked MP4, chosen automatically by a budget script

Read from README.md, SKILL.md, references/concepts.md, references/motion-patterns.md, scripts/oil_motion_config.py, scripts/motion_pipeline.py, scripts/compile_scroll_video.py, scripts/production_gate.py, scripts/secure_credentials.py, scripts/requirements.txt, evals/evals.json, references/runtime.md, references/prompting.md, LICENSE, agents/openai.yaml.

What it can do

  • Map user input (scroll, mouse, drag, touch, orientation) to specific animation frames

    AI-generated video and user interaction data → Interactive web animation

  • Verify keyframes in generated video sequences

    AI-generated video frames → Verified keyframes

  • Clean up animation frames

    Raw video frames → Cleaned frame set

  • Compress animation assets into a WebP atlas or green-screen MP4

    Processed video frames → Compressed WebP atlas or MP4 file

Tags

ai-agent-skillweb-animationai-video-generationinteractive-animationscroll-animationfrontend

Tech Stack

TypeScript

Media

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.