Owlie Studio

AI-powered video editor for VS Code — you direct, it edits, and nothing is ever lost.

Owlie Studio flips video editing on its head: instead of doing the work by hand, you tell an AI assistant what you want — trim this, add captions, reorder these scenes — and it makes the edits for you. You stay in control: review each change and keep it, undo it, or try a different version to explore an idea. The AI does the hands-on work; you decide what makes the final cut. It runs on your own AI subscription, so you bring the assistant you already use.

Watch on YouTube

New to Owlie Studio? Watch the walkthroughs, tips, and release demos on our channel — click the logo to open it on YouTube.

▶️ Watch Owlie Studio on YouTube »

Key Features

Plain-text timeline as the single source of truth

Your project is an OpenTimelineIO (OTIO) JSON file on disk — the SMPTE/Pixar open exchange format — not a vendor-locked binary (.prproj, .fcpbundle, .drp). It can be diffed, merged, branched, and searched with ordinary git and your editor. Unknown fields (agent-authored provenance, third-party effects, future schema extensions) are preserved byte-exact across edits, so the editor UI and your coding agent can both write the same document without clobbering each other. Optional JSONC comments are supported with a byte-identical strict-JSON round-trip for interop.

Agent-first, bring-your-own-model

Drive edits with any MCP-aware coding agent — Claude Code, Cursor, Copilot agent mode, Aider, Continue, Windsurf, Codex — operating on the timeline via filesystem read-and-edit primitives. Because prompts and completions run under your own subscription and never traverse our servers, you get privacy by construction and same-day frontier-model upgrades with no extension release required.

Deterministic MCP tool surface (no LLM arithmetic)

Frame-accurate work is handled by deterministic tools, not token generation — eliminating the latency, off-by-one errors, and non-reproducibility of asking an LLM to do timecode math. The server exposes compile_ffmpeg_argv, validate_otio, detect_filler_words, generate_srt, and media_metadata, plus client-side prompt templates (color_grade_intent, suggest_cuts). The LLM handles intent and style; the tools handle the bit-precise math.

Browse the cloud MCP tools — and sign in for a higher rate limit

The sidebar's MCP section opens a browsable reference for the hosted Owlie Studio MCP tools (validate_otio, compile_ffmpeg_argv, detect_filler_words, generate_srt, media_metadata) and prompt templates (color_grade_intent, suggest_cuts) — its icon turns green when your session token is valid, red when it's expired, and stays neutral when anonymous. Signing in to Owlie Says is entirely optional: everything works anonymously at 60 requests/min, and a one-click sign-in lifts that to 600/min. Auth is purely a rate-limit lane — no prompts or media ever route through our servers.

Local AI inference at electricity-only cost

Speech-to-text runs locally via a cached Whisper.cpp model by default, so per-edit inference is host electricity rather than per-token cloud charges. The Audio Transcript panel lets you pick your engine — Whisper (local) or NVIDIA (cloud) ASR — with a progress bar, an install check, and a one-click model download; the NVIDIA path uses an API key you store securely (OS SecretStorage) from the Accounts section. Per-word transcript timestamps anchor frame-precise cuts ("cut every 'um'", "split when the speaker says X") with the second-to-frame conversion done deterministically on the server. Beyond speech-to-text, a local background remover (rembg) already runs the same electricity-only way, and the pipeline is designed to extend to future local models — image generation, segmentation, frame interpolation, lip-sync, vision — as they ship.

Incremental render compilation

Timeline rendering works like a modern build system: each clip is a translation unit whose rendered segment is cached on disk by a content hash of its inputs (source content key, source range, encoder settings). An edit re-renders only the clips that actually changed, and the preview is assembled by stream-copy concatenation — bounding render cost to the changed portion of the timeline instead of its total length, for sub-second iteration.

Vertical, square, and 4K output — not just 16:9

