Automating Meeting Notes: Dictate, Summarize, and Extract Action Items Locally on Mac

You can automate meeting notes entirely on your Mac by combining on-device dictation, local transcript cleanup, and a locally running LLM to extract summaries and action items. No audio leaves your machine. No third-party bot joins your call. The full pipeline (capture, clean, extract) takes under three minutes of processing for a typical hour-long meeting on an M-series Mac, and the output is a structured note with a summary, key decisions, and action items complete with owners, deadlines, and priorities.

I've been running this workflow for six months across product standups, 1:1s, and client calls. The setup took me about 30 minutes. The result: I spend zero time writing meeting notes after the meeting ends, and I've stopped worrying about whether a cloud service is training on my confidential conversations.

Why Most Meeting Note Workflows Leak Your Confidential Conversations

Popular AI note-takers like Otter.ai, Fireflies.ai, and Grain work by uploading your full meeting audio to cloud servers. The transcription and summarization happen on their infrastructure, not yours. Even products that market "enterprise-grade security" typically store your audio and transcripts on third-party cloud infrastructure for days or weeks to enable search, playback, and model improvement.

This is not a theoretical concern. A 2025 Cisco Hybrid Work survey found that 63% of knowledge workers feel uncomfortable with AI bots joining their calls, and 41% have actively blocked or removed meeting assistants added by colleagues. In regulated industries (healthcare, finance, legal), uploading meeting audio to a third party can create compliance liability that no privacy policy disclaimer can fully offset.

The alternative is straightforward: run the entire pipeline locally. Capture speech on your Mac using on-device speech-to-text. Clean the transcript with on-device AI. Extract structured data with a local LLM. Every byte of audio, every word of transcript, every action item stays on your hardware. No API calls, no cloud uploads, no data retention policies to audit.

The Three-Stage Pipeline: Capture, Transcribe, Extract

The workflow breaks into three discrete stages, each with a clear input, output, and processing step. Here's the full map:

On an M2 Pro or later Mac, stages 2 and 3 together finish in under 90 seconds for a typical one-hour meeting transcript. The total "post-meeting" effort is clicking two buttons and reviewing the output, which is usually about 2 minutes of your time.

The key insight is that each stage produces a standalone artifact. If the extraction step misses something, you still have the cleaned transcript to search. If the cleanup is too aggressive, you still have the raw transcript with timestamps to check the original phrasing.

Setting Up Live Dictation for Meetings on macOS

The capture stage is the foundation. You have two approaches depending on whether you're dictating your own notes or capturing everything said in the meeting.

For dictating your own notes: Open Auditory before the meeting, select the Whisper "medium" model for real-time speed, and dictate your observations, summaries, and notes as the meeting happens. This works well for 1:1s and small meetings where you're an active participant. You're narrating key points rather than capturing verbatim audio.

For capturing full meeting audio: Route system audio through a virtual audio device like BlackHole (free) or Loopback ($99) so that Auditory receives the combined output of your Zoom, Teams, or Google Meet call. Select the Whisper "large-v3" model for post-meeting processing to get the highest accuracy. This approach captures everything but requires more cleanup.

For keyboard shortcuts, I set up a global hotkey (Ctrl+Shift+M) to toggle Auditory's recording. During meetings, I also use voice markers: I say "DECISION" or "ACTION" before important items so they're easier to find in the transcript later. This takes a few meetings to become habit, but it dramatically improves extraction accuracy in stage 3.

If you're evaluating which Whisper model size fits your hardware, our guide to [on-device AI performance on Apple Silicon](/blog/on-device-ai-apple-silicon) covers the benchmarks in detail.

Cleaning Raw Transcripts Without Cloud APIs

Raw speech transcripts are messy. In my experience, a raw meeting transcript is typically 30-40% longer than it needs to be. Filler words ("um," "uh," "you know," "like," "so basically"), false starts ("I think we should, well actually, let me rephrase"), and verbal repetitions ("we need to, we need to update the dashboard") add bulk without adding meaning.

