Open Source AI Note Taker: My Docs Said Audio Stayed Local. The Code Disagreed.

For 85 public days, the privacy docs of my open source AI note taker said audio never leaves the machine. Four other files in the same repository said it could.

The tool is OnCue. It transcribes calls locally with whisper.cpp and can coach you live. Local-first is the whole point, so the privacy document said so, in bold.

The code had an opt-in backend that sends every audio chunk to a cloud API when you select it. Nobody hid it. It was described next to the code and missing from the documents a privacy reader opens.

The claim and the code

The privacy document on release v1.0.0-rc.2 said it three times:

  • "Raw audio is always transcribed locally with whisper.cpp or mlx-whisper and never leaves the device."
  • "What never leaves the machine: Raw audio (mic stream and system stream)"
  • "Raw audio never leaves the machine. The risks of a data breach at an external provider are thereby eliminated for the most sensitive data type."

The README added: "Audio never touches a network call."

On 13 May, when I wrote the first version, that was true. When I started building OnCue, I wrote that I did not want to ship a prospect's audio to a US transcription provider (building a real-time sales copilot). Keep that sentence in mind. On 18 July I added a cloud transcription backend for speed: Groq's hosted whisper-large-v3-turbo. Set WHISPER_BACKEND=groq, or pick it per conversation in the dashboard, and this happens:

  • every voice-activity chunk of 1.2 to 7 seconds is encoded as a 16 kHz, mono, 16-bit WAV;
  • it goes out as a multipart upload to api.groq.com/openai/v1/audio/transcriptions;
  • the transcript comes back as JSON.

No PII filter runs on that route. The redaction layer in OnCue works on text, and this is audio.

Four files told the truth

This is the part that makes it a developer story rather than a scandal. The backend's own docstring was accurate from day one:

python
"""CLOUD backend: every audio chunk leaves the machine as a WAV upload
to Groq's API. [...] Selecting this backend is an explicit opt-in
(dashboard dropdown or ``WHISPER_BACKEND=groq``)."""

.env.example said "every audio chunk leaves the machine as a WAV upload to Groq". The module doc said "every audio chunk is uploaded to Groq as a WAV; never the default". The dashboard tooltip said "Do not use for sensitive or confidential conversations."

My CI gate saw it too, which is a pattern I wrote about before: monitoring that watches the wrong thing. A boundary check keeps an allowlist of files that may import a network library, and groq_backend.py was on it from the first commit. So the code path was known from the start. It was a disclosure in the wrong place.

The documents a privacy officer, a client or a buyer reads were the ones that were wrong. The privacy document and the README said "never". So did the beta tester guide, a draft DPIA and two more docs.

Two doc sweeps walked past it

Five days after the Groq backend landed, I ran a "full accuracy sweep" over the docs. That sweep added the Groq route to the module doc. It also kept the README line "never leaves your Mac, unlike cloud-Whisper services".

In early October I answered a privacy questionnaire of thirteen questions. I laid the docs next to the code and found seven other mismatches. The three that mattered most were the default model provider, a "fragments of one to three sentences" claim that ignored the running summary and the meeting report, and a PII filter that promised more than it does. I fixed all seven. The audio claim survived again. In my own answers I wrote that audio and transcripts stay on the user's computer.

Both sweeps missed it for the same reason. The claim was true for the default. When you check a sentence against the code, you check the path you know.

On 20 October someone else's draft quoted my answers back to me. I wrote that part of the story for Dutch readers in a post on privacy by design for meeting notes (in Dutch). Reading my own words in another person's text, I checked each sentence against the code. That was the pass that found Groq.

The three fixes

All three are public. The diff from rc.2 to rc.3 shows the old "never leaves" lines next to the new ones. v1.0.0-rc.4 is the first release with all three.