A format picker in the transport bar renders to the shapes people actually publish: 16:9 · 1080p (default), 9:16 · 1080p for Shorts / Reels / TikTok, 1:1 · 1080p for square feeds, and 16:9 · 4K — plus a 16:9 · 720p draft tier for fast checks. Each non-landscape preset offers a fit mode — fill scales up and center-crops to reframe landscape footage with no bars, fit letterboxes to keep the whole frame. The full render now defaults to 1080p rather than 720p. Under the hood this is a fit: contain | cover axis on the render encoder; omitting it is byte-identical to prior output, so existing projects render unchanged.

Export a real upload master

The in-panel Render writes out.mp4 with MP3 audio — chosen only so VS Code's WebView (which ships without an AAC decoder) can play the preview with sound. For a deliverable, Owlie Studio: Export Video (upload master)… — or right-click any .otio in the Explorer — renders export.mp4 in your chosen format with a standards-compliant AAC track and a higher-quality encode (crf 20), then offers to Publish to YouTube with the file prefilled. One audio: mp3 | aac encoder axis, so the preview stays playable and the export is upload-grade.

Photos & screenshots as clips

Drop a still image (.jpg / .png / .webp / .bmp / .tiff) on the timeline and it renders as a real video segment for its full duration — the compiler loops the frame at 30 fps with a silent audio track — instead of a single frozen frame. Stills honor every output format, including the 9:16 / 1:1 crops, so a screenshot becomes a proper Short. Inserting a still gives it a 5-second default; images import into media/images/.

Per-clip finishing — titles, color grade & audio fades

Enrich a cut in two ways: right-click any clip → Edit Effects… for a form with live sliders, or let your coding agent write the same metadata.owlie_vibes.* keys directly. Either way you get:

• Text titles / captions — text_overlays burns drawtext titles onto a clip (position, font size, color, a readability box, and a show/hide time window), rendered with a system font (override via font_file or the OWLIE_FONT env var).
• Color grade — color_grade (brightness / contrast / saturation) applies an ffmpeg eq to just that clip.
• Per-clip audio — volume plus fade_in / fade_out (seconds) for clean transitions instead of the old all-or-nothing mute.
• Ken Burns pan / zoom — ken_burns adds a slow zoom + drift over a clip (from/to zoom and a pan direction), turning a static photo into motion — pairs with the stills support.
• Transitions — transition_in (black_fade / white_flash / blur_dissolve / zoom_punch), paired with duration_frames, crossfades into a clip (zoom_punch is a per-clip punch-zoom, not a crossfade); a real Transition.1 node renders identically, including on single-track timelines.

Run Owlie Studio: Generate Agent Map to (re)write AGENTS.md / CLAUDE.md / GEMINI.md — the drop-in briefing that teaches Claude Code, Cursor, Copilot, or any MCP-aware agent your timeline layout and the full metadata.owlie_vibes.* effect reference.

Fast media handling

A composite content-addressed cache key — SHA-256(size ‖ head_1MB ‖ tail_1MB ‖ mtime) — produces a stable key for any media file in under 50 ms regardless of size, keeping import gestures interactive on multi-gigabyte files. Waveform peaks for any video container are produced by streaming FFmpeg's WAV output directly into BBC audiowaveform with no intermediate files. Preview-proxy encoding uses GPU acceleration (h264_nvenc) with an automatic, session-latched software fallback (libx264) — no configuration required. (Final timeline exports encode with libx264.)

Local media tools — background removal, convert, resize, compress, grab

A batch of one-shot media utilities in the sidebar's Tools section. Each runs locally through @owlie-studio/core (a single ffmpeg or Python call), writes a new file next to the original — never overwriting your source — and imports the result into the Media Library. Each picks a non-clobbering output name, and all but the near-instant grab-frame are cancellable.

• Remove Background Color — key a solid / green-screen color out of a still via ffmpeg colorkey → a transparent PNG. Pick the color (green / blue / white / black / magenta / custom hex) and a tolerance. Best for flat backgrounds.
• Remove Background (AI) — cut the subject out of any photo via the rembg Python sidecar → a transparent PNG. Needs pip install rembg; the first run downloads a ~170 MB model.
• Convert Image Format — re-encode an image to PNG / JPG / WebP.
• Resize & Reframe — scale + reframe an image to 16:9 / 9:16 / 1:1 / custom, with fill (scale-up + center-crop, no bars) or fit (letterbox) — mirroring the render format picker.
• Compress / Shrink — reduce file size: images re-encode with a quality knob (PNG shrinks by converting to WebP); videos re-encode at a higher CRF via the Convert-to-MP4 path.
• Grab Frame → Still — save a full-resolution frame from a video at a given timestamp as PNG.