On-device AI cleanup handles this in a single pass. Auditory's filler removal and grammar correction runs entirely on your Mac's Neural Engine, producing a polished transcript that reads like written language rather than spoken language.

Here's what the difference looks like for a real segment:

Raw transcript:

> "So um basically what we need to do is, well, I think we need to, we need to update the dashboard by Friday, right? Like the, the metrics page specifically. And uh John you were gonna, you were gonna look into the API rate limiting thing, right?"

Cleaned transcript:

> "We need to update the dashboard by Friday, specifically the metrics page. John, you were going to look into the API rate limiting issue."

That's a 52% reduction in word count with zero loss of meaning. Multiply that across a 60-minute meeting and you're looking at a transcript that takes 5 minutes to read instead of 12.

The cleanup stage also adds paragraph breaks at natural topic transitions and, if you used voice markers ("DECISION," "ACTION"), preserves those as section headers in the output. The result is a scannable document, not a wall of text.

Extracting Summaries and Action Items with a Local LLM

This is where the workflow becomes genuinely powerful. A cleaned transcript is useful, but a structured extraction (summary, decisions, action items with owners and deadlines) is what actually replaces manual note-taking.

I use Ollama running locally on my Mac with the Llama 3.1 8B model. The setup takes about 10 minutes: install Ollama, pull the model, and you're ready.

Here's the exact prompt template I use:

```text

You are a meeting notes assistant. Given the transcript below, extract:

1. 1.SUMMARY: A 3-sentence summary of the meeting's purpose and outcome.
2. 2.DECISIONS: A bullet list of decisions made, with brief context.
3. 3.ACTION_ITEMS: A JSON array where each item has:

- "task": description of the action

- "owner": person responsible (or "Unassigned")

- "deadline": stated deadline (or "Not specified")

- "priority": "high", "medium", or "low" based on urgency signals

Respond ONLY with valid JSON. Do not add commentary.

TRANSCRIPT:

{paste cleaned transcript here}

```

Two critical settings make this reliable. First, set temperature to 0.1 (not 0.0, which can cause repetition loops in some models). This keeps the output deterministic and prevents the LLM from inventing action items that were never discussed. Second, use structured JSON output mode if your local LLM runner supports it. Ollama's `format: json` flag constrains the output to valid JSON, which prevents the model from adding conversational filler around the structured data.

Here's how the main local LLM options compare for this specific task:

For most teams, Llama 3.1 8B at Q4 quantization is the right choice. It fits comfortably in 16 GB of RAM alongside the rest of your apps, and the extraction quality is high enough that I rarely need to edit the output.

Organizing Action Items into Your Task System

The JSON output from stage 3 is machine-readable, which means you can pipe it directly into your task manager without manual re-entry.

Here's a short Shortcuts automation (macOS Shortcuts app) that creates Apple Reminders from the extracted action items:

```javascript

// JXA script for macOS Shortcuts

const app = Application("Reminders");

const list = app.lists.byName("Meeting Actions");

const items = JSON.parse(inputJSON).ACTION_ITEMS;

items.forEach(item => {

const reminder = app.Reminder({

name: `[${item.priority.toUpperCase()}] ${item.task}`,

body: `Owner: ${item.owner}\nSource: ${meetingName}`,

dueDate: item.deadline !== "Not specified"

? new Date(item.deadline)

: null

});

list.reminders.push(reminder);

});

```

This script runs entirely on your Mac. No server, no API key, no sync service involved in the creation step (your task app syncs separately, on its own terms).

For naming conventions, I prefix every meeting-sourced task with the meeting name in brackets: `[Product Standup] Update dashboard metrics page`. This makes it trivial to filter all tasks that came from a specific recurring meeting. I also tag them with `#meeting-action` so I can pull up a list of all meeting commitments across all projects.

For long-term storage, I keep each meeting's full output (transcript, summary, and action items) in a single Obsidian note using a consistent template. The filename format is `YYYY-MM-DD Meeting Name.md`. Six months in, I have a searchable archive of every meeting I've attended, and it takes up about 400 MB on disk, all local.

What This Workflow Looks Like in Practice: A Real Thursday Standup

