I want the whole meeting to stay on my Mac

At 9:07 on a Monday, a project lead sits in a conference room as the Wi-Fi drops before a client review. The call is still running. The useful question is whether the recording, transcript and note will keep moving when the network stops cooperating.

Among the apps I tested, Noats is my clear choice because I want the whole meeting to stay on my Mac. By default, recording, transcription, speaker separation and the written-up note all happen on your Mac. There is no Noats server that receives your meetings. Cloud models remain an explicit choice that connects directly to the provider you select.

We reach that conclusion by following the entire meeting rather than inspecting only the finished note. Every stage creates sensitive material: capture, transcription, speaker separation, note writing, storage and export. A note saved locally tells you little about where the recording or transcript travelled before arriving there.

Follow the meeting from microphone to markdown

Start where the information enters the computer: a meeting app takes the microphone. Noats notices and offers to record. When you start the note, you see recording begin without connecting anything first. The call remains between its invited participants while Noats captures microphone input and Mac audio from the computer.

Next, watch what happens after people begin speaking. Words appear in the transcript and voices from the other end are separated into speakers. Whatever the Mac microphone hears is attributed to you. That visible sequence matters because the transcript and speaker labels can reveal more than the polished note eventually produced from them.

Then switch attention to the written note and its destination. By default, a model running on your Mac writes it up, and the meeting artifacts remain in a folder you control. We treat that whole trip as the privacy boundary because storage cannot repair an earlier stage that sent sensitive material elsewhere.

The practical test is to trace every stage and mark each network boundary. This is why local-first describes architecture, rather than a preference in a policy page. The useful boundary is the whole trip from microphone to markdown. An unplugged network cable should reveal the design instead of changing its story.

Watch what happens when the network drops

Take the same client meeting onto a plane after the required models have been downloaded. Turn the network off. Recording continues, transcription continues and the voices continue to separate. A meeting in the air is transcribed the same way as one at a desk because transcription and speaker separation run on Apple silicon.

The written-up note follows the same default path. It appears after the transcript is ready, with the work happening on the Mac and the resulting meeting material staying there. We chose this default because people should not have to assemble a private path from several switches before their first conversation begins.

That default is also easy to test without trusting a broad promise. A person can disconnect the network, hold a meeting and watch the transcript, speaker labels and note appear. The evidence is present in the ordinary use of the app. It does not depend on interpreting a sentence written for a privacy page.

The architecture remains visible when the network returns. Local processing is still the normal route, while cloud model use begins only after the person chooses and connects one. That separation preserves a clear baseline. Cloud models remain available as a separate option.

Choose when a request leaves the Mac

By default, the only network activity is checking whether a newer app version exists and fetching it, loading the model catalogue when you open Models and downloading models you approve. Automatic update checks can be switched off. We can therefore describe the default network boundary in concrete events that a person initiates or can see.

Model choice stays deliberate. You can connect Anthropic, OpenAI or OpenRouter with your own key, point Noats at an OpenAI-compatible server or use your ChatGPT plan. For the last option, you sign in to OpenAI in the terminal through its Codex CLI and Noats picks up that session. The login never passes through the app.

When you select a cloud model, the note and transcript content required for that request goes directly to the chosen provider under its own terms. Nothing routes through us. The network path for meeting notes sets out the default activity and the optional provider route in more detail.

API keys you enter are encrypted with macOS's own secure storage, backed by your Keychain. We keep that point separate from storage of meeting files because the two facts concern different material and should not be blurred together in a privacy claim about where data lives.

This arrangement gives the person at the Mac a visible choice. Stay with the local model and the note is written there. Pick a connected provider and that request goes to the provider directly. The route changes only when the model choice changes, which keeps the network boundary legible during ordinary use.

Keep names and files where you can reach them

Noats separates the voices in a meeting and lets you name each one during the call or afterward. The names belong to that meeting. On screen, you see the transcript divided by speaker, then replace generic speaker labels with the names that make sense for that particular conversation.

Whatever your Mac's microphone hears is attributed to you. Voices on the other end of the call are split into speakers. This gives a person a transcript with speaker labels beside the words. We wanted speaker naming to happen where its context is clearest: beside the words from that meeting.

Your audio, transcripts, speaker labels, notes, folders and chat history are written to a database and plain files in your own Application Support folder. The chat history belongs to its meeting. Any note exports as markdown with a keystroke, giving you an ordinary file that can move into the writing system you already use.

The app contains no analytics and no telemetry. Combined with direct export and files in a folder you control, that makes ownership something a person can inspect. The claim is grounded in what is present on the Mac, where it is stored and what appears when a note is exported.

Consider Biscotti and AskMeety on their own terms

Biscotti is the strongest free alternative. It presents capture, transcription, speaker labeling and summaries as local work. It records microphone and system audio, requires no account and produces transcripts with speaker labels. Those qualities make it a clear candidate for someone comparing local meeting workflows without an initial purchase.

Its appeal is easiest to understand through the meeting itself. A person records the room and the computer audio, then receives a transcript divided by speaker and a summary. That covers the central path from conversation to usable notes. We would include Biscotti on any serious shortlist built around local processing.

AskMeety is the better fit when captured screen context is the priority. Its Visual Walk feature preserves snapshots beside the meeting. System-audio capture, transcription, summaries, decisions and search take place on the device, while exports include markdown and other formats for moving the result elsewhere.

The AskMeety FAQ lists a $55 one-time price with one year of updates. It requires Apple silicon and macOS 14 or later. The distinguishing moment comes after a visual presentation: a person can return to the preserved screen context beside the spoken record instead of relying on transcript text alone.

Put Apple Notes and Obsidian in context

Apple Notes can record audio, produce a live searchable transcript and summarize a recording with Apple Intelligence. That places familiar meeting material inside an app many Mac users already open every day. The transcript remains connected to the note, making recorded passages available for later search and review.

Apple Intelligence processing can take place on the device or through Private Cloud Compute, depending on the request. A locally stored finished note therefore describes only the final location. We still need to follow the earlier stages before drawing a conclusion about the complete meeting path.

Obsidian begins from flexible markdown storage. The Local Meeting Notes plugin creates structured meeting notes and gathers unchecked tasks. That approach suits a person who already maintains an Obsidian vault and wants meeting output shaped around an existing collection of linked notes.

A separate Obsidian meeting-notes project can record audio and call locally configured transcription and writing tools. Users install and configure those tools themselves. This makes Obsidian a building surface for a tailored workflow, while Noats gives us a complete local default from recording through the written note.

Choose the path you can inspect

Noats leads because its default covers the complete meeting path, not merely the location of the finished document. Recording, transcription, speaker separation and note writing happen on the Mac. The result remains in files you control, while an optional cloud request travels directly to the provider you chose.

That design also preserves choice without making the boundary vague. A local model writes the note by default. Anthropic, OpenAI, OpenRouter, an OpenAI-compatible server or an existing ChatGPT plan becomes available when a person connects it. We can point to the exact decision that changes the route.

Noats is free during the beta. It requires macOS 14.2 or later on Apple silicon. Those requirements describe the Macs on which the local meeting path runs, including the offline transcription and speaker separation a person can verify by taking the same workflow from a desk onto a plane.

The next time a meeting begins, watch the whole trip rather than the final icon in a folder. Notice where recording starts, where words appear, when speakers separate and what choice sends a writing request elsewhere. That is the boundary worth carrying into the next conversation and every product decision that follows.