How to run private AI transcription on your own laptop

You can run AI transcription entirely on the laptop you already own: free, under a hotkey, with nothing you say ever leaving the machine. There’s no app in this build. The whole thing is three parts you own: an engine called whisper.cpp, a model file you download once, and a small script that glues them to a hotkey, which is now something you describe to an AI agent rather than write yourself. This playbook is the exact build we use every day, plus the packaged-app shortcut at the end for anyone who’d rather not build at all.

Two reasons it’s worth an afternoon. Speed first: a Stanford study found speech input three times faster than typing, with a 20% lower error rate. You speak at 130 to 150 words a minute and type at about 40, so every long email, brief, file note and rambling idea is arriving at a third of the pace it could. Privacy second: every cloud transcription tool is, by definition, your words on someone else’s server. Otter.ai is currently facing consolidated federal lawsuits alleging its notetaker recorded people without consent and used those recordings to train its models. Those are allegations, not findings, but the underlying point doesn’t need a courtroom: what never leaves your laptop can never be leaked, subpoenaed from a vendor, or fed into someone’s training run.

1. Check your machine can handle it

If you bought a Mac in the last five years, you’re already there. Any Apple Silicon machine (M1 onwards, 2020 and later) runs Whisper comfortably, because whisper.cpp was built to squeeze speed out of exactly these chips. The benchmarks put the turbo model at roughly ten times faster than real time on a recent MacBook: an hour of audio transcribed in about six minutes, a dictated paragraph in under a second.

Memory is the only spec that matters. 8GB is fine for transcription alone. If you want step 6, the local model that writes your summaries, 16GB makes life easier. On Windows, whisper.cpp has builds too, and the packaged apps at the end run on any recent machine. The worked example from here is Mac, because that’s where this build shines and where we run it.

2. Install the engine: whisper.cpp

You’ll hit the word whisper.cpp a lot, so here’s the plain version: OpenAI released their Whisper speech-recognition model as open source, and whisper.cpp is the community’s lean rebuild of it that runs fast on normal laptops instead of data-centre hardware. That’s all it is. An engine with no interface, which is why we’re about to wrap one around it.

Open Terminal (press Cmd+Space, type “terminal”, hit enter) and run two commands, one at a time:

brew install whisper-cpp
brew install ffmpeg

The first is the engine, the second is the standard tool for handling audio files. If your Mac says brew doesn’t exist, install Homebrew first with the one-line command on its homepage. And if all of this already feels foreign, hold that thought: in step 4 you’ll have an AI agent on hand, and it’s perfectly reasonable to make installing these its first job while you watch.

3. Download a model from Hugging Face

The engine needs a brain, and the brain is a single file you download once. The official conversions live on Hugging Face, a site best thought of as the app store for open AI models, in the whisper.cpp collection.

One recommendation covers nearly everyone: large-v3-turbo, in the q5_0 version, a 547MB file with close to the accuracy of the full 3.1GB flagship at about six times the speed. It handles accents, jargon and mumbling into your laptop mic on a Tuesday. If your machine is older or you only ever dictate in English, small.en at 466MB is faster still and noticeably lighter. Skip the full large-v3 unless you’re transcribing courtroom audio; the turbo file gives up almost nothing.

Download the model file, make a folder like ~/whisper/models, and drop it in. That path matters in the next step.

4. Don’t write the script. Describe it.

This is the step that used to make the build developer-only, and it’s the step that has changed completely. The glue between hotkey, microphone and whisper.cpp is a small script, and you don’t write it. You open an AI coding agent, describe the tool in plain English, and test what it hands back. We use Claude Code; Cursor or Codex do the same job. This isn’t a novelty workflow, either: there are public builds of exactly this pattern, and ours has been a daily driver for months.

Before you write the brief, make the one decision that shapes the tool: what happens to your words after they’re transcribed. Three sane setups. Paste and vanish: the text lands wherever your cursor is, the audio and transcript are deleted on the spot, nothing accumulates. Right for sensitive work, and the default below. The archive: the text still lands at your cursor, but every dictation is also appended to a dated text file in a folder you choose, so you build a searchable record of everything you’ve ever dictated. Genuinely useful for file notes and ideas; just know the record exists and treat the folder accordingly. Clipboard only: the transcript goes to your clipboard and nowhere else, you paste it where you want, and it’s gone the next time you copy something. Any of these is one line in the brief, and you can change your mind later with one sentence to the agent.

Open the agent in Terminal and give it this, edited to taste:

Build me a push-to-talk dictation tool for this Mac.

When I hold down the right Option key, record from the microphone.
When I release it, stop recording, transcribe the audio with
whisper-cpp using the model at ~/whisper/models/ggml-large-v3-turbo-q5_0.bin,
and paste the text wherever my cursor is, in any app.

Requirements:
- Everything runs locally. No network calls, ever.
- Delete the audio and the transcript after pasting. Keep nothing.
  (Or: also append every transcript to a dated file in ~/Documents/dictation.)
- Start automatically when the Mac starts.
- Walk me through any permission pop-ups macOS shows
  (microphone, accessibility) as we go.

Test it end to end with me before you call it done.

macOS will ask you to approve microphone access and something called accessibility access (the permission that lets the script type text for you). The agent will tell you when each pop-up is coming and which box to tick. Ten minutes later you hold a key, talk, release, and your words land in whatever you were writing: email, doc, chat, anywhere.