Let me walk through last Thursday's product standup to make this concrete.

9:00 AM: Meeting starts. I hit Ctrl+Shift+M to start Auditory's recording. Five people on the Zoom call, audio routed through BlackHole. I'm using the medium model for live transcription so I can glance at the transcript during the meeting.

9:25 AM: Meeting ends. I stop recording. Raw transcript: 4,847 words, full of filler, some crosstalk artifacts, and three spots where someone's name was slightly garbled.

9:25:18 AM: I run the cleanup pass. 18 seconds later: cleaned transcript at 2,941 words. Filler removed, grammar fixed, paragraph breaks added at topic transitions.

9:25:30 AM: I paste the cleaned transcript into my Ollama prompt. 14 seconds later: a JSON object with a 3-sentence summary, 4 decisions, and 7 action items, each with an owner, deadline, and priority.

9:25:50 AM: I run my Shortcuts automation. 7 new reminders appear in Apple Reminders with correct due dates and priority tags.

Total post-meeting time: 50 seconds of processing, 2 minutes of review. Compare that to the 15-20 minutes I used to spend typing up notes and manually creating tasks.

The common failure modes are worth addressing. Crosstalk (two people talking at once) produces garbled segments, but the cleanup pass usually recovers the meaning from context. Acronyms need to be in your vocabulary list or they'll be transcribed phonetically. Off-topic tangents sometimes generate spurious action items, which is why I spend 2 minutes reviewing the extraction output rather than blindly piping it into my task system.

Frequently Asked Questions

Does this work with virtual meetings or only in-person?

Both. For virtual meetings (Zoom, Teams, Meet), route system audio through BlackHole or Loopback. For in-person meetings, use your Mac's built-in microphone or an external mic. The transcription pipeline is identical either way.

What if I have less than 16 GB of RAM?

Use Phi-3 Mini (3.8B parameters) for extraction. It requires only 2.4 GB of RAM and handles short to medium meetings well. For transcription, the Whisper medium model works on 8 GB machines without issues. See our [Whisper model benchmarks guide](/blog/whisper-model-benchmarks-apple-silicon) for detailed RAM and speed comparisons.

Can this handle non-English meetings?

Yes. Whisper supports 100+ languages with varying accuracy levels. For major languages (Spanish, French, German, Mandarin, Japanese), accuracy is within 2-3 percentage points of English. The extraction LLM should match the transcript language, so select a multilingual model variant.

What about speaker identification?

Whisper alone doesn't do speaker diarization. If you need per-speaker attribution, you can add a local diarization step using pyannote.audio before cleanup. For most meeting notes, though, context clues in the transcript ("John mentioned..." or your voice markers) are sufficient.

Your First Automated Meeting in 30 Minutes

Here's exactly what to install and configure before your next meeting:

1. 1.Install Auditory from auditoryapp.com. Select the Whisper medium model for live use.
2. 2.Install BlackHole (free, github.com/ExistentialAudio/BlackHole) if you need to capture system audio from virtual meetings.
3. 3.Create a Multi-Output Device in macOS Audio MIDI Setup that combines your speakers and BlackHole, so you hear the meeting and Auditory receives the audio simultaneously.
4. 4.Install Ollama (ollama.com) and pull the Llama 3.1 8B model: `ollama pull llama3.1:8b`.
5. 5.Save the extraction prompt from the section above as a text file you can quickly paste from.
6. 6.Set up a keyboard shortcut (System Settings > Keyboard > Shortcuts) to toggle Auditory recording.
7. 7.Create a "Meeting Actions" list in Apple Reminders (or your preferred task app).
8. 8.Run a test with a 5-minute practice recording before your real meeting.

The one metric to track weekly: minutes spent on post-meeting note processing. Before this workflow, I averaged 12-15 minutes per meeting. Now it's under 3 minutes, including review time. Over 8 meetings a week, that's 80+ minutes reclaimed.

And every word of every meeting stays on your Mac. No cloud upload, no third-party storage, no data retention policy to worry about. Your conversations are yours.