Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    video to skill

    1

    Converts video tutorials into structured, evidence-backed agent skills with local extraction and sandbox verification.

    Free

    Security scanned
    video to skill

    video to skill

    Example session with this skill installed

    I have a Vim tutorial at https://youtube.com/watch?v=... — watch it and turn it into a skill my agents can use.

    • Read your context and instructions
    • Compiled the video to

    Watched the tutorial and compiled it into an installable skill. Commands were read off the frames rather than the narration — that mattered twice.

    What the video taught

    GenreScreencast / CLI ⚠
    Steps extracted9 ⚠
    Badge✅ Verified by execution — 7 passed, 2 skipped by safety policy
    Installed to~/.agents/skills/vim-basics, symlinked into every detected agent

    Where pixels beat the transcript

    Narration saidThe frame readWhat shipped
    "QBang":q! at [t=0:54]:q!
    "the first extension called Vim"vscodevim.vim v1.18.9the exact extension id

    A step, as it ships

    - id: quit-discard-changes
      goal: Leave Vim without saving
      action: ":q!"
      evidence: "[t=0:54] references/frames/shot_007_key.jpg"
      confidence: high
    

    What the sandbox caught

    The paste step compiled to "+P — Vim's internal register, not the system clipboard. The sandboxed sub-agent ran it, the success criterion failed, the repair loop corrected it to "+p, and it re-verified against the real pasteboard. Two steps that would have been unsafe to execute were skipped by policy and say so on the badge — no silent green.

    Next steps

    1. /vim-basics is available in your agents' next session.
    2. Feed it a second Vim tutorial to fold in: agreements gain confidence, conflicts become cited variants.
    3. The .vts/vim-basics/ bundle was kept for that fold — delete it whenever you like.

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

    About this skill

    Video to Skill solves the problem of high-friction knowledge transfer from tutorials to automated agent workflows. If you find yourself pausing videos to copy commands or transcribe steps for your agents, this skill automates that entire pipeline — and the video never leaves your machine.

    What it does

    • Deterministic local extraction — a Rust binary (vts-extract) handles download, word-timestamped transcription, perceptual-hash shot detection, motion density and keyframe export. Only the frames the agent chooses to read enter the model's context.
    • Pixels outrank narration — a whisper model heard "some"; the frame read =SUM(B3:B10). Commands and identifiers are read off the frame character by character, never paraphrased from the transcript.
    • Every claim is cited — each step carries [t=MM:SS] and the frame it came from. Anything not visually verifiable is flagged low-confidence rather than guessed, and a non-procedural video (a talk, a vlog) returns a report explaining why no skill was generated instead of fabricated steps.
    • Verification is execution, not vibes — a fresh sub-agent that has never seen the video runs each step against its success criteria inside an OS sandbox (macOS Seatbelt, Windows LPAC/AppContainer, Linux bubblewrap) with no network, writes confined to a throwaway workspace, and credential stores unreadable. Where no sandbox exists the run is refused and the steps are badged honestly as unverified.
    • Skills that grow — fold in a second video of the same task: agreements gain dual provenance and a confidence bump, conflicts become cited variants rather than overwrites, and verification re-runs before reinstall.
    • Installs everywhere at once — one real copy in the universal ~/.agents/skills, with relative symlinks from every agent actually detected on the machine (Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, Amp).

    How it works

    1. Resolve the extractor — locate or fetch vts-extract, checksum-verified, then vts-extract check --fix prints exactly what else is missing and downloads nothing until you approve it.
    2. Extract the bundle: manifest, word-level transcript, shots and keyframes, aligned timeline.
    3. Read the timeline, then look closer — the agent reads the token-lean digest first and re-watches a range only when evidence demands it.
    4. Compile, verify, install — the analysis becomes a Procedure IR, the compiler validates it, the sandbox tests it, and installation prints its plan before writing anything.

    Safety

    Credentials visible on screen are never transcribed — the compiler refuses an IR carrying secret-shaped text in any field rather than sanitising it. Video text addressed to an AI ("ignore previous instructions") is flagged as suspected prompt injection and never encoded into steps. curl … | sh style steps are never emitted as runnable scripts. Nothing downloads or installs without showing you the plan first, and every artifact is version-pinned and sha256-verified.

    Why this beats prompting it yourself

    Generic prompts hallucinate commands and miss flags, versions and UI labels. This enforces pixels-over-narration, then proves the result by running it under an OS sandbox — neither of which a prompt can do.

    Known limitations

    Best on screen recordings and command-line tutorials; fast physical demonstrations lose detail between frames. Some GUI clicks cannot be checked by executing them, and are labeled unverified rather than hidden behind the badge. Non-procedural videos produce an analysis report, not a skill.

    Requires local binary execution. Supports x64/arm64. Procedural videos only for skill generation. Requires ffmpeg/yt-dlp (can auto-download).

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

    • Free with an Agensi account

    Requires

    GitHub CLI
    Python

    Permissions

    Network Access
    Listed14 days ago

    What's inside

    Frequently Asked Questions

    This skill converts video tutorials into executable, verified code and documentation for your agents, eliminating the manual effort and errors involved in transcribing commands and UI steps from video to text.

    Yes — macOS, Windows 10/11 and Linux. You do not need to install anything first: ffmpeg, yt-dlp and the speech models are fetched on first use, version-pinned and sha256-verified, and you see the full list before anything downloads. Tools already on your PATH are reused. No Homebrew, Python, account or API key.

    Any agent that reads the SKILL.md standard. Installation detects which agents are actually present and reaches all of them at once: Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and Amp. One real copy lives in the universal ~/.agents/skills and each other agent gets a relative symlink, so a later update reaches every agent in one step.

    No, the extraction process uses a local Rust binary (`vts-extract`) to ensure your video data, transcripts, and keyframes never leave your machine during the analysis phase.

    The skill includes a 'secure sandbox verification' step that tests extracted scripts in an isolated environment to confirm they are functional before you deploy them to your primary agents.

    The skill is free. The package is SKILL.md plus its reference docs. On first use it fetches a prebuilt vts-extract binary, static ffmpeg/ffprobe, yt-dlp and the whisper ggml-base and Silero VAD weights — each version-pinned and sha256-verified, each shown to you in a list before anything is written. Run `vts-extract check --print-downloads` to see every artifact it could ever fetch.

    New in Agents & Orchestration