What’s shipped

1. Open Settings › Profiles and turn on “Apply per-app profiles”.
2. Add an app (or pick an existing profile) and choose a Refine preset in its column: Verbatim, Minimal cleanup, Casual, Formal, or Custom.
3. For Custom, a prompt editor appears below the table — write a one-line tone instruction (it still runs behind the same safety guard, so it can't translate your words).
4. Terminals and code editors (Terminal, iTerm2, Warp, VS Code, Xcode, JetBrains, Cursor, Zed, and more) default to verbatim automatically — an explicit preset overrides that.
5. Precedence when more than one applies: an active Mode wins, then the per-app preset, then your global cleanup dial.

1. Requires macOS 26 — the engine only appears there.
2. Open Settings › Models and select Apple SpeechAnalyzer.
3. It runs on-device and auto-punctuates. The file-transcription path (files, meetings, watch folders, history re-transcribe) is the primary, fastest win — roughly 2× Whisper's speed on files.
4. Custom-vocabulary biasing isn't wired for this engine yet; use Parakeet, WhisperKit, or whisper.cpp when you need it.

1. No setup for MCP clients: openwhisp mcp runs in the client's working directory and self-derives the folder name + git branch on each openwhisp_dictate call.
2. A client can also pass explicit context (e.g. recent file names) — explicit values win and merge with the derived ones.
3. Opt out with the OPENWHISP_MCP_WORKSPACE_CONTEXT environment variable (0/false/off/no).
4. From the CLI, pass --cwd, --git-branch, or --terms "a,b,c".
5. Terms bias whichever engine honors it (whisper.cpp, WhisperKit, Apple Speech) and are session-scoped only — never written to your vocabulary file.

1. When a coding agent opens a dictation, speak your answer.
2. Tap your dictation hotkey to end the session immediately and return the transcript — overriding any pending silence/EOU settle wait.
3. A tap during the confirm window re-opens the session so you can append more.
4. Agents can set autoSubmit on the openwhisp_dictate tool to choose submit-immediately vs. wait-for-confirm.

1. Nothing to set up — the app checks for new signed releases automatically and prompts you when one is available.
2. You can also check on demand from Settings → General → Check for Updates.
3. Updates come from a cryptographically signed appcast; the update check is disclosed in the privacy documentation.

1. Open Settings › Models and select “Parakeet Realtime (CoreML)” (badged Experimental).
2. Pick a variant: Unified realtime (default, 0.32 s latency, punctuation), Unified efficient (same accuracy, lower CPU), Unified accurate, EOU ultra light (smallest), or Parakeet Multilingual (~40 languages, auto-detect).
3. The model (~150–600 MB) downloads automatically to Application Support/FluidAudio and is cached; the row shows Not downloaded / Downloading… / installed.
4. Dictate as usual — words stream in as you speak in preview and live-typing modes, and meetings/file jobs automatically use Parakeet's multilingual batch model.

The English variants refuse a fixed non-English dictation language up front (switch to the Multilingual variant or Auto instead of silently mangling it). Parakeet is ASR-only: the translate-to-English toggle doesn't apply, and vocabulary biasing is text-side only.

1. Select the Parakeet engine with the “EOU — ultra light” variant (Settings › Models).
2. Open Settings › Agent Bridge and enable “Stop on end-of-utterance (Parakeet EOU)”.
3. When an agent requests a dictation, speak your answer — the session finishes ~0.6 s after your utterance ends (a new word cancels the pending stop).

Experimental and default-off. Only the EOU variant emits the signal — on any other engine or variant the toggle is inert and the silence auto-stop still applies. Agent sessions only.

1. Start a recording from the OpenWhisp menu bar (Start meeting), and Stop it there when the call ends — the audio is captured on-device as a 16 kHz WAV.
2. Open Settings → Meetings: the new recording appears in the list and is transcribed automatically by your on-device engine (long recordings are chunked, like file transcription).
3. For a summary: with a LOCAL LLM configured it runs automatically once transcription finishes; with a cloud or agent-CLI provider you get a per-meeting “Summarize (transcript leaves this Mac)” confirmation first, so cloud text-sharing is never silent.
4. Use the row’s Actions menu to Re-transcribe, Summarize, Export .md (summary + transcript), or Delete (which also deletes the recording’s audio).

Live now. The summary is map-reduced for long meetings and always demanded in the transcript’s own language — if a small model translates it away, OpenWhisp rejects the summary and keeps the transcript. Speaker attribution (Me vs. Them) now ships too — see the next entry. Cloud summaries only ever run after your explicit confirmation.

1. Start a meeting from the menu bar as usual. OpenWhisp records the mixed audio plus two per-speaker legs (your mic and the system audio), all on-device.
2. While recording, the Meetings pane’s live row shows “You’re talking”, “They’re talking”, “Both”, or “…”, and the menu-bar item shows a matching glyph.
3. When transcription finishes, the pane shows the attributed transcript (Me:/Them: lines). Export .md includes it, and the local summary is built from the labeled transcript so action items can carry the speaker.

Live now. “Them” is everyone on the remote side of the call — system audio is a single mixed stream, so distinguishing individual remote participants (per-person diarization) is a separate follow-on. Attribution is degrade-safe: the mixed recording is unchanged and remains the fallback, and if a leg can’t be captured or transcribed the meeting keeps its plain, un-attributed transcript.

1. Open Settings → Meetings. The new “Summarization model” picker defaults to “Same as cleanup” — existing behavior, no change needed.
2. To use a bigger model just for summaries, pick a provider (On this Mac, Your server, or OpenAI) and optionally a model name; for a self-hosted server you can also set its URL. Leave the model blank to use the server/provider default.
3. Summaries then run through that model: a local summary provider still summarizes automatically after transcription; a cloud one asks for your per-meeting confirmation first, naming the provider the transcript would be sent to.

Live now. Cleanup keeps favoring a small fast model; the summary model runs only when you summarize. Agent-CLI isn't offered for summaries (the summarize path is OpenAI-shape); use the cleanup Agent-CLI provider for dictation as before. The summary is still checked against the transcript's language and rejected if it's translated away.

1. Click the OpenWhisp menu-bar icon → “📝 Scratchpad” (or run open "openwhisp://scratchpad" from any launcher).
2. The floating panel opens on top of your other windows and takes focus. Use “＋ New” for another note; click a note in the left list to switch.
3. With the Scratchpad frontmost, start a dictation (your trigger key) — the text appends into the active note instead of an app. You can also just type.
4. Each note shows a provenance line (e.g. “Dictated 3:14 PM · typed 3:20 PM”); the list is ordered most-recently-touched first. Notes persist locally between launches.

v1 is plain text with a simple multi-note list and per-note dictated/typed timestamps. It's local-only (saved under Application Support). Rich text, tabs, checklists, and image paste are intentionally deferred. Dictation lands in the Scratchpad only while it's the frontmost window; otherwise dictation goes to your focused app as usual.

1. Open Settings › Privacy & Permissions › History.
2. Turn on “Keep transcription history” (needed to associate audio with an entry), then turn on “Keep raw audio for re-transcription”. It's off by default — the audio stays on this Mac and is never uploaded.
3. Set the policy: “Keep at most N clips” and/or “Delete audio + history after N days” (0 = no cap). The sweep runs after each dictation and on launch.
4. Dictate as usual (standard hold-to-talk sessions). Each dictation's audio is saved beside its history entry.
5. On a saved entry, click the re-transcribe (waveform) button to run its audio through your current engine again; the new text replaces the old, and the revert arrow restores the previous words.
6. Turn the toggle off (or use Clear History) to delete every saved clip immediately.

On-device only — audio never leaves your Mac. Retention covers standard hold-to-talk dictations (which produce a single whole-session recording); live-chunk/streaming sessions aren't retained yet. Crash recovery of an interrupted in-progress recording is scaffolded and tested in core but not yet wired to a launch prompt — that's a follow-up; retention, re-transcribe, and the cleanup policy are live now.

1. Insert method: Settings › Output › Insertion → choose “AppleScript keystroke” if paste/direct insert misbehaves in an app (Electron, VNC, non-QWERTY).
2. Per-app override: Settings › Per-App Profiles → add the app and set its “Insert” column (Inherit / Auto / Direct / Paste / AppleScript).
3. Mouse trigger: Settings › Dictation › Activation → “Mouse-button trigger” → pick Middle button or a side button (Mouse 4-10). “Off” disables it.
4. The mouse trigger uses your existing activation style — hold to talk, or tap to lock hands-free.

The AppleScript method never touches the clipboard, and your transcript is always safely escaped into the script (quotes, backslashes, and newlines can't break or inject it) — it falls back to paste if the script can't run (grant Accessibility/Automation permission if prompted) or if the transcript is very long (keystroke types at keyboard speed). The left and right mouse buttons are deliberately not bindable, since they're needed for normal clicking.

1. Open Settings › Dictation › Activation.
2. Click “Record shortcut” and press the key or modifier combo you want (e.g. ⌥⌘R, ⌃⇧Space, or a lone Option). Press Esc to cancel a recording.
3. If the combo would fire on ordinary typing, shadow a system shortcut (⌘Space, ⌘Q…), or clash with your Refine key, a warning appears — pick another.
4. Prefer a built-in? The “Trigger key” menu keeps Fn (Globe) and Control + Space as one-click quick picks.
5. Your custom trigger works in both Hold-to-talk and Hands-free activation styles.

Live in Settings today. A single typing key with no modifier is rejected (it would fire as you type); add a modifier or bind a non-text key (function row, Esc, arrows) instead.

1. Open OpenWhisp Settings and pick the “Insights” tab.
2. Read your lifetime words, speaking speed (WPM), and estimated time saved (the card states the typing-speed assumption behind that estimate).
3. Check your current and longest streaks and which apps you dictate into most.
4. Click “Save share card…” to write a PNG, or “Copy image” to put it on the clipboard — the image is rendered entirely on your Mac; nothing is uploaded.

Time saved is an estimate: it compares your speaking time to typing the same words at 40 wpm (a common average). Your real typing speed will differ. Stats are metadata only — no transcript text is ever stored or shown here, and sessions recorded while a password field was focused are excluded.

1. Grant Accessibility (Settings › Privacy › Permissions) — it's how OpenWhisp reads the focused field.
2. Settings › Privacy › Screen Context → turn on “Read screen context (advanced)”. It's off by default.
3. Click “Add Last-Used App” to allowlist the app you were just typing in. Context is only ever read in apps you list.
4. Dictate as usual. Proper nouns and identifiers on screen bias the on-device transcription so they come out right.
5. For the surrounding-text cleanup boost, keep your AI cleanup provider on Built-in or your own local LLM (Cleanup › AI Cleanup) — with OpenAI or an agent CLI selected, no surrounding text is shared.

Live now. Bias terms only prime the on-device transcription engine (whisper.cpp) and never leave your Mac; the WhisperKit engine ignores the term prompt today (a known pilot gap), so bias terms apply on the whisper.cpp backend. Surrounding text is shared ONLY with a local cleanup provider and never with a cloud/agent-CLI one. Password fields are excluded entirely, and nothing read is written to disk. Vision/OCR of non-text UI is out of scope for this version.

1. Open Settings › Rules and click “Add rule”.
2. Choose when it fires: “After transcribe” (the raw transcript, pre-refine) or “After refine” (the final text that gets typed).
3. Set the match: Always, Exact, Starts with, Contains, or Regex — optionally scope it to one app by bundle ID (e.g. com.apple.Notes).
4. Add actions in order: Insert snippet, Open URL (use {{text}} for the transcript), Run script, Run Shortcut, POST webhook, or Append to file.
5. Save. Rules run automatically on your next matching dictation.
6. To run a rule on agent-bridge sessions too, set its “Sessions” to “Agent only” or “Both” — it's dictation-only by default so an agent's transcript never leaves your machine unless you opt in.

Live in Settings today. Actions are fail-open: a failing or slow action is skipped and never affects the normal insert. Scripts and Shortcuts receive the transcript on stdin (never interpolated into a command line); webhooks receive it as JSON; an Open-URL template's {{text}} is percent-encoded. Regex is guarded against catastrophic backtracking. The old Output › Script toggle still works and is unchanged.

1. Open Settings › File Transcription.
2. Click “Add audio or video files…” and pick one or more media files — they queue up and transcribe one at a time on your current engine.
3. Watch each row move through Queued → Loading model → Transcribing → Done; long files are chunked for you.
4. On a finished row, use Export to save .txt, .srt, or .vtt (SRT/VTT carry chunk-level timestamps).
5. Optional: “Add a watch folder…” so any new media dropped into it is transcribed automatically (files still copying are picked up once they settle).

Timestamps for .srt/.vtt are chunk-level (each cue spans a decode window), since the local engines surface plain text per chunk — finer per-word timing is a future engine-seam upgrade. The optional LLM “Enhance” pass over finished transcripts is present as a toggle but only runs when an LLM is configured.

1. Settings › Dictation › Activation › “Activation style” → “Hands-free (tap to lock)”. (Or leave it on “Hold to talk” and double-tap the trigger key to lock the mic open for a single session.)
2. Tap your trigger key (Fn or Control + Space) — the overlay shows a lock badge and “Hands-free — tap key or Esc to stop”.
3. Speak with your hands free; the mic stays live.
4. Tap the trigger key again, or press Esc, to stop. Esc discards the session; a stop tap delivers it.
5. Optional safety net: “Auto-stop after long silence” (on by default) ends a locked session after a long quiet stretch so a forgotten one can't record forever.

Live in Settings today. Hold-to-talk remains the default and is unchanged. The double-tap gesture reaches lock even without changing the setting; a normal pause to think won't trip the silence safety auto-stop (its hangover is deliberately long).

1. Make sure OpenWhisp is installed (if it isn't running, macOS launches it and delivers the URL on start).
2. From any launcher or a terminal: open "openwhisp://record" to start/stop dictation, open "openwhisp://paste-last-result" to paste the last result, or open "openwhisp://refine?instruction=make%20it%20formal" to rewrite the last result onto your clipboard.
3. Chain verbs in one URL — open "openwhisp://?switch-mode=email&record" — they run in order, all-or-nothing.
4. For a one-key setup, add the Raycast Script Commands or the Alfred recipe from the integrations/ folder and bind them to hotkeys.

record, refine, paste-last-result, switch-mode, and activate-mode all work today. switch-mode?key=… queues a Mode for your next dictation; activate-mode?key=… sets it as the sticky active Mode without recording (MAK-39 wired the named-mode registry). An unknown key is logged as a miss rather than silently pinning a phantom mode. See integrations/README.md for the full grammar.

1. Settings › Modes → “+” to add a Mode. Give it a name, a key (it's normalized to lowercase-with-hyphens), a tone, and optionally an AI instruction, icon, or language/output/AI-cleanup overrides.
2. Set your “Active mode” at the top of the pane — it governs your next dictations until you change it (or pick “None” for global settings).
3. Bind a Mode to an app (its bundle ID) and turn on per-app modes to have it auto-activate when you dictate into that app.
4. From a launcher: open "openwhisp://switch-mode?key=email" to use a Mode for just your next dictation, or "openwhisp://activate-mode?key=email" to make it the sticky active Mode.
5. Share a Mode by exporting your config (it now includes Modes) or shipping it in a config pack.

The tone/instruction, language/output/AI-cleanup overrides, LLM-model override, active-mode picker, app auto-activation, and both URL verbs are live. Two pieces are deferred honestly: a per-Mode transcription-model swap is carried and round-trips but is NOT yet applied to the live engine mid-session, and per-Mode global hotkeys are not wired (key-based invocation via the URL scheme + picker is the shipped path). The old Per-App Profiles pane still exists; Modes are seeded from your profiles on first launch.

1. Turn it on: Settings › Cleanup › Formatting › “Enable file tagging in code editors” (off by default).
2. Dictate into Cursor or Windsurf and say the filename the way you'd read it: the name, the word “dot”, then the extension spelled out letter-by-letter (“main dot t s”) or as a whole word (“main dot swift”).
3. Or lead with “at” for a bare mention: “at main” → @main.
4. The @-mention lands in your editor and its file autocomplete disambiguates the rest.

Works in Cursor and Windsurf when the Settings toggle is on — OpenWhisp only converts spoken filenames while one of those editors is frontmost, so ordinary dictation everywhere else (chat, docs) is never touched. Off by default. An optional AX read of the open workspace to auto-pick the exact extension is still a stretch goal.

1. Open Settings › Cleanup › AI Model and set Provider to “Agent CLI (Claude / Codex)”.
2. Pick a preset — Claude Code (claude -p) or Codex (codex exec) — or choose Custom and enter any command that reads stdin and writes the cleaned text to stdout.
3. Turn on “Improve every dictation automatically” below (or use Refine on demand). OpenWhisp feeds your transcript to the CLI on stdin — never on the command line, so nothing you say can be interpreted as a command — and uses its output as the refined text.
4. If the CLI is missing, errors, times out, or returns nothing, OpenWhisp keeps your original words — you never lose a dictation.

Reuses your locally-installed CLI and its own login — no API key needed here. Where your text goes depends on which CLI you pick (a cloud coding agent, or a fully local model).

1. Build a Shortcut in Shortcuts.app that starts with “Receive input” (text) and does whatever you want with it.
2. Open Settings › Output › Output target and choose Shortcut, then pick your Shortcut from the list (or type its name and Refresh).
3. Dictate as usual — OpenWhisp runs `shortcuts run <name>` with your transcript on stdin and hands the text off.

Live now. Runs on the final transcript only (live-typing always goes to the focused app). On any error or timeout it fails open to normal insertion, so your words are never lost.

1. Open Settings › Cleanup › Automatic Cleanup and pick a level on the dial: None (verbatim, no AI pass), Low (fixes caps, punctuation, spelling), Medium (also removes fillers and lightly rephrases), or High (also resolves spoken self-corrections like “3, no wait, 4” → “4”).
2. Dictate as usual — the level you chose is applied automatically to each final transcript. None skips the AI entirely.
3. In Settings › Privacy › History, click the revert (↺) button next to any entry the AI reshaped to swap the cleaned text back to your raw words — the originals are copied to your clipboard.

Live now. The dial is the single source of truth for AI cleanup — the old on/off “Improve every dictation” toggle (tray + onboarding) now just reflects it. Higher levels trade literal fidelity for polish; the revert button appears only when the AI actually changed your words. Revert currently covers the standard preview and insert-at-end dictation modes (not the live-streaming per-chunk mode, which pastes as it types). It lives in History and, right after a dictation lands, in the post-dictation overlay — a one-tap “Revert to original” pill that swaps the cleaned text back to your raw words in place when it safely can, and otherwise leaves them on the clipboard for ⌘V.

1. Set Settings › Output › Delivery to “Preview, then insert” (the mode that holds the text on-screen until you release the key).
2. Leave “Spoken edit commands” on in that same Delivery section (it’s on by default).
3. Dictate as usual, then pause and say a command on its own — “scratch that” drops the last thing you said, “undo” brings it back.
4. Release the key: the edited text is what gets inserted.

Works in Preview mode (the text is held until release, so an edit can still change it). A command is recognized only when the WHOLE phrase is spoken on its own — say it as its own short utterance, with a pause, so the recognizer punctuates it as a separate sentence. A command buried inside a longer phrase (“finish the report scratch that let me redo”) is left as plain text on purpose, so ordinary speech like “scratch the surface” is never eaten. Parser is case- and punctuation-tolerant (including … and curly quotes).

1. Open Settings › Cleanup › Vocabulary. Your Substitutions open sorted starred-first then most-used, each with a 'used N×' count; 'Sort by use' re-sorts on demand (rows stay put while you type so nothing jumps under the cursor).
2. Click the star on any rule to keep it at the top on the next sort.
3. Dictate into a normal text field, then immediately type over a single misheard word to fix it (e.g. 'kubernetis' → 'kubernetes').
4. OpenWhisp adds that fix to 'Suggested corrections' at the top of the Vocabulary section — click Add to make it a rule, or Dismiss to never be offered it again.
5. Turn the whole capture off with 'Learn corrections as I type over them' if you don't want it.

Live today: star + usage sort + per-rule usage counts, and the full accept/dismiss flow — an accepted suggestion becomes a real substitution that rewrites future transcripts, and nothing is ever added silently. How a suggestion appears today: after an insert made via the Accessibility path, if you type over ONE word within a couple of seconds while the SAME field stays focused and its text is readable via Accessibility, that edit is captured and run through the conservative learner (single-word casing/spelling fixes only). Deferred: capture is a single short-delay re-read, not continuous observation — corrections you make after that window, in paste-only or some web/Electron fields (where the field text isn't Accessibility-readable), or that span multiple words, aren't captured yet. You can always add those rules by hand in the same list.

1. In Settings › Cleanup › Formatting, turn on the groups you want — Numbers and years, Currency, Spoken lists, Markdown commands. They're independent and off by default.
2. Dictate naturally — the rules rewrite structure locally, on-device, no LLM.

Live now. Each group is off by default so it never touches ordinary prose until you turn it on.

1. Open Settings › Output › Output target and pick a destination: Focused app (default), File, Shortcut, or Webhook.
2. Fill in that target's details (a file path, a Shortcut, or a webhook URL).
3. Dictate as usual — the final text goes to your chosen target. If it isn't configured or a delivery fails, your words still land in the focused app — never dropped.

Live now. The choice is global (one destination for all apps) for this version. Live-typing (“Type live as you speak”) always goes to the focused app; only the final transcript is routed.

1. Open Settings › Output › Output target and choose File, then Choose… the file to write to (any .md or .txt — e.g. your vault's daily note).
2. Optionally set a heading template with {{date}}, {{time}}, or {{datetime}} tokens (e.g. "## {{datetime}}") to stamp each entry.
3. Choose Append (add each dictation to the end, blank-line separated) or Overwrite (keep only the latest).
4. Dictate — the final text is written to the file; live partials are ignored so you get one clean entry.

Live now. All local; if the file can't be written, your words still land in the focused app — never dropped.

1. Open Settings › Output › Output target and choose Webhook, then enter your URL and add any headers your endpoint needs (e.g. an Authorization token).
2. Dictate as usual — OpenWhisp POSTs { text, language, appBundleID, timestamp } as JSON to your URL.
3. If the POST fails (non-2xx, network error, or timeout), the same text is typed into the focused app instead — you never lose it.

Live now. Content-Type: application/json is always set; your custom headers are applied verbatim, with a short timeout so a slow endpoint fails open quickly.

1. Open Settings › Dictation › Microphone.
2. Turn on “Quiet-dictation mode”. (Leave “Auto-boost quiet microphone” on too — quiet mode is the stronger boost curve.)
3. Position the mic within a few inches of your mouth and pick a quiet spot — the boost is aggressive, so it will also lift background noise.
4. Dictate softly or whisper; the lowered speech threshold keeps quiet words from being treated as silence.

v1 is a preprocessing preset — a stronger auto-gain plus whisper-friendly VAD/silence thresholds — not a custom whisper model. The boost never clips (hard-limited), and it won't amplify near-silence into hiss. In a noisy room the aggressive gain can raise background noise, so quiet mode is best close to the mic.

1. Click the OpenWhisp menu-bar icon and choose “Tips & Commands…” to open the cheat sheet — grouped by voice editing, hands-free, spoken formatting, file @-mentions, AI cleanup, output targets, launcher automation, and the self-learning dictionary, each row with its real Settings path.
2. First-run onboarding now closes with a “What's next” card pointing at 2–3 features to try (voice editing, hands-free mode, the AI cleanup dial).
3. For roughly your first ten dictations, the overlay shows a small rotating tip while you speak; click its × to dismiss one forever.

Live now. The overlay hints are calm and ambient — they only appear in a quiet listening moment of an ordinary dictation, never during an agent question, a refine, a hands-free-locked session, or while a transcript or revert control is on screen, and they auto-off after the first-run window. Every tip and Settings path in the cheat sheet is checked against what the running app actually does.