parley

Private, on-device meeting transcription for Apple Silicon. Captures your microphone and the far side of the call (Zoom, Teams, Meet, Slack, FaceTime), and turns them into speaker-attributed transcripts that never leave your Mac. 100% open-source, open-model, airgapped.

🤝 Sister project: mailrag — private, self-hosted email RAG. Two halves of one idea: a private, open context stack your AI agents can draw on.

What it buys you. Meeting transcription that's private by construction — every byte stays on your Mac, on open models, with nothing phoning home. It transcribes and labels speakers chunk by chunk in the background as you record, so when you stop, only the last chunk is left: a 3-hour meeting is ready about as fast as a 30-minute one. On an M5 Pro that runs at ~140× real-time for transcription and ~110× for diarization on the Neural Engine and GPU. It separates "you" from "them" with dual-stream capture and survives a crash mid-recording with zero data loss.

Why this exists

The first time I used cloud AI for meeting notes it felt like a cheat code — until I thought about what I was actually doing: uploading the raw audio of every meeting to someone else's servers. For anything confidential, that's a non-starter.

So I built the opposite. parley runs entirely on your Mac, on open models, with nothing phoning home — no account, no upload, no vendor to trust.

Then the real point clicked. These transcripts aren't just notes, they're context. A faithful, private record of what was actually said is exactly what an AI agent needs to be useful about your work — kept on-device, so you get total recall without renting your memory to anyone. parley is one private context source, for calls and meetings. mailrag is another, for email — different domain, different machinery (vector-DB retrieval). They don't talk to each other; my agents know about both and reach for whatever fits. The point was never a single app — it's a private, open stack of context I own.

Why it's built this way

Meetings are sensitive. Most of what gets said in them shouldn't be uploaded to anyone's servers, and for confidential work that rules out every cloud notetaker. So I built the opposite, around a few hard requirements:

• On-device and airgap-capable. The one that matters most. Nothing leaves your Mac, ever.
• Open-source and free. Read the code, trust the code. Donations welcome. :)
• Crash-resilient. It shouldn't fall over in the meeting you most needed it for.
• Tamper-proof. Signed transcripts and summaries you can actually trust (on the roadmap).
• Agent-queryable. Your own AI agents can search the record over MCP, kept on your machine (also coming).

Put together, that's a private, verifiable record of what was actually said, that you and your agents can rely on. Parley covers meetings, mailrag covers email. By humans. For agents.

What it does

• Dual-stream capture — records your microphone and the system audio as separate streams, so local and remote voices stay distinguishable. Works with any app. No virtual audio drivers, no kernel extensions.
• On-device speaker diarization — automatic who-said-what (pyannote + WeSpeaker + VBx), with a quality score on every segment.
• Two transcription engines — FluidAudio (Parakeet — fastest, 25 EU languages) or Apple SpeechAnalyzer (macOS 26+; downloads a per-language model on first use). Swap them in Settings.
• Echo / mic-bleed removal — flags the far-end voice that bleeds into your mic on speakers, so it doesn't show up as a phantom speaker in what you read (the JSON record keeps it, marked echo).
• Crash-safe recording — survives UI and XPC crashes with auto-relaunch, silent re-attach, and multi-segment stitching.
• Multiple outputs — JSON, SRT, and TXT with absolute timestamps, speaker labels, confidence scores, and local/remote tags.
• Optional local LLM summaries — point it at any OpenAI-compatible or LM Studio endpoint (including a fully local model) for a meeting summary, still without touching the cloud.
• CLI included — transcribe, rename speakers, summarize and download models from the terminal.

Screenshots

Quickstart

git clone https://github.com/fmasi/parley.git
cd parley
bash package_app.sh --release --install   # builds the Swift targets (optimised), assembles the .app +
                                          # XPC service, ad-hoc signs everything, installs to /Applications
open /Applications/Parley.app

On first launch, macOS asks for Screen & System Audio Recording permission. The default engine downloads its model (~500 MB) on first use and caches it after that.

Requirements: macOS 15+ (Sequoia), Apple Silicon (M1–M5); Xcode to build from source. (The Apple SpeechAnalyzer engine additionally requires macOS 26+.)

