Dictating prompts to an LLM agent: why macOS Dictation gets the jargon wrong, and what OpenWhispr actually does (local models, BYOK, LiteLLM, cost, and the alternatives)

Research date: 13 Sep 2026. Every number below carries the source it was verified against on that date. Repo stats, release counts, download counts and issue/PR totals are live GitHub API snapshots from 13 Sep 2026; prices are taken from the vendors’ own pricing pages on the same date. Claims that are the vendor’s own self-description rather than independently measurable are labelled “vendor claim”. Findings I could not verify either way are collected in the caveats.

TL;DR

• The premise holds, but for a different reason than “it doesn’t know jargon.” Apple’s Dictation is a closed model with no user-vocabulary channel, no model choice and no bring-your-own-key path — Apple’s own docs say the feature is “not available in all languages or regions” and that you can only check whether audio is processed on-device (Apple: Dictate messages and documents on Mac). What actually fails for agent prompts is that nothing in the stack is addressable: you cannot tell it your product name, your internal codenames, or pgvector. Everything after that is a model-quality argument, and a 2026 Whisper-class model plus a dictionary beats it on exactly the tokens an LLM agent cares about.
• OpenWhispr is real, and larger than a hobby project. MIT, created 19 Jun 2025, 8,102 stars / 999 forks / 91 contributors / 89 releases, last commit 12 Sep 2026, v1.10.0 shipped 11 Sep 2026 (repo). ~4.59M release-asset downloads across its releases. It is Electron 41 + React 19 + TypeScript, and it calls whisper.cpp and sherpa-onnx for local inference.
• How it works, end to end: global hotkey → local recording → transcription (local / cloud / BYOK / enterprise / self-hosted) → optional LLM cleanup pass → text copied to the clipboard and a paste keystroke sent to the focused window, then your old clipboard restored. It does not inject characters into the target app (docs: Dictating into other apps).
• The jargon fix is a custom dictionary, and it is passed differently per engine. For most providers it rides the prompt field; for gpt-transcribe it rides a dedicated keywords[] multipart channel; Deepgram Nova-3 uses keyterm. It is a hint, not an override, and it is windowed — Whisper accepts ~224 prompt tokens, Groq 896 characters (docs, OpenAI speech-to-text).
• Pure OpenAI: yes, trivially. Add your OpenAI key and pick gpt-transcribe, gpt-4o-transcribe, gpt-4o-mini-transcribe or whisper-1. Pure LiteLLM: yes, with caveats — the “Self-Hosted” mode POSTs multipart/form-data to {your-url}/audio/transcriptions and reads {"text": "..."}, which is exactly what a LiteLLM proxy exposes (LiteLLM /audio/transcriptions). But that path is batch-only (no streaming), is not available for Note Recording, and needs HTTPS unless it is loopback or a private address.
• Cost, honestly: per-minute transcription is cheap. OpenAI gpt-transcribe is $0.0045/min; Groq’s Whisper Turbo is $0.00067/min ($0.04/hr); the OpenWhispr Pro plan is $8/month flat. That is per minute of speech, not per prompt. If you dictate 15 minutes a day (about 450 min/month) you are looking at $0.30–$2.03/month on a BYOK key. Light use is under a dollar a month.
• Google is not cheaper — and “Google TTS” is the wrong product. TTS is text-to-speech synthesis; you want speech-to-text. Google STT v2 Standard is $0.016/min, about 3.6x gpt-transcribe and 24x Groq Turbo. Google’s $0.003/min dynamic-batch tier is the only competitive number, and it is batch, not real-time dictation.
• Hardware is modest. macOS 12+ (Apple Silicon or Intel), Windows 10+ x64, Linux x86-64 only — no ARM or Raspberry Pi build. Local models want 75 MB to 2.7 GB of disk and roughly 1–10 GB RAM depending on size. On an M-series Mac an 11-second clip transcribes in 173 ms (Orukeet) or 230 ms (Parakeet) on the arm64-native sherpa-onnx runtime.
• Caveats that will actually bite you: paste-based delivery needs macOS Accessibility permission and breaks on non-QWERTY layouts; Whisper hallucinates filler phrases during silence; roughly weekly releases mean fast churn; Intel Macs lost ONNX Runtime support and with it diarization and semantic search; and the free cloud tier is a rolling 2,000 words per 7 days with a 25 MB upload cap.
• Adoption is real but lopsided. 4.59M downloads and 87% of PRs closed say it is a used, maintained product, and named outside contributors land fixes. Hacker News, however, has essentially ignored it: the top story is 5 points, 0 comments (HN search). It is winning through release channels and app-store search, not developer zeitgeist — and there is no independent accuracy benchmark anyone has published.
• Alternatives that beat it on specific axes: Handy (31,469 stars, MIT, Rust/Tauri, fully offline) is the bigger open-source project; VoiceInk (6,399 stars, macOS-native) is the polished Mac option; Wispr Flow ($15/user/mo) and superwhisper are the proprietary leaders; Whispering (4,798 stars, MIT) is the one this crowd actually upvoted (591 points, 152 comments). Pick on the axis you care about — offline, native macOS feel, or managed cloud.