BGM Library — royalty-free background music, one click away

Tools → BGM Library browses a catalogue of royalty-free background-music tracks and downloads the ones you pick straight into media/bgm/ (via yt-dlp), where they show up under the Media Library's dedicated BGM category — ready to drop under a cut.

Git-native supervisor loop

On render completion the document is committed and tagged. You retain terminal authority: revert to the last render checkpoint with a non-destructive, path-scoped restore that doesn't touch your other work; branch any cut into an alternate and open a pull request via the host's REST API. Agent commits carry Co-Authored-By: provenance, giving every edit an auditable chain-of-custody in plain git log / git blame / git show.

Publish to YouTube — from the app or by asking your agent

Render, then ship — in one gesture. A finished render offers a Publish to YouTube action that opens the upload panel prefilled with that exact file, and you can right-click any .mp4 in the Explorer to publish it. Tools → Publish to YouTube does a resumable upload of your rendered video with title, description, tags, category, and privacy; optional native scheduling (publishAt), an .srt caption track, a custom thumbnail, and playlist placement. Sign-in uses your own Google "Desktop" OAuth client and tokens are held in the OS keychain — nothing routes through our servers.

It also ships a local MCP server so any coding agent (Claude Code, Cursor, Codex) can run the whole pipeline by asking — "render project.otio as a 9:16 Short and upload it unlisted." Its youtube_render tool renders a timeline to an mp4 with the same compiler the editor uses (pick 16:9 / 9:16 / 1:1 and 720p / 1080p / 4K), and youtube_upload_video uploads it — closing the edit → render → upload loop with no GUI. The server runs entirely on your machine with its own browser sign-in and local token store (no cloud), requests the least-privilege youtube.upload scope by default, and installs in one click via "Owlie Studio: Set up YouTube Upload MCP."

Calendar — plan and schedule your posts

A Calendar section for planning releases across platforms (YouTube, TikTok, Instagram, X, LinkedIn). Compose a scheduled post from the section header — title, time, caption, target platforms, and an optional local video + thumbnail — and the sidebar previews the next few upcoming entries, each opening in a themed Calendar editor and carrying a status (draft / scheduled / published / failed). Backed by a global store, so your schedule follows you across workspaces. Today it's a planning ledger — it stores and previews your plan; the dispatcher that would auto-publish on the scheduled date isn't wired up yet.

Media Library — browse, preview, and de-risk your footage

A dedicated panel over any folder of media (open it from the sidebar or the command "Owlie Studio: Open Media Library"):

• Grid + filters — a responsive thumbnail grid with Images / Videos / Audio / Other filters, search across filename / camera / codec, and live stats.
• Preview + playback — click any item for a full-screen image lightbox (cursor-anchored zoom, drag-pan) or inline video / audio playback, alongside its EXIF: camera, focal length, ISO, aperture, exposure, capture date, dimensions, codec.
• GPS map view — click Show map to plot geotagged photos and videos on an OpenStreetMap street map; the grid follows the map viewport, and each item's detail shows a mini-map of where it was shot. Tiles are fetched host-side and cached, so the panel stays fully sandboxed under a strict offline CSP.
• Privacy — bulk GPS removal — find everything that leaks your location (a 📍 badge, a "have GPS" count, and an Only with GPS filter), then strip GPS from selected items or the whole library. Cleaned …nogps copies are written next to the originals — your originals are never modified — so they're safe to share online.

Social Media — watch channels and pull their latest

A Social Media sidebar section with YouTube and TikTok: add channels to a per-project watch list (paste a URL or @handle), then hit the fetch icon on a channel — or on a platform, to sweep all of its channels — to download their newest videos straight into the workspace. Downloads land in a "Social downloads" Media Library folder, ready to drop on the timeline. Defaults to the latest 5 (configurable, with a per-fetch override), and a per-channel download archive means already-fetched videos are skipped on the next pull.