How it works — the hard parts

The interesting engineering isn't the transcription call; it's everything around keeping the record faithful and private.

• Dual-stream capture (the core constraint). macOS exposes no API for a pre-mixed mic + system stream — verified through the macOS 26 SDK headers. So the app runs two independent capture streams — your mic and the system output — and treats "local" (mic) and "remote" (system) as first-class. That constraint is why reliable speaker separation is possible at all.
• Capturing the calls a screen recorder can't see. ScreenCaptureKit misses Continuity (iPhone) calls and some VoIP audio. A Core Audio process tap grabs the system output directly, so phone and app calls land in the transcript too. The tap is the default for new installs; ScreenCaptureKit stays selectable in Settings as the legacy option until #221.
• Echo / mic-bleed removal. On speakers, the far-end voice bleeds into your mic and shows up as a phantom local speaker. Each mic-side line is matched against the far end on time (>50% overlap) and words (>70% overlap); a mic-side speaker whose speech is at least half matched is judged to be echo and every matched line of it is flagged, and elsewhere only matches of three words or more are. A flagged line is kept in the JSON record and hidden from the TXT/SRT transcript and the summary, and the transcript records the numbers behind each verdict (metadata.echo_clusters). The rename dialog and the completion notice say it in words: which speaker row looks like the far end through your loudspeakers, how many lines were marked, and that headphones avoid it.
• Cross-chunk speaker reconciliation. Audio is chunked and transcribed in parallel; per-chunk speaker IDs are merged into one global identity via greedy cosine matching on embeddings.
• Crash-safe by design. A sentinel file + LaunchAgent restart + multi-segment stitching mean a UI or XPC crash mid-meeting costs ~300–800 ms, not your recording. WAV files sync to disk every 0.5 s.
• Chunked over streaming — a deliberate accuracy call. Streaming ASR and diarization trade accuracy for low latency. Parley processes complete chunks in the background instead, so transcript and speaker labels come out as good as a full offline run, and only the final chunk waits for you to stop.
• On-device ML across the Neural Engine and GPU. Parakeet ASR and Silero VAD run on the Neural Engine (.cpuAndNeuralEngine); pyannote/WeSpeaker/VBx diarization runs through CoreML's .all, spread across the Neural Engine and GPU.

For the full design — the Core Audio tap, capture reliability and healing, the recording lifecycle, the pipeline — see ARCHITECTURE.md.

Transcription engines

Two ASR engines, switchable in Settings: FluidAudio (Parakeet) — ~500 MB model, 25 European languages, macOS 15+ — and Apple SpeechAnalyzer — system languages, downloaded per language on first use, macOS 26+. Engine choice is measured, not assumed: FluidAudio leads on European languages, Apple SpeechAnalyzer is the reliable path for Japanese, Korean and Chinese. FluidAudio also adds inverse text normalization ("two hundred" → "200") and per-segment confidence scores.

Speed

Measured on an M5 Pro (release build) with the bundled harness (tools/engine-benchmark), on a 4-minute AMI clip:

Stage	Engine	Real-time factor
Transcription	FluidAudio (Parakeet, ANE)	~142×
Transcription	WhisperKit (large-v3-turbo), for contrast	~2.5×
Speaker diarization	pyannote + WeSpeaker + VBx	~111×
Full pipeline	transcription + diarization	~62×

Because chunks are processed in the background during the meeting, the number you actually feel is the last row: at ~62× real-time end-to-end, the final chunk (≤30 min by default; the chunk length is configurable) finishes in well under a minute after you stop, whatever the meeting's length.

Apple SpeechAnalyzer isn't in this table — it needs a per-language model and errored on this clip in this run, so it should be benchmarked separately per system language.

Output

Transcripts are written as JSON, with SRT or TXT alongside:

