Productivity

How to Convert Raw Meeting Notes Into Structured Summaries on Mac

Published on September 02, 2026 • 6 min read

Meetings generate a torrent of spoken information that quickly devolves into a chaotic collection of audio files, scribbled notes, and fragmented action items. The real productivity gain comes when that raw material is transformed into a clean, searchable, and actionable summary that can be shared with stakeholders without the need for manual transcription. On macOS, the combination of built‑in speech services, powerful terminal utilities, and the emerging autonomous AI platform Purple (https://1into1.com) makes it possible to automate the entire pipeline—from voice capture to polished document—using only voice commands or a few keystrokes. This guide walks you through every technical step, explains why each tool matters, and equips you with a repeatable workflow that can be embedded in any team’s knowledge‑management system.

Understanding the Voice‑to‑Text Pipeline on macOS

Why raw audio is not enough

Audio recordings preserve the nuance of tone and inflection, but they are unusable for indexing, searching, or assigning tasks. Human listeners must pause, rewind, and interpret, which introduces latency and error. Converting speech to text creates a machine‑readable artifact that can be parsed by natural‑language models, filtered with grep or awk, and fed into downstream automation. The key is to retain speaker attribution, timestamps, and contextual cues while stripping out filler words that would otherwise dilute the summary.

Core macOS tools that power the pipeline

macOS ships with a suite of speech‑related services that can be invoked from the command line or via AppleScript:

These components form the scaffolding on which Purple builds its autonomous, voice‑driven workflows.

Setting Up Purple for Hands‑Free Summarization

Installing Purple on macOS

Purple is distributed as a signed .pkg installer. After downloading from https://1into1.com/download, run the following command in Terminal to verify the signature and install:

spctl --assess --type install ~/Downloads/PurpleInstaller.pkg
sudo installer -pkg ~/Downloads/PurpleInstaller.pkg -target /

Upon completion, Purple registers a system service named purpled that listens for voice intents and can be invoked via the purple CLI.

Configuring BYOK (Bring‑Your‑Own‑Key) security

Purple’s architecture isolates all AI processing in a sandbox that encrypts data at rest with a user‑supplied key. Generate a 256‑bit key with openssl and import it into Purple’s key store:

openssl rand -hex 32 > ~/purple_key.txt
purple key import --file ~/purple_key.txt --label "MyMacKey"

All subsequent transcription and summarization jobs will be encrypted with this key, ensuring compliance with corporate data‑privacy policies.

Enabling voice triggers for a hands‑free experience

Purple leverages macOS’s built‑in Voice Control to map spoken phrases to CLI commands. Create a custom phrase “Summarize meeting” that runs the master workflow script:

purple voice add --phrase "Summarize meeting" --command "/usr/local/bin/meeting_summary.sh"

Once activated, you can say “Hey Siri, Summarize meeting” while the recording is still playing, and Purple will orchestrate the entire process without touching the keyboard.

Step‑by‑Step Workflow: From Recording to Structured Summary

Capture meeting audio with Voice Memos or QuickTime

Start by recording the session using the native Voice Memos app or QuickTime Player. Export the file to a dedicated folder, e.g., ~/Meetings/Raw. For consistency, rename the file with a timestamp:

mv ~/Downloads/Recording.m4a ~/Meetings/Raw/$(date +"%Y%m%d_%H%M")_TeamSync.m4a

Transcribe the audio using macOS Dictation or Purple

If you prefer an offline solution, enable Enhanced Dictation in System Settings and run:

dictate --input ~/Meetings/Raw/20230902_0930_TeamSync.m4a \
        --output ~/Meetings/Transcripts/20230902_0930_TeamSync.txt

For higher accuracy and speaker diarization, let Purple handle the transcription:

purple transcribe \
    --file ~/Meetings/Raw/20230902_0930_TeamSync.m4a \
    --output ~/Meetings/Transcripts/20230902_0930_TeamSync.txt \
    --model "large‑v2" \
    --diarize true

Clean the transcript with terminal filters

Raw transcripts contain filler words (“um”, “you know”), timestamps, and occasional misrecognitions. Use sed and awk to produce a clean version ready for summarization:

sed -E 's/\[?[0-9]{2}:[0-9]{2}(:[0-9]{2})?\]?//g' \
    ~/Meetings/Transcripts/20230902_0930_TeamSync.txt |
awk '!/^(um|uh|you know|like)$/ {print}' \
    > ~/Meetings/Transcripts/20230902_0930_TeamSync_clean.txt

Generate a structured summary with Purple’s AI

Purple can ingest the cleaned transcript, extract key decisions, action items, and produce a markdown outline. The following command runs the “summarize‑meeting” preset, which is pre‑trained on corporate meeting corpora:

purple summarize \
    --input ~/Meetings/Transcripts/20230902_0930_TeamSync_clean.txt \
    --output ~/Meetings/Summaries/20230902_0930_TeamSync_summary.md \
    --preset "meeting‑summary" \
    --format markdown

The resulting file contains sections such as # Decisions, # Action Items, and # Open Questions, each populated with bullet points automatically extracted from the conversation.

Export the summary to Word, Pages, or a shared drive

Most teams still rely on Microsoft Word or Apple Pages for final distribution. Convert the markdown to a .docx file with pandoc and move it to the shared folder:

pandoc ~/Meetings/Summaries/20230902_0930_TeamSync_summary.md \
    -o ~/Shared/TeamSync_20230902.docx \
    --metadata title="Team Sync – September 2 2026"

If you prefer a native Pages document, use AppleScript to import the markdown and apply a corporate template:

osascript -e '
tell application "Pages"
    set newDoc to make new document with properties {template:"Corporate"}
    set theText to read file "~/Meetings/Summaries/20230902_0930_TeamSync_summary.md"
    set body text of newDoc to theText
    save newDoc in "~/Shared/TeamSync_20230902.pages"
end tell
'

Automate the entire pipeline with a single voice command

All of the commands above can be wrapped in a shell script (/usr/local/bin/meeting_summary.sh) that Purple invokes when you say “Summarize meeting.” The script logs each stage, handles errors, and notifies you via macOS Notification Center:

#!/bin/bash
set -e
log() { echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> ~/meeting_summary.log; }

log "Starting transcription"
purple transcribe --file "$1" --output "$2" --model "large-v2" --diarize true

log "Cleaning transcript"
sed -E 's/\[?[0-9]{2}:[0-9]{2}(:[0-9]{2})?\]?//g' "$2" |
awk '!/^(um|uh|you know|like)$/ {print}' > "${2%.txt}_clean.txt"

log "Generating summary"
purple summarize --input "${2%.txt}_clean.txt" \
    --output "${2%.txt}_summary.md" --preset "meeting-summary" --format markdown

log "Exporting to Word"
pandoc "${2%.txt}_summary.md" -o "${2%.txt}_summary.docx"

osascript -e 'display notification "Meeting summary ready" with title "Purple AI"'

Comparison & Pros/Cons of Alternative Approaches

Frequently Asked Questions

Can I use Purple without an internet connection?

Yes. Purple ships with an on‑device inference engine that runs the “large‑v2” transcription model locally. As long as you have enabled Enhanced Dictation and installed the optional offline model bundle (≈2 GB), all steps—including diarization and summarization—execute without leaving the Mac. Cloud‑based presets are optional and only invoked when you explicitly add the --cloud flag.

How does Purple protect my meeting data with BYOK?

Purple encrypts every intermediate file (raw transcript, cleaned text, summary) using the user‑provided key stored in the macOS Keychain. The key never leaves the device, and decryption occurs only within the sandboxed purpled process. Audit logs are written to ~/Library/Logs/purple/ and can be reviewed for compliance.

What if my meeting contains multiple speakers with overlapping dialogue?

Purple’s diarization engine leverages a pretrained speaker‑embedding model that assigns a unique label (Speaker 1, Speaker 2, etc.) based on voice characteristics. Overlapping speech is detected and marked with a timestamped “[overlap]” tag, which the summarizer then treats as a joint statement. You can later refine speaker names by editing the *.txt file before running the summary step.

Experience Hands-Free macOS Automation

Purple transforms your Mac into an autonomous voice-controlled OS. Control your browser, synthesize documents, and run automated workflows with your voice.

Download Free Trial