Capture your screen without leaving the editor

Record your screen and system/mic audio, or grab region and full-screen screenshots, straight into the Media Library — with a cursor highlight, recording-border privacy exclusion, and one-click export to animated GIF.

ToDo — a project-agnostic checklist in the sidebar

A lightweight ToDo list lives in the sidebar and persists globally, so it's there whether or not a folder is open. Add a task from the section's + button, click any row to toggle it done/undone, and remove it with the inline trash icon — a quick place to park cut notes like "re-cut the intro to 15s" without leaving the editor.

Jobs — live background-task status

Every background pipeline — proxy, waveform, thumbnail, transcription, and render — reports into the Jobs section as it runs. Active jobs sort to the top with a live stage + percent readout (or the error message on failure), and any running or queued job carries an inline Cancel button. The list updates itself off the Worker's job stream, so you can watch an import or export finish without leaving the sidebar.

Three complementary UI surfaces

• Native file-explorer access — the .otio file opens as plain text in the standard JSON editor; diff, search, fold, and jump-to-symbol come for free.
• Interactive Pixi.js timeline panel — GPU-accelerated visualization with per-frame playhead, drag-to-reorder, trim-by-handle, split-at-playhead, in/out marking, and an embedded preview bound to the incremental renderer.
• Rich sidebar — Timelines; Media Library (grid browser with preview, playback, and map); Social Media (watch YouTube / TikTok channels); Tools — grouped into collapsible categories: Capture (screen recorder, region / full-screen screenshots), Import & Download (YouTube download, import local media, BGM library), Audio (extract WAV, transcribe, generate narration), Image (remove background color, remove background AI / rembg, convert format, resize & reframe), and Video (convert to MP4, compress / shrink, grab frame → still) — with Publish to YouTube and a Transitions reference group below; MCP (cloud tools + prompts, green when signed in); ToDo (project checklist); Calendar (upcoming scheduled posts); Jobs (live background-job status); History; Accounts (Owlie Says sign-in, GitHub for branches
  • PRs, your NVIDIA API key, and connected social accounts with Verify / Reauthorize / Disconnect); and Help — auto-refreshed by the workspace file watcher, with a ⚙ Settings shortcut in the view's title bar.

Robust cross-platform bootstrap

External tools installed via system package managers are discovered even when PATH updates haven't propagated into the running IDE: a multi-plan spawn fallback (PATH binary → python -m → py -m) with a post-spawn liveness probe, plus Windows winget package-directory probing with PATH injection into spawned children — no IDE restart after a fresh install. And when a tool genuinely isn't there yet, the failure isn't a dead end: a missing external tool surfaces a one-click Install … action on the error toast that opens the matching setup guide. The Help section carries the full set of one-click install guides — FFmpeg (+ audiowaveform), Whisper, yt-dlp, Chatterbox TTS (for Generate Narration), and Background Removal / rembg (for Remove Background (AI); first run downloads a ~170 MB model) — alongside a keyboard-shortcut cheat-sheet and a Working-with-Media guide.

Telemetry & privacy

Owlie Studio sends anonymous usage analytics to Google Analytics so we can see how many people use the extension and which core actions (activation, render) get exercised. Each install generates a random ID that identifies nothing but itself; events carry only the event name, extension version, VS Code version, and OS platform.

Never sent: file paths, file contents, media, prompts, transcripts, timelines, tokens, or account identity. Your footage and your AI conversations stay on your machine and your own subscription — telemetry doesn't change the privacy-by-construction story above.

Two ways to turn it off (either one is enough):

• Owlie Studio only — Settings → owlieStudio.telemetry.enabled → off.
• All of VS Code — set telemetry.telemetryLevel to "off"; Owlie Studio honors the global switch automatically.

License

Proprietary — Copyright © 2026 Owlie Says. All rights reserved. See LICENSE. Bundled third-party open-source components remain under their own licenses (see NOTICE).

Patent pending — USPTO provisional application No. 64/069,062 (filed 2026-05-19).