You’re the tester, not the coder. The first version will have a quirk. Maybe the paste lands twice, maybe the hotkey clashes with something. Don’t debug it yourself and don’t give up: copy the error or describe the misbehaviour, paste it back to the agent, and let it fix its own work. That loop, describe, test, paste back, is the entire skill, and it’s the same loop that will maintain this tool for years.

5. Teach it your words

Whisper is strong out of the box, but it’s never met your clients, your products or your industry’s acronyms, and the first place a transcript goes wrong is names. The fix is a vocabulary list: whisper.cpp accepts a hint prompt that biases it toward the words you actually use. Tell your agent: “add a vocabulary list to the transcription call with these words” and give it the twenty terms it keeps fumbling. Two minutes, permanent fix.

Then spend a day dictating everything and notice what you’d tune. Punctuation is automatic and good. Long rambles come back as clean paragraphs. If you want new-paragraph behaviour on a spoken cue, or a different key, or a small sound when recording starts, they’re all one-sentence requests to the agent. This is the quiet advantage of owning the build instead of renting an app: every niggle is fixable, by you, in plain English.

6. Add a local model to write the notes

Transcription gets your words down; the next rung has a second local model turn them into something finished, with nothing leaving the machine at any point. Install Ollama, the free tool that runs open AI models on your own laptop, then pull a small model: qwen3:8b is a strong pick on a 16GB machine, gemma3:4b if you’ve got 8GB.

Then extend your build. Tell the agent: “add a second command that takes a transcript and runs it through the local model with this prompt, and give me back tidy meeting notes with decisions and action items.” Now a dictated brain-dump becomes a structured file note, a recorded call becomes minutes, and a rambling voice memo becomes a to-do list, all offline.

Know the trade on quality: an 8B model on a laptop is a rung below the frontier cloud models. For summaries, notes and action items it’s genuinely fit for purpose. For a client-facing document you’d still draft with the big models, using text you’ve already decided isn’t sensitive. This rung is newer and less documented than the dictation build: it works, we run it, and you should expect to tinker.

7. Point it at meetings, and ask first

For meetings, skip the bot-joins-your-call model entirely. Meetily is a free, open-source meeting note-taker that captures your system audio and microphone on your own machine, transcribes with whisper.cpp, and summarises through Ollama. No bot in the participant list, no vendor account, no meeting audio on anyone’s server, and it works with any call platform because it listens to your machine, not the meeting. It’s the assembled version of the pipeline you just built, for macOS and Windows, and it’s the obvious answer for conversations you’d never hand to a cloud notetaker.

Local doesn’t mean lawless. Consent rules for recording conversations apply whether the file goes to a server or stays on your disk, and in Australia they differ state by state. Part of the Otter litigation is about recording people who never agreed. Don’t import that mistake into your private stack: say “I’m recording this for notes, all good?” at the top of the call, every time.

8. Roll it out to a team, the regulated-industry play

If you run a clinic, a law practice, an accounting firm or anything else where conversations are the confidential asset, this build is a rollout pattern, not a personal toy. The shape: the same scripted build on every laptop, model versions pinned so every machine transcribes identically, no vendor accounts, and summaries through the local model only. Your privacy review collapses into one sentence a regulator can verify: the audio never leaves the device. No data-processing agreement, no retention policy to audit, no vendor breach that can touch you, no terms-of-service update that quietly adds training rights.

This rung is the frontier: there’s no product to buy and no guide to follow past this one, and it needs one person, in-house or hired, who owns the build, tests updates and hands out the hotkey. That’s a real cost. It’s also a fraction of what a compliant enterprise transcription contract costs, and it comes with a privacy story no cloud vendor can match. The strategic case for owning this layer of your stack is one we’ve made in full in the AI sovereignty playbook; this is that argument with a hotkey on it.

Buy the shortcut or build the tool

To be clear about what the build gets you: you don’t need an app for any of this, and the apps that sell local transcription are running the same Whisper models you just installed for free. What they’re selling is the packaging. If that’s worth money to you, the good ones at each price: Handy is free, open source, works offline on Windows, Mac and Linux, and does the core hold-a-hotkey-and-talk job. VoiceInk is US$25 once, Mac only, on-device by default, and more polished. superwhisper has a free tier and a Pro plan at US$8.49 a month, with the slickest experience and optional cloud modes you’d want to leave off. For transcribing recordings and files rather than dictating, MacWhisper has a free tier and a €59 one-time Pro that adds speaker labels.

The aeroplane-mode test. Some dictation apps advertise privacy while defaulting to cloud models. Before you trust any app with sensitive talk, turn off Wi-Fi and try to dictate. If it works, it’s local. If it spins, your voice was leaving the building.

So the call: install Handy today if you just want to stop typing and bank the speed win. Build the whisper.cpp pipeline when you want the tool shaped exactly to you, your vocabulary, your hotkey, your rules for what gets kept, and audio that provably never leaves the machine. Add the local summariser when your notes are sensitive enough that “private end to end” beats “slightly smarter summary”. And if you’re taking it to a team in a regulated industry, give the build an owner before you give it to the team: this is the one rung where doing it half-way creates the exact risk you were trying to remove.