{
  "metadata": { "language": "multilingual", "diarization": true, "dual_stream": true },
  "segments": [
    { "start": 1.6,  "end": 8.72, "speaker": "Speaker 1", "source": "local",
      "text": "On March 15, 2026, we held a meeting with 342 participants.", "confidence": 0.963 },
    { "start": 49.2, "end": 56.08, "speaker": "Speaker 2", "source": "remote",
      "text": "Le 14 juillet 2026, nous avons organisé une conférence.", "confidence": 0.941 }
  ]
}

source is local (your mic) or remote (the far side) — the dual-stream signal that makes the record trustworthy.

CLI

# Transcribe audio files (system + optional mic stream)
"$(swift build --show-bin-path)/Parley" transcribe -i system.wav [-i mic.wav] [-f srt] [--engine fluid_audio]

# Rename detected speakers interactively
"$(swift build --show-bin-path)/Parley" rename -i transcript.json

# Summarize a transcript with a local/remote LLM
"$(swift build --show-bin-path)/Parley" summarize -i transcript.json

# Benchmark engines (speed + WER) across languages
swift run --package-path tools/engine-benchmark EngineBenchmark audio.wav --engines fluid,speech

Project layout

TranscriberApp/        SwiftUI menu-bar app (MenuBarExtra + Settings), XPC client, windows and dialogs
TranscriberCore/       recording lifecycle, chunk processing, engines, diarization, echo detection, summaries, transcript I/O
AudioCaptureHelper/    XPC audio-capture service (Core Audio tap or ScreenCaptureKit, dual-stream)
AudioCaptureProtocol/  shared @objc XPC protocol
SwiftTests/            2775 tests across 299 suites
tools/engine-benchmark/  WER + speed benchmark harness
docs/                  architecture, pipeline, parameters, gotchas

Documentation

• ARCHITECTURE.md — the four targets, the Core Audio tap, capture reliability and healing, the recording lifecycle, the record
• docs/pipeline.md — end-to-end pipeline: recording → transcription → echo dedup → summary
• docs/parameters.md — every tunable parameter, with config keys and defaults
• docs/gotchas.md — hard-won platform gotchas (macOS APIs, ScreenCaptureKit, XPC, audio formats)

Local CI

CI runs once per PR, when it's marked ready, so run the checks on your machine first:

lefthook install      # once per clone: pre-commit secrets/shell/workflow checks, pre-push `just ci`
just ci               # exactly what CI runs (workflow lint, the serial Swift suite, the red-first gate), plus the app build
/ci-review            # in Claude Code: the same review rubric CI uses (.github/claude-review-prompt.md)
gh pr create --draft  # CI skips drafts
gh pr ready           # runs CI and the Claude review once

A PR merges when test, red-first and review / review-gate are green; a Critical review finding keeps the gate red until a re-review passes. The full rules for contributors and coding agents are in AGENTS.md.

Models & credits

parley runs on open models that download on first use — nothing is sent to the cloud:

Component	Model	License
Speech recognition	NVIDIA Parakeet TDT 0.6B (CoreML via FluidInference)	CC-BY-4.0
Speaker diarization	pyannote segmentation + WeSpeaker embeddings	CC-BY-4.0
Voice activity detection	Silero VAD	MIT
Engine SDK	FluidAudio	Apache-2.0
Apple engine (optional)	SpeechAnalyzer — on-device, macOS 26+	OS-provided

All model weights are CC-BY-4.0 or MIT — free for commercial and non-commercial use with attribution.

Built by Frédéric Masi

I build private, on-device context tools for AI agents — software that gives an agent (and me) total recall over my own work without sending anything to the cloud. parley covers calls and meetings; mailrag covers email.

I care about on-device ML, audio, and systems that stay correct when things crash. If that's useful to you, or you're hiring, I'd like to hear from you.

• LinkedIn — https://www.linkedin.com/in/fmasi/
• GitHub — https://github.com/fmasi

License

Open source under the GNU AGPL-3.0 — see LICENSE and NOTICE. Copyright © 2026 Frédéric Masi.

If you build on this code, the AGPL requires your derivative — including any networked service — to be released under the same license. Dual licensing: as the sole copyright holder, I also offer parley under separate commercial terms (proprietary binaries, App Store). For a commercial license, reach out via LinkedIn.