1. The problem: why built-in macOS Dictation fails at agent prompts

The complaint is precise even when the diagnosis is loose. It is not that Apple’s model is bad at English. It is that three things you need are structurally absent:

Apple’s documentation is explicit about the limits it will admit to: Dictation “is not available in all languages or regions, and features may vary,” and the most you can do about processing is check whether voice inputs are processed on-device rather than sent to Siri servers (Apple). There is no model picker, no dictionary, and no key.

A fairness note. OpenWhispr’s own comparison page claims Apple’s model is “good but less accurate on technical content” and that Whisper and Parakeet “consistently outperform built-in dictation on technical vocabulary, accents, and noisy environments” (openwhispr.com/compare/apple-dictation) — that is a vendor claim, not a measurement, and I found no independent benchmark of Apple Dictation versus Whisper on technical corpora. Treat the direction as plausible and the magnitude as unproven. The structural argument above does not depend on it.

Why the jargon problem is worse for agent prompts than for prose. When you dictate an email, a wrong word is a small embarrassment. When you dictate a prompt for a coding agent, the wrong word is a broken instruction: pgvector becomes “PG vector,” kubectl becomes “cube control,” useEffect becomes “use effect,” a file path becomes a sentence. The tokens that carry the meaning are exactly the ones a general-purpose recogniser has never seen. That is a vocabulary problem before it is an accuracy problem — which is why the custom-dictionary mechanism matters more here than raw word error rate.

2. How OpenWhispr actually works

The pipeline

hotkey (Globe/Fn on macOS)
  -> record (local, WebM/Opus by default)
  -> transcribe   [local | cloud | BYOK | enterprise | self-hosted]
  -> cleanup      [optional LLM pass: fillers out, punctuation in]
  -> clipboard + paste keystroke to the focused window
  -> original clipboard restored

Sources: docs: How dictation works, docs: Dictating into other apps, docs: Dictation cleanup.

Two details from the docs explain most “why didn’t it work” reports:

• Delivery is clipboard plus a simulated paste, not typing. Step 1 copies the finished text, step 2 sends the paste keystroke to whichever window has focus, step 3 restores your previous clipboard. Consequences: focus decides everything (the text lands wherever the cursor is when dictation ends), and the clipboard is “borrowed, not taken.”
• Cleanup is a separate LLM call, on by default, with its own model. Transcription turns audio into words; cleanup is a second pass through a language model that removes filler words, fixes grammar and polishes punctuation. It has its own provider, model and prompt, independent of both the transcriber and the voice agent. It can be switched off entirely, and if it fails, your dictation is pasted uncleaned rather than dropped.

The architecture

Sources: README, package.json, src/models/ModelRegistry.ts, repo tree.

The part that matters for an agent workflow