1. The docs describe the opt-in routes. The privacy document now says audio stays on the device by default, and lists the routes that change that. The README says: "By default audio never touches a network call. One opt-in route sends audio off the machine: WHISPER_BACKEND=groq uploads every audio chunk to Groq."

The fix drifted too. The first docs PR described a non-loopback whisper.cpp host as sending audio "to that machine". OnCue starts whisper-server itself and binds it to that address on your own machine. The real outcome is an open, unencrypted listener on your network. The next PR corrected it.

2. The per-conversation ceiling covers transcription. OnCue lets you set a privacy ceiling per client: local, tenant or public. Before the fix, that ceiling only knew about LLM providers. A client set to local could still be transcribed by Groq.

Now a transcription_tier_of() function classifies every backend. mlx-whisper and whisper.cpp on loopback are local. Groq, whisper.cpp on another address and any unknown name are public. At start-call, the ceiling checks the backend the runtime will actually build, including the per-conversation pick. A backend above the ceiling gets HTTP 400. The new test file failed 10 of its tests on the old code.

There is a gap left. A newer note-taker route builds its transcription backend without that check. Groq cannot run on that route today, so no audio leaves through it. The README line "a client's privacy ceiling refuses both" is only true for the coaching route, and I haven't closed that yet.

3. The default provider is none in code, not only in .env.example. The example file said none. config.py said openrouter. Without a key nothing went out, because the client fails on the missing key. The risk sat in a machine with a provider key in its environment and no explicit setting.

The European data protection board defines a default as "the pre-existing or preselected value of a configurable setting that is assigned to a software application" (EDPB Guidelines 4/2019, par. 40). A value in an example file the user may or may not copy is not that. The fix is a few lines in config.py and outbound_policy.py. Its test file failed 13 of 14 on the old code.

What Groq does with the audio

If you turn the Groq route on, this is what the provider says, as of November 2026. Groq's data page says it does not retain inference data by default. The transcription endpoint does fall under "system reliability and abuse monitoring", retained "up to 30 days", in Google Cloud buckets in the United States. Any customer can switch on Zero Data Retention in their own settings.

So with the Groq route on, a prospect's audio does go to a US provider, which is exactly what I set out to avoid in May.

One detail you only notice when you send short chunks: Groq bills a minimum of 10 seconds per request. OnCue's live chunks are 1.2 to 7 seconds, so every chunk is billed as 10.

Pin the claim, not the import

My CI checked which files may open a network connection. It did not check what the privacy document promises. I already had tests that tie two other outbound data classes to the privacy document. Transcription had none, and still doesn't.

This is a common failure, not a special one. PoliCheck compared 13,796 apps with their privacy policies and found that "up to 42.4%" either incorrectly disclosed or omitted their privacy-sensitive data flows. A sentence like "audio never leaves the machine" points at no function. You will not catch it with grep or a link checker.

What I'd do now, in this order:

  1. List every outbound data class in the privacy document: audio, transcript fragments, full transcripts, telemetry.
  2. For each one, write a test that fails when a code path sends that class somewhere the document does not name.
  3. Re-read the privacy document whenever you add a backend, a provider or a route. A new backend is a new data flow, even when it is opt-in.

📖 Read also: OnCue's local-first architecture: how the local data plane and the per-call control plane are split.

Frequently Asked Questions


OnCue is open source on GitHub. Checking each sentence of the privacy document against the code is how this one came out. If you do the same and find another mismatch, open an issue. More about the tool on the OnCue page.

Vincent van Deth

AI Strategy & Architecture

I build production systems with AI — and I've spent the last six months figuring out what it actually takes to run them safely at scale.

My focus is AI Strategy & Architecture: designing multi-agent workflows, building governance infrastructure, and helping organisations move from AI experiments to auditable, production-grade systems. I'm the creator of VNX, an open-source governance layer for multi-agent AI that enforces human approval gates, append-only audit trails, and evidence-based task closure.

Based in the Netherlands. I write about what I build — including the failures.