Local-first AI content agent

Long-form video in.
Vertical clips out.

ClipForge transcribes your video, works out which sixty seconds are worth keeping, cuts them vertically and hands them to you for review — all on the GPU already sitting in your desk. Nothing is billed per minute, because nothing is sent anywhere to be billed.

  • MIT licensed
  • Runs on 6 GB of VRAM
  • No per-minute API
  • Review from your phone

Cloud video pipelines charge by the minute. Your GPU does not.

Transcription, semantic analysis and encoding are the three expensive operations in a clipping pipeline, and they are also the three that a consumer graphics card is genuinely good at. ClipForge runs all three locally and uses the cloud only for the things it is actually better at: knowing who you are, holding a little structured state, and reaching your phone.

No metered anything

No per-minute transcription, no per-token analysis. Process a three-hour podcast twice because you did not like the first pass, and the bill is the same as processing nothing.

Your footage stays put

A 60-minute 1080p source is 1–3 GB. Uploading it would invert the whole point, so it never happens: the source is read from disk and stays there.

Built for one small card

Whisper and the analysis model cannot both sit on 6 GB at once, so GPU residency is scheduled explicitly and every job is a checkpointed pipeline that resumes mid-run instead of starting over.

How it works

Five stages, each one checkpointed. Close the lid halfway through and the job picks up where it stopped rather than paying for the same work twice.

The ClipForge pipeline Ingest, transcribe, analyse and cut all run on your own machine. Only the last stage — review and publish — touches the network. YOUR MACHINE — NOTHING HERE TOUCHES THE NETWORK Ingest yt-dlp or a local file Transcribe faster-whisper, on GPU Analyse a local model, via Ollama Cut & encode ffmpeg with NVENC Review & publish phone, then YouTube sign-in, job state, and one clip for five days every stage checkpointed — a job resumes, it does not restart
  1. Ingest

    Point it at a file or a URL. yt-dlp handles the fetch; the source lands on your disk and stays there.

  2. Transcribe

    faster-whisper produces a word-level transcript on the GPU, without PyTorch and without an API key.

  3. Analyse

    A local language model reads the transcript and scores candidate segments on whether they stand alone.

  4. Cut and encode

    ffmpeg cuts the winners, reframes them vertically and encodes with NVENC — hardware you already paid for.

  5. Review and publish

    Approve or reject from your phone. Approved clips upload to YouTube with the title and privacy you chose.

What stays on your machine

"Local-first" is a claim that is easy to make and easy to check. Here is the actual split, and it is enforced by the security rules in the repository rather than by a promise on a marketing page.

Never leaves your machine

  • Source video. Read from disk, never uploaded.
  • Transcripts and model weights. Produced and used locally.
  • Your YouTube credentials. The client secret and refresh token are written encrypted to the worker and never to the cloud.
  • The finished clips. The copy that survives is the one on your disk.

Goes to the cloud, and why

  • Who you are. Firebase Authentication, so the phone and the desktop agree.
  • Job and clip metadata. Titles, timings, scores and status — kilobytes, not gigabytes.
  • One clip at a time, briefly. So it can play on a phone. Deleted when you review it, and by a bucket rule after five days regardless.
  • A notification. When a job finishes and you are not at the desk.

Under the hood

Nothing exotic, and every part of it replaceable.

Worker

Python 3.12 · faster-whisper on CTranslate2 · Ollama · yt-dlp · ffmpeg with NVENC · a scheduler with one GPU lane and several CPU lanes.

App

Angular 22 · Tailwind · an installable PWA with an offline shell, plus a Tauri desktop build for the machine that holds the credentials.

Control plane

Firebase Auth, Firestore, Cloud Messaging and Hosting. Security rules enforce approval; there is no server of ours in the path.

Questions

Does my video get uploaded to a server?

No. Source video never leaves your machine. Only a finished clip is uploaded, only so it can play on a phone during review, and it is deleted as soon as you review it — or after five days by a bucket lifecycle rule, whichever comes first.

What hardware does ClipForge need?

An NVIDIA GPU. The reference machine is an RTX 3050 with 6 GB of VRAM, and that constraint shapes the design: transcription and the analysis model cannot both be resident, so GPU residency is scheduled explicitly and jobs are checkpointed so they can resume.

What does it cost to run?

ClipForge is MIT licensed and free. There is no metered API in the pipeline. You supply a Firebase project for sign-in and job state, which for one person sits inside the free tier apart from the clip bucket that makes phone review possible.

Can it publish to YouTube on its own?

It publishes what you approve. The OAuth client secret and refresh token stay on the worker machine, encrypted, and are never written to the cloud — so a compromised database cannot upload to or delete from your channel. A publish that cannot afford its API quota is refused before the upload starts rather than after it.

Is this a hosted service?

No. It is software you install and run. There is nothing to sign up for here, no seat to buy, and no queue behind other people's video.

Is it finished?

It is in active development and built in the open. The pipeline, review and publishing all work; the plan, the architecture decisions and every rough edge are in the repository rather than behind a roadmap page.

Clone it and point it at a video

Python 3.12, ffmpeg, Ollama and a Firebase project. The README walks through the rest in about fifteen minutes.