There are five separate hotkeys, not one, and they do genuinely different things (docs):

1. Dictation — your words at the cursor.
2. Voice agent — your words are an instruction; the model’s answer is what lands at the cursor. Selecting text first edits it in place. Optional screen-context capture (Share screen context, off by default) makes “explain the error on screen” work — the screenshot is used once and never saved.
3. Dictation translation — speak one language, paste another.
4. Meeting mode — live transcription with diarization.
5. Chat agent — a chat surface that can search notes and the web.

For prompting a coding agent, hotkey #1 with a dictionary is the useful one, and it is deliberately dumb: transcribe, lightly clean, paste. It also recognises terminals specifically — on Windows and Linux it switches paste shortcuts by window class (Windows Terminal, mintty, Alacritty, kitty, WezTerm, Ghostty, about 24 on Linux), and for Electron editors like VS Code and Cursor it sends Shift+Insert because that is the one shortcut that works in both the editor and an embedded terminal, and that terminal AI agents such as Claude Code, Codex and OpenCode do not intercept as “paste image” (docs: Editors, IDEs and terminals). That is a small thing that reveals the target user.

3. What it can transcribe with

Cloud and API providers (from src/models/modelRegistryData.json, v1.10.0)

“OpenWhispr Cloud” is a separate managed lane that needs no key: Free = 2,000 words per rolling 7 days, Pro $8/month or $80/year = unlimited, with a 25 MB upload cap on Free and BYOK and 500 MB on paid (docs: Plans and limits).

Local models

Vendor claim: OpenWhispr describes Cohere Transcribe as “5.42% average word error rate across 14 languages — the most accurate offline model OpenWhispr ships.” That figure comes from the project’s changelog, not from an independent evaluation.

Sources: docs: Local models, CHANGELOG.

4. The jargon fix, and its real limits

The custom dictionary is the feature that answers the original complaint. How it is delivered depends on the engine, which is not obvious from the UI:

That table is the single most useful thing to know before you invest in a big word list, and the project learned it the hard way — a v1.10.0 fix had to stop a blanket 900-character cap that was silently truncating a 1,633-character dictionary to 899 characters, “about half the words dropped, with no indication anywhere,” on models that accept 16k tokens (CHANGELOG #1632).

Practical rules, straight from the docs:

• The dictionary is a hint, not an override. “It raises the odds; it isn’t an override.” If a word still comes out wrong, the doc’s advice is to try the spelling you want to read, not the phonetic one.
• Don’t dump your whole vocabulary in. “A very long list dilutes it — the fifty words you actually get wrong beat five hundred you don’t.”
• Snippets are the exact-text escape hatch. For a phrase you say constantly, a snippet replaces a trigger with exact text rather than nudging a model.
• Auto-learn from corrections watches for you fixing a transcription in the target app and adds the corrected word (Settings → Preferences → App). It is the highest-leverage setting for this use case, since the words you correct are by definition the ones being got wrong.
• Cleanup cannot fix a misheard word. Cleanup only sees the transcript, never the audio. Persistent wrong words are a transcription problem, and only the engine or the dictionary will move them.

Also worth knowing: the accuracy guide explicitly ranks “name your language” as the single cheapest improvement, because on auto-detect “the model spends part of its effort deciding what language you’re in” (docs). If you dictate English prompts, pin the language.

5. Pure OpenAI? Pure LiteLLM?

Pure OpenAI: yes, and it is the default BYOK path. Enter an OpenAI key, pick a model, done. The first-party provider is hard-wired to https://api.openai.com/v1, so there is no endpoint to get wrong. OpenAI’s own docs also make the vocabulary story concrete: gpt-transcribe takes a prompt string and a separate keywords array — prompt: "A customer support call about a premium plan and account AC-42.", keywords: ["premium plan", "AC-42", "billing"] — with the warning that “keywords are hints, not required output” and a note to “keep each keyword on one line” (OpenAI speech-to-text). That is precisely the channel OpenWhispr uses for your dictionary.

Pure LiteLLM: yes, through the “Self-Hosted” mode. Here is the actual contract OpenWhispr expects (repo example: Custom ASR shim):

POST {your-server-url}/audio/transcriptions
  multipart/form-data
    file      recording (WebM/Opus by default, filename audio.webm; may be ogg/mp4/mp3/wav)
    model     the Model string from the Self-Hosted panel, when set
    language  ISO code, only when you pick a non-auto language
    prompt    the custom-dictionary hint

expect HTTP 200 and JSON {"text": "..."}

LiteLLM’s proxy registers both /v1/audio/transcriptions and /audio/transcriptions, and supports openai, azure, vertex_ai, gemini, deepgram, groq, fireworks_ai, ovhcloud and mistral as transcription providers, configured with model_info: mode: audio_transcription (LiteLLM docs). So a LiteLLM proxy really is a drop-in self-hosted endpoint for OpenWhispr, and it gives you one key, spend tracking and failover across all of those engines — which is exactly what you would want if you were testing Groq Turbo against OpenAI gpt-transcribe on your own speech.

The caveats are specific and worth reading twice:

1. Self-hosted transcription is batch HTTP only. OpenWhispr does not send stream=true on that path, and the shim returns a single JSON object rather than server-sent events.
2. Note Recording can’t use a self-hosted endpoint yet — the in-app string is literally “Note Recording can’t use a self-hosted endpoint yet. Open Settings and choose Local or a streaming provider.”
3. No API key is sent on the self-hosted path. Hold your vendor key inside the proxy; do not require Authorization from OpenWhispr.
4. HTTPS is required for public hosts. Plain HTTP is allowed only for localhost, *.local, loopback, and RFC1918/link-local/CGNAT ranges. So a LiteLLM proxy on your LAN works over HTTP; one on a public host needs TLS.
5. Deepgram and AssemblyAI are the reverse case: streaming-only. A batch, upload or retry request for them fails closed by design — the code comments explain this is deliberate, so audio does not silently fall through to api.openai.com on your OpenAI key.
6. The AI passes (cleanup, voice agent, chat) use a separate OpenAI-compatible setting. That path uses /chat/completions, not /responses, specifically so LiteLLM, vLLM, DeepSeek and llama-server proxies work (CHANGELOG #1181) — LiteLLM is named in the project’s own changelog as a supported custom endpoint, and the test suite contains a case literally using a litellm-key.

Bottom line: if you want one cloud provider, use BYOK directly. If you want to A/B models, cap spend, or keep a vendor key off your laptop, run LiteLLM and point Self-Hosted at it — accepting that dictation works, streaming does not, and meeting or note recording stays on another lane.

6. What it costs

Unit prices, from vendor pricing pages on 13 Sep 2026

Sources: OpenAI pricing, Groq speech-to-text docs, Deepgram pricing, AssemblyAI pricing, Google Cloud Speech-to-Text pricing, Gemini API pricing, OpenWhispr plans.

What that means per month

At a normal speaking rate of roughly 150 words per minute, 1 minute ≈ 150 words, and the free tier’s 2,000 words is about 13 minutes of speech per week.

Read the middle row as the realistic case for a developer who talks to a coding agent a few times an hour. You are in the low single-digit dollars per month on any modern engine. Against that, OpenWhispr Pro at $8/month is competitive with gpt-4o-transcribe at moderate use and beats it at high use — but local models are free, and so is the 2,000-word weekly cloud allowance.

Three honest footnotes:

• Cleanup is a second, metered call. The cleanup pass sends the transcript through a language model of your choosing. It is a few hundred tokens per dictation rather than minutes of audio, so it does not change the order of magnitude, but it is not free and it is not counted above.
• The 25 MB upload cap is the real wall, not the price. A 45-minute MP3 is typically 40–65 MB, which exceeds the BYOK and Free-plan cap. Dictation itself streams in short clips and is unaffected; long file uploads are.
• The free tier is a rolling window, not a weekly reset. Each transcription stops counting once it is more than seven days old, so there is no Monday where the counter returns to zero.

“Would Google be cheaper?”

No, and the question contains a category error worth correcting.

• Text-to-speech is the wrong direction. TTS synthesises audio from text. Dictation is the inverse: speech-to-text. Google’s TTS pricing (Aura-2 at $0.030 per 1,000 characters, and so on) is irrelevant to the problem.
• On recognition, Google is the expensive option. Google STT v2 Standard is $0.016/min — about 3.6x OpenAI gpt-transcribe, 5.3x gpt-4o-mini-transcribe, and 24x Groq’s Whisper Turbo (Google pricing).
• Google’s cheap tier is batch, not dictation. The $0.003/min dynamic-batch tier matches OpenAI’s mini tier and beats gpt-transcribe, but it is asynchronous batch recognition — you cannot stream a live dictation session through it.
• Google’s free allowance is thin and conditional. On the v1 API, the first 60 minutes per month are free on the with-data-logging SKU; without data logging the rate is $0.024/min above the free hour. Trading audio retention for a free hour a month is a bad deal for exactly the prompts you were worried about.
• Where Google is competitive: gemini-3.5-transcribe at about $0.005/min and Gemini 3.5 Transcribe Live at about $0.009/min (Gemini pricing). That is roughly gpt-transcribe territory, not Groq territory, and OpenWhispr supports both Gemini models natively.

7. Hardware requirements

Gated capabilities and hardware-dependent behaviour:

• System audio capture (recording the other side of a meeting) needs macOS 14.2+. Below that, meetings still record your microphone only.
• Local models, disk: about 75 MB (Whisper tiny) to 2.7 GB (Cohere Transcribe); models live in ~/.cache/openwhispr/whisper-models/.
• Local models, RAM: roughly 1 GB for tiny and base, about 2 GB for small, about 5 GB for medium, about 10 GB for large, about 6 GB for turbo (LOCAL_WHISPER_SETUP.md).
• GPU acceleration: Metal on Apple Silicon works with no setup. On Windows and Linux, NVIDIA gets one-click CUDA and AMD or Intel gets one-click Vulkan; the runtime is SHA-256 verified and falls back to CPU with an in-app notice if it fails or runs out of VRAM, so dictation keeps working.
• Measured speed on Apple Silicon: an 11-second clip transcribes in 173 ms on Orukeet and 230 ms on Parakeet with the arm64-native sherpa-onnx build, after v1.10.0 switched off the universal binary whose arm64 slice ran INT8 models “far slower” (from 605 ms and 665 ms). Identical transcripts.
• Intel Mac penalty, stated by the project: live speaker identification and voice fingerprinting are unavailable because ONNX Runtime stopped shipping macOS x86_64 binaries in 1.24. Meetings still record and transcribe; note search falls back to keyword matching instead of semantic search.

Sources: docs: System requirements, CHANGELOG, README.

Reading of this: cloud and BYOK dictation will run on almost anything, including an old Intel Mac. Local Parakeet-class accuracy at low latency wants Apple Silicon or a discrete GPU. The 672 MB Orukeet and 680 MB Parakeet tier is the sweet spot, not the 3 GB Whisper large.

8. Caveats worth knowing before you switch

Delivery mechanism

1. Paste-based, so macOS needs Accessibility permission. Without it the text is copied but never pasted — the deliberate fallback is that the transcript is always on your clipboard.
2. Focus is everything. Text lands wherever the cursor is when dictation ends. A notification stealing focus mid-dictation sends your prompt to the wrong app.
3. Non-QWERTY layouts broke auto-paste on macOS — Cmd+V resolved to the wrong character (issue #1478, open). Related issues track the same family, and a later release shipped a compositor-native symbolic-shortcut fix.

Transcription quality

4. Whisper hallucinates during silence. The open issue is blunt: with Groq’s Whisper API, transcriptions “randomly include hallucinated phrases that were never spoken, such as Thank you for watching!, Thanks for watching, Please subscribe” — traced to Whisper’s YouTube-subtitle training data, fixable locally via no_speech_threshold but not exposed by cloud APIs, so the fix has to be client-side voice-activity detection (issue #462, 13 comments, open). If you dictate into an agent, a silent pause can inject a sentence.
5. The dictionary is a hint and it is windowed — 224 tokens for Whisper-class models, 896 characters for Groq, 8,000 characters for the 4o family. A large glossary will be truncated.
6. Cleanup runs by default and can be wrong. It is a language model between you and your words. It is designed to be conservative and should not answer questions or rewrite tone — but if you want fidelity, turn it off and compare against View raw transcript.

Product and policy

7. Fast release cadence. 89 releases, v1.9.0 to v1.10.0 within a month, and an Enterprise note requiring a minimum app version of 1.10.0 for managed transcription. Expect churn; pin versions if you deploy this for a team.
8. The free cloud lane is a rolling window, not a weekly reset. 2,000 words per rolling 7 days, checked when a transcription starts (so a long recording can carry you over rather than being cut off mid-way), plus a 25 MB upload cap.
9. “No telemetry” needs a careful read. The README says “No data collection, no telemetry.” In the app there is a Usage analytics toggle described as sharing “anonymous performance metrics… only timing and error data,” and a separate opt-in Insights sync that can sync “word counts, the date and exact time of each dictation, durations, and model types” across devices. The docs are explicit that transcript content is never included. I could not verify the default state of the usage-analytics toggle from source, so check it yourself in Settings → Privacy & Data.
10. Erasure surface. On macOS the SQLite history lives at ~/Library/Application Support/OpenWhispr/ (transcriptions.db and audio/), and the docs state plainly that the database “is an ordinary file on your computer — OpenWhispr doesn’t encrypt it separately.” Audio retention defaults to 30 days; transcript retention defaults to forever. Set retention deliberately.
11. Cloud modes keep the transcript. In OpenWhispr Cloud mode, audio is processed and discarded but “the transcript and its technical metadata” are stored. Local and self-hosted modes put OpenWhispr Cloud nowhere in the path at all.
12. The MCP server is hosted. mcp.openwhispr.com is Streamable HTTP with no local install, and the beta transcribe_audio tool caps audio at 3 MB and requires a paid plan. If you want audio to stay local, use the CLI against the desktop app instead — the CLI’s POST /v1/transcribe runs whichever local model the app is set to, and “audio never crosses the bridge.”
13. There is a real open backlog. 174 open issues and 166 open PRs against 669 closed issues and 1,128 closed PRs. Healthy throughput, but it is a fast-moving project, not a settled one.
14. No independent accuracy benchmark exists. Every accuracy claim I could find traces back to the project’s own changelog or its own comparison pages — including the Cohere 5.42% word-error-rate figure and the “better on technical vocabulary than Apple” claim. This is a genuine evidence gap, not a mark against the app.

9. Alternatives

Star counts, licences and last-push dates are GitHub API snapshots from 13 Sep 2026.

Also in the field: savbell/whisper-writer (1,100 stars), VocaHQ/vocalinux (821 stars), infiniV/VoiceFlow (417 stars), MacParakeet (GPL-3.0), Pindrop (Swift/WhisperKit), Spokenly, WillowVoice, Typeless and Meetily.

How to choose in one line each:

• Want offline and nothing else? Handy.
• Want the best native macOS feel? VoiceInk (one-time) or superwhisper (subscription).
• Want dictation and meeting notes and an MCP surface? OpenWhispr.
• Want zero configuration and don’t care where audio goes? Wispr Flow.

10. Is it widely accepted? The evidence

The honest answer is “yes by volume, no by developer mindshare.” Both halves are provable.

Evidence for adoption:

Evidence that it is a community project, not a one-person app: outside contributors land real fixes and are credited by handle in the changelog — @nikhilmaddirala (Deepgram and AssemblyAI BYOK auth bugs), @alekc (macOS meeting audio tap watchdog), @hsusul (Granola import ID collisions, Cohere language codes), @boseq, @AdityaPainuli, @dajiaohuang, and @IdrisGit (non-QWERTY auto-paste). 91 contributors across 89 releases is a working maintenance loop, not a launch.

Evidence against the “widely accepted” framing:

• Hacker News has essentially ignored it. A query for “openwhispr” returns 14 hits; the top OpenWhispr story is 5 points, 0 comments (HN Algolia). By contrast, Whispering — an app in the same category — hit 591 points and 152 comments (HN). If “widely accepted” means “known on Hacker News,” the answer is no, and Whispering is the one that is.
• The comparison content is vendor-authored. OpenWhispr publishes around 18 /compare/* pages and claims transparency, but every comparative claim about competitors comes from OpenWhispr.
• No independent benchmark. No third-party word-error-rate evaluation of OpenWhispr versus Apple Dictation versus Whisper versus Parakeet was findable on 13 Sep 2026.
• The download number is a lower bound with soft edges, since auto-updates and re-installs count again. Treat 4.59M as “millions of installs,” not “4.59M users.”

Why it got this far — the causal read. Four things compound:

1. It solves an everyday friction for a specific, motivated user — the person already paying a monthly fee for a coding agent who wants to prompt it at speaking speed. That user is exactly the one who notices jargon failure, and is exactly the one who will accept a 672 MB model download to fix it.
2. It refuses to pick a lane. Local or cloud or BYOK or enterprise or self-hosted, per activity, with a free tier that is genuinely usable on local models. Almost every competitor forces the choice.
3. MIT plus a real release cadence. Weekly-visible progress and an open backlog make it purchasable by a skeptical engineer — you can read the code that handles your keystrokes before you grant Accessibility.
4. It shipped the boring enterprise surface. Network allowlist for firewalls, a DPA, a trust centre, SCIM provisioning, managed Bedrock and Azure. That is what moves a tool from personal hack to something you can put in front of an IT team.

The gap between “4.59M downloads” and “5 points on Hacker News” is the whole story: this is a product that grows through app-store search and word of mouth among people who dictate, not among people who read launch threads.

11. What I would actually do

1. Install the desktop build and start on local Orukeet (~672 MB). It is the recommended default, it needs no key, and on Apple Silicon it transcribes an 11-second clip in about 173 ms. That tells you in an afternoon whether the approach beats macOS Dictation for your speech, at zero cost.
2. Pin your language and build a 30–50 word dictionary of the terms you actually get wrong, not a glossary. Add auto-learn from corrections and let it grow. If a word still fails, add a snippet rather than fighting the model.
3. If local accuracy is not enough, move to BYOK Groq first — $0.04/hour is roughly 7x cheaper than gpt-transcribe and it is the same Whisper family. Keep OpenAI gpt-transcribe as the accuracy fallback.
4. If you dictate into a coding agent, check the terminal recognition and decide deliberately about cleanup. A raw transcript plus a good dictionary may be more faithful than a language model’s tidy-up.
5. If you want one key, spend caps and failover, put LiteLLM in front and point Self-Hosted at it — knowing dictation works, streaming does not, and note recording stays elsewhere.
6. Skip Google unless you are already inside GCP. Its recognition pricing is about 3.6x gpt-transcribe at the standard tier, and “Google TTS” is the wrong product for the job.

Where the honest uncertainty sits: whether Whisper-class models actually beat Apple’s current on-device model on your voice and your vocabulary is an empirical question nobody has published a benchmark for. Test it on your own jargon — that is the only measurement that matters, and it costs you one afternoon and $0.

Appendix: primary sources

OpenWhispr

• Repository and README — https://github.com/OpenWhispr/openwhispr
• Changelog (v1.10.0, 11 Sep 2026) — https://github.com/OpenWhispr/openwhispr/blob/main/CHANGELOG.md
• Docs index — https://docs.openwhispr.com/llms.txt
• How dictation works — https://docs.openwhispr.com/guides/dictation
• Dictating into other apps (paste mechanism) — https://docs.openwhispr.com/platform/dictating-into-other-apps
• Editors, IDEs and terminals — https://docs.openwhispr.com/platform/editors-and-terminals
• Dictation cleanup — https://docs.openwhispr.com/help/dictation/cleanup
• Getting better accuracy — https://docs.openwhispr.com/help/dictation/improve-accuracy
• Custom dictionary — https://docs.openwhispr.com/help/customise/custom-dictionary
• Local models — https://docs.openwhispr.com/guides/local-models
• Cloud vs local — https://docs.openwhispr.com/guides/cloud-vs-local
• System requirements — https://docs.openwhispr.com/platform/system-requirements
• Plans and limits — https://docs.openwhispr.com/help/plans-and-limits
• Where your data goes — https://docs.openwhispr.com/help/privacy/where-your-data-goes
• What is stored and for how long — https://docs.openwhispr.com/help/privacy/what-we-store-and-for-how-long
• Network allowlist — https://github.com/OpenWhispr/openwhispr/blob/main/docs/network-allowlist.md
• Custom ASR shim (self-hosted wire format) — https://github.com/OpenWhispr/openwhispr/tree/main/examples/custom-asr-shim
• Local Whisper setup (RAM and disk table) — https://github.com/OpenWhispr/openwhispr/blob/main/LOCAL_WHISPER_SETUP.md
• MCP server — https://docs.openwhispr.com/integrations/mcp
• Security policy — https://github.com/OpenWhispr/openwhispr/blob/main/SECURITY.md
• Vendor comparisons — https://openwhispr.com/compare
• Apple Dictation comparison (vendor claim) — https://openwhispr.com/compare/apple-dictation

OpenWhispr issues and changelog entries cited

• #462 Whisper hallucinations during silence — https://github.com/OpenWhispr/openwhispr/issues/462
• #1478 Auto-paste fails on non-QWERTY macOS layouts — https://github.com/OpenWhispr/openwhispr/issues/1478
• #2028 Custom cloud STT always uploads audio/webm — https://github.com/OpenWhispr/openwhispr/issues/2028
• Changelog entries for the local-transcribe CLI bridge, the dictionary character caps, and Cohere Transcribe

Vendor pricing and docs

• OpenAI pricing — https://platform.openai.com/docs/pricing
• OpenAI speech-to-text guide (keywords, 224-token prompt limit, gpt-transcribe) — https://platform.openai.com/docs/guides/speech-to-text
• OpenAI realtime transcription — https://platform.openai.com/docs/guides/realtime-transcription
• Groq speech-to-text (per-hour costs) — https://console.groq.com/docs/speech-to-text
• Deepgram pricing — https://deepgram.com/pricing
• AssemblyAI pricing — https://www.assemblyai.com/pricing
• Google Cloud Speech-to-Text pricing — https://cloud.google.com/speech-to-text/pricing
• Gemini API pricing — https://ai.google.dev/gemini-api/docs/pricing
• LiteLLM /audio/transcriptions — https://docs.litellm.ai/docs/audio_transcription

Platform and community

• Apple: Dictate messages and documents on Mac — https://support.apple.com/guide/mac-help/use-dictation-mh40584/mac
• Hacker News coverage of OpenWhispr — https://hn.algolia.com/api/v1/search?query=%22openwhispr%22
• Hacker News: Whispering — https://hn.algolia.com/api/v1/search?query=whispering%20dictation
• Handy — https://github.com/cjpais/Handy
• VoiceInk — https://github.com/Beingpax/VoiceInk
• Wispr Flow pricing — https://wisprflow.ai/pricing
• superwhisper — https://superwhisper.com
• MacWhisper — https://www.macwhisper.com
• Whisper — https://github.com/openai/whisper
• whisper.cpp — https://github.com/ggml-org/whisper.cpp
• sherpa-onnx — https://github.com/k2-fsa/sherpa-onnx