Livecaster local transcription, remote reasoning

A live co-pilot for podcast hosts.

While you record, Livecaster transcribes the conversation on your own machine and every twenty-five seconds asks a fast model how your outline is holding up against what was just said. You get a map of the episode instead of a script.

Runs on

macOS and Linux

Transcription

On your machine

Two-hour episode

About $0.50

Your outline file

Never modified

01 The map

What it does

Livecaster reads your episode plan as Markdown and follows the conversation against it. Headings, bullets, nested bullets, question lines, whole paragraphs: it takes whatever you already write.

  • Covered topics get struck through

    With the time they were covered, so you can see how much of the plan is behind you.

  • Topics that just became relevant light up

    In amber, with a short reason and a sentence you could use to get there from wherever the conversation is now.

  • Questions and links collect on the side

    Follow-ups worth asking, and the things you promised to link to, so you do not have to remember them until the end.

  • Your outline file is left alone

    Livecaster only reads it. Everything it writes goes into a session directory of its own.

02 A session

How a session goes

You write the outline in whatever editor you use, point Livecaster at it, and press Start when you are ready. The interface is a page served on your own machine.

  • Before you press Start

    One pass over the outline fills in suggested questions and trigger phrases for each topic. It runs in the background while the map is already on screen, so it does not hold you up.

  • While you talk

    Speech is transcribed locally as it arrives. Every twenty-five seconds the recent transcript and the state of the outline go to a fast model, which answers in about nine seconds.

  • The map updates

    Items are marked covered, touched or hot. The Now panel holds one line and three labels of at most five words each. Nothing on that screen is meant to be read in full while you are speaking.

  • When you finish

    Press Finish and a slower, better model reads the whole transcript and writes the notes.

00:41:07 STT local $0.09 · 98 ticks
  • Why we built it ourselves 00:04:12
  • What it costs to run live the guest just asked about the bill You asked what the bill looks like. That is the part that surprised us.
  • What breaks on a bad connection

The map, mid-episode.

03 Notes

What you get at the end

The notes come out in the language of the podcast rather than in English.

  • A summary, and what was covered. Including the topics that were on the plan and never came up.

  • Chapters with timestamps, relative to the sync mark if you pressed one when your other recorder started.

  • Titles and descriptions to pick from.

  • A social post.

  • Quotes worth pulling out.

  • Mentions with links, or a link TODO where it could not find one. It says so instead of inventing a URL.

Everything lands in one session directory: the notes, the annotated outline, the transcript as Markdown and as SRT, and the raw analysis as JSON.

04 Demo

A walkthrough, recorded with Livecaster running on itself

Still from the Livecaster walkthrough video
The walkthrough is in Slovak. The outline it follows is in the repository, with an English translation beside it.

05 Cost

Privacy and cost

The audio never leaves the machine. Transcription runs locally and the WAV backups are written beside the session. What crosses the network is the outline text, the transcript text, and the state derived from them.

A two-hour episode costs about fifty cents, and the number comes from real sessions. A tick averages $0.0009, because most of each prompt comes back from the provider's cache, and the wrap-up at the end came to between $0.14 and $0.20 on short episodes. A whole six-minute live session cost $0.17.

If that is still too much, point the wrap-up at the same cheap model the ticks use and pay less for worse notes.

06 Limits

Before you try it

  • The transcriber picks the language itself

    Parakeet detects the language per utterance and cannot be told which one to use. On poor audio it drifts. There is a language lock in the top bar, and a Whisper engine that honours the language at the cost of a couple of seconds per utterance.

  • A Bluetooth headset is usually the problem

    Opening its microphone drops the whole link into 16 kHz handsfree mode, which is where most of the drift comes from. Use a wired or USB microphone for a real episode.

  • One microphone means no speaker labels

    Remote mode captures your microphone and the browser's output as two channels. On a single microphone there are no labels, and the prompts are written to work without them.

  • A crash costs you the sentence in flight

    The transcript, the session state and the audio are written as they happen. Resuming reloads all of it and picks up where it stopped.

07 Install

Get it on GitHub

You need Python 3.12 and uv. The README has the install for macOS and for Linux, the API key it wants, and the check command that verifies the lot.

$ git clone https://github.com/jooray/livecaster-llm && cd livecaster-llm
$ uv sync --extra mac  # or --extra linux
$ uv run livecaster check

The first run downloads about 2.4 GB of transcription weights, so do not leave it until the morning of the episode. check also resolves every microphone you named in the config, so a device that was renamed fails there rather than when you press Start.

read-only

add #edit to the URL to edit this page