The why, the engine, and the fine print
Hold the dictation key, speak, let go. Boswell types what you said into whatever app your cursor is in, and the audio never leaves your Mac. That's the whole feature. This post is the longer story: why we built it, what makes it quick, the engine underneath, and the fine print.
Why we built this
The push came from a benchmark. Inscribe published numbers on SpeechAnalyzer, the speech-to-text engine Apple shipped with macOS 26, and the results were hard to ignore: a 2.12% word error rate on clean audio, ahead of the Whisper models that most local transcription tools are built on. Apple had quietly put a best-in-class speech engine into the operating system itself, running on the Neural Engine, free to call.
Then we looked around at the dictation market and saw what you'd expect from a market that hadn't absorbed that news. Most dictation utilities still record your voice, send it to a cloud API, and charge you monthly for the round trip. The audio leaves your machine so a server can do work your Mac is now better at doing itself.
We were in an unusual position to act on that. Boswell already existed as a meeting recorder: the on-device transcription pipeline, the permissions handling, the menu-bar app were all built and shipping. The distance between "transcribes your meetings" and "types what you say, anywhere" was one feature, not one product. So we built it: a global hotkey, streaming transcription into whatever app has focus, and push-to-talk behavior so nothing listens until you ask.
The features
System-wide. It works wherever your cursor is: your editor, your browser, your email, a commit message. No special text box, no separate window to paste from.
On-device. Transcription runs on your Mac's Neural Engine. It needs no network connection, so it works the same on a plane as at your desk.
Push to talk. Hold the key, speak, release. Nothing listens until you ask it to.
Why it feels fast
Speed here is mostly about what we left out. There is no upload step, no queue on someone's server, no round trip before text appears. The engine transcribes the audio stream while you're still talking, so words land in the target app almost as you say them, and releasing the key finalizes a sentence rather than starting a job.
Running on the Neural Engine matters too: dictation doesn't fight your compile or your browser tabs for CPU, so it stays quick on a busy machine. Fast isn't a benchmark claim here. It's the difference between dictation you actually use for every message and dictation you demo once and forget.
The engine
Boswell dictates with SpeechAnalyzer, introduced with macOS 26. Per Inscribe's benchmark, it's a meaningful accuracy jump over the Whisper-family models most local dictation tools ship:
| Engine | WER (clean) | WER (noisy) |
|---|---|---|
| Apple SpeechAnalyzer | 2.12% | 4.56% |
| Whisper Small | 3.74% | 7.95% |
| Whisper Base | 5.42% | 12.51% |
Lower is better; WER is word error rate. Benchmark data published by Inscribe.
The appeal goes beyond the error rate. SpeechAnalyzer is a native API, it streams token by token, and it runs on the Neural Engine without bundling a multi-gigabyte model inside the app or sending audio anywhere. It's also why Boswell requires Apple Silicon and macOS 26 (Tahoe): the engine is the requirement.
The fine print
Dictation does not have a server. The honest details:
- Your voice is transcribed on the Mac you're speaking to. Audio is never uploaded, and nothing you dictate touches the network.
- Nothing records until you hold the key. Release it and the microphone is done.
- Permissions. Boswell asks for microphone access and the macOS Accessibility permission, which is what lets it type into other apps on your behalf. Both are standard system prompts you can revoke in System Settings at any time.
- An account is only needed for Pro billing. The transcription itself never depends on being signed in.
The full policy is at meetboswell.com/privacy.
Built with Claude Code
The Boswell team builds with Claude Code doing a large share of the typing, and dictation was no exception. The setup is deliberately boring: every change rides a ticket, lands through tests and a lint baseline, and merges fast-forward-only. The agent works from a written instructions file, per-topic rules, and snapshot tests that fail loudly when it draws the wrong pixels.
A few lessons from building this way:
- Write the outer loop down. Agents are excellent at the inner loop when what to build, what "done" means, and what never to touch are in a file instead of in someone's head.
- Make failure loud. Snapshot tests and fail-loud build scripts catch an agent's confident mistakes far earlier than review does.
- Test on the real thing. A dictation feature has to be verified by actually holding the key and talking, on the Mac, in real apps. Simulated confidence doesn't survive first contact with a text field.
- Keep the boring path. Small commits, one ticket per branch, fast-forward merges only. Predictable process is what makes agent speed safe to use.
- The human keeps the wheel. The agent proposes; the team reads, tests, and decides what ships.
Credits
Thanks to Inscribe for publishing the benchmark that pushed this feature up the roadmap, and to Apple's speech team for putting an engine this good in the operating system. Boswell's job was to get out of its way.