Project Raven: a local-first AI meeting copilot with dual-stream capture and echo cancellation
Open-source AI meeting copilot - real-time transcription, echo cancellation, and AI assistance. Captures system audio + mic, cancels echo via WebRTC AEC3, transcribes with Deepgram, and gives you Claude/OpenAI help during meetings. Runs locally on macOS and Windows.
At a glance
- What is it?
- Project Raven is an MIT-licensed Electron app that captures system audio and your microphone, cancels echo with WebRTC AEC3, transcribes both sides on separate streams, and answers through your own Deepgram, AssemblyAI, Anthropic or OpenAI keys. The trade-off is that you supply the keys, the cost, and the platform assumptions.
- Who is it for?
- Adopt Project Raven if you already hold Deepgram or AssemblyAI and Anthropic or OpenAI keys, work on macOS 12+ Apple Silicon or Windows 10/11 x64, and want transcripts and notes in a local SQLite file rather than a vendor account. Skip it if you are on an Intel Mac, need a Linux build, or cannot accept that raw microphone and system audio leaves your machine for the speech-to-text provider.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 18 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What Project Raven solves, and for whom
Most meeting assistants are SaaS products: you send a bot into the call, or you pipe audio to a vendor, and the transcript lands in someone else's account. Project Raven takes the opposite position. It is an Electron desktop app that runs capture, echo cancellation, SQLite history and document retrieval on your own machine, and it holds no Raven account, no hosted backend and no cloud session sync. The only data that leaves the machine is what you explicitly route out: microphone and system audio to Deepgram or AssemblyAI for speech-to-text, and Assist prompts (transcript excerpts, chat, an optional screenshot, retrieved documents) to Anthropic or OpenAI.
The intended user is someone who takes a lot of calls and already pays for model access. The README describes the workflow in two halves: during the call, a dual-stream capture plus an overlay that suggests what to say and is invisible to screen share; after the call, auto notes, structured action items, a follow-up email draft, talk ratio, export, and an Ask tab that queries a single session or your whole history. Sales is listed among the topics, and the follow-up draft and talk ratio point at that audience, but nothing in the repository restricts it to sales.
The cost model is the honest part of the pitch. There is no subscription to Raven. There is a Deepgram or AssemblyAI bill and a Claude or GPT bill, both on your own accounts, which for a heavy meeting schedule is real money that a flat-rate competitor would have bundled.
Dual-stream capture and the residual echo gate
The architecture splits the audio problem in two rather than mixing it. On macOS, capture uses ScreenCaptureKit plus CoreAudio; on Windows, WASAPI loopback plus capture, implemented in Rust through NAPI. That yields two parallel streams: Them, from system audio, and You, from the microphone.
The microphone stream is the hard one, because your speakers leak into your mic. Raven runs the mic through GStreamer's webrtcechoprobe and webrtcdsp, which is WebRTC AEC3, and then applies what the README calls a residual echo gate: a stage that drops mic chunks which still look like speaker bleed before they reach the speech-to-text engine. That second stage matters. Acoustic echo cancellation rarely removes everything, and a chunk of your own call audio arriving on the You stream would be transcribed as something you said. Dropping it costs you a little real speech at the boundary; keeping it would corrupt the transcript and, downstream, the talk ratio and the notes.
Transcription runs on both streams separately, with Deepgram nova-3 and AssemblyAI u3-rt-pro named as the engines. Auto-routing prefers AssemblyAI for English, Spanish, French, German, Portuguese and Italian when that key is present, and falls back to Deepgram otherwise, and Settings can force either engine. Because the two streams are labelled at capture time, speaker attribution is a property of the pipeline rather than a diarization guess made after the fact.
Installing Project Raven from the release installers
The README points at prebuilt installers on the latest GitHub Release rather than a package manager. Windows 10 and 11 x64 get a setup executable, macOS 12 or newer on Apple Silicon gets a DMG. Intel Macs are explicitly not in the DMG.
On Windows, the README warns that SmartScreen may flag the unsigned open source build, and the documented path is More info, then Run anyway.
Raven-Windows-2.4.3-Setup.exeOn macOS, you open the DMG, drag Raven to Applications, then launch it. The first launch runs a six-step onboarding flow that covers API keys, permissions, the overlay tour and shortcuts. Keys go into Settings, and the README is direct that you enter your own keys there.
Raven-Mac-2.4.3-Installer.dmgThere is no Homebrew formula, no npm install path for end users, and no Linux artifact in the release table. Building from source is a separate exercise: the repository requires Node 22.12.0 or newer, and package.json exposes build:aec for the AEC native module and build:swift for the macOS AudioCapture helper, so a source build needs CMake and a Swift toolchain on top of the usual Electron tooling.
Stealth mode, and what setContentProtection does not promise
The overlay is the feature that will decide adoption for some people and rule the tool out for others. Raven uses Electron's setContentProtection so the overlay and dashboard are omitted from typical screen-share APIs, and the README names Zoom, Meet, Teams and Discord as the cases it targets. Two screenshots in the repository show the same overlay visible and invisible to a share.
The README states plainly that this is not a guarantee against every capture tool. That sentence is doing real work. Content protection is a window-level hint to the compositor and to well-behaved capture APIs; it is not encryption, and it does not stop a phone camera, an external capture card, or a recorder that ignores the flag. Anyone treating stealth mode as a compliance control rather than a display convenience is reading past the documentation.
There is a second, quieter constraint. The app captures system audio, which on both platforms is the audio of everything playing on the machine, not just the call. The README does not describe a per-application capture scope, so if a notification, a video or a second call plays during the session, that audio is in scope for the Them stream.
Local storage, RAG, and the absence of long-term memory
Sessions live in SQLite on disk: transcript, overlay chat, auto title and summary. Incognito mode skips SQLite persistence for that session, which is the documented way to keep a call out of history. The dashboard can generate insights using your own LLM key.
Modes are local behaviour profiles that bundle a system prompt and notes templates, and each mode can carry attached documents for retrieval. Uploads accept .txt, .md, .pdf and .docx, which are chunked and embedded on-device with Xenova/all-MiniLM-L6-v2 through @xenova/transformers; chunks are stored in SQLite and the top matches are injected into the Assist system prompt. The README notes the first embed may download roughly 30MB of model weights, so the first run after install is not fully offline even though the embedding itself is local.
The limitation is stated in the README rather than hidden: session context is not long-term memory. During a recording, Assist keeps recent turns, pins the opening transcript and your typed questions, and may compress older context with a cheap model in RAM. There is no cross-meeting user-memory profile. If your expectation is an assistant that remembers a client from six calls ago without you retrieving it, this build does not do that. The Ask across all meetings tab searches your history, which is retrieval over stored transcripts, not a persistent model of the people you talk to.
Where Project Raven is the wrong tool
Three cases stand out. First, hardware: the macOS installer is Apple Silicon only, and the README says Intel Macs must build from source. A team with mixed Macs cannot roll this out from the DMG alone. Second, platform: there is no Linux build in the release table, and no self-hosted server component, because there is no server. Anyone who needs a headless recorder on a Linux box, or a shared team workspace where transcripts appear for colleagues, is outside the design.
Third, the one that matters most for regulated environments. Capture, echo cancellation, SQLite and RAG run locally, but the README is explicit that microphone and system audio go to Deepgram or AssemblyAI, and that Assist prompts go to Anthropic or OpenAI. A local-first label here means local storage and local processing of the parts that can be local, not a system where meeting audio never leaves the machine. If your policy forbids sending call audio to a third-party STT vendor, no setting in this app changes that, and the README does not document a local speech-to-text option.
There is also a dependency shape to weigh. The app is Electron with a native AEC module and, on macOS, a Swift capture helper, plus a postinstall step that rebuilds better-sqlite3 for Electron. That is a source build with a toolchain requirement, not a one-command install.
How it compares to a bot-based meeting assistant
The obvious alternative is the class of assistants that join the call as a participant: a bot dials into Zoom, Meet or Teams, records server-side, and delivers a transcript and summary afterwards. Otter.ai and Fireflies.ai are the well-known examples of that model, and they solve the problem in a genuinely different way.
The difference is where the audio goes and who is visible. A bot-based assistant gets a clean, single, server-mixed audio stream, which removes the echo problem entirely, because there is no speaker-to-microphone path to cancel. Raven has to solve echo cancellation and residual gating precisely because it captures from your machine instead of from the meeting server. In exchange, no bot appears in the participant list, the overlay is on your screen rather than in a shared recording, and the transcript is written to a SQLite file you control.
That trade cuts both ways. A bot-based assistant works on any platform the bot can join, including Linux desktops and mobile, and it produces a shared artifact a whole team can open. Raven is per-machine, per-user, and its value is concentrated in the live overlay during the call. If your main need is an after-the-fact transcript archive that colleagues can search, the bot model fits better. If your main need is a prompt on your own screen while you talk, and you would rather hold the keys and the database, Raven is aimed at you.
Licence, updates, and the cost of keeping it current
Project Raven is MIT licensed, and package.json carries the same identifier. MIT is permissive: you can use, modify and redistribute it, including in commercial settings, provided the copyright notice and permission notice are preserved. That covers the application code. It does not cover what you plug into it. Your Deepgram, AssemblyAI, Anthropic and OpenAI usage is governed by those vendors' terms, and the embedding model pulled through @xenova/transformers carries its own licence, which the README does not restate. Nothing here is legal advice; if you are shipping a fork inside a company, read the LICENSE file and the model card yourself.
Upgrades are handled in-app. Installed copies check GitHub Releases, using latest.yml on Windows and latest-mac.yml on macOS, and the updater only offers a build when the published version is newer than the one you have. From 2.4.1, macOS self-updates in-app like Windows: Update now downloads, Restart and update installs. The release notes say Macs still on 2.4.0 update via the DMG one last time, and v2.4.3 is titled as a fix for macOS in-app self-update, which tells you that path was recently repaired rather than long-settled.
The maintenance signal is recent: the last push to the repository was on 2026-08-28, and v2.4.3 landed the same day. The upgrade cost is low for a packaged install and higher for a source build, because the native AEC module and the Swift capture helper have to be recompiled when their dependencies move.
Editorial conclusion
Adopt Project Raven if you already hold Deepgram or AssemblyAI and Anthropic or OpenAI keys, work on macOS 12+ Apple Silicon or Windows 10/11 x64, and want transcripts and notes in a local SQLite file rather than a vendor account. Skip it if you are on an Intel Mac, need a Linux build, or cannot accept that raw microphone and system audio leaves your machine for the speech-to-text provider. Before committing, verify two things on your own hardware: that the residual echo gate holds on your speaker and microphone combination, and that the stealth overlay stays out of the screen-share tool your counterparty actually uses. The README states plainly that setContentProtection is not a guarantee against every capture tool, so treat that as the boundary of what you are buying.
Frequently asked questions
What is Project Raven?
It is an MIT-licensed Electron desktop app for macOS and Windows that captures microphone and system audio, cancels echo locally with WebRTC AEC3, transcribes the two streams separately, and offers AI assistance from an overlay during the call. It runs with your own Deepgram or AssemblyAI and Anthropic or OpenAI keys, with no Raven account or hosted backend.
What are the projects for cyber security?
The repository does not present Project Raven as a cyber security project. It is described as a meeting copilot for real-time transcription and AI assistance, and the topics listed are ai, transcription, meeting-assistant and similar, with no security tooling.
Does Project Raven need an account or a subscription?
No. The README states there is no Raven account, no hosted backend and no cloud session sync, and that recordings and notes stay in a local SQLite database. You supply your own API keys in Settings on first launch, so your costs are whatever Deepgram or AssemblyAI and Anthropic or OpenAI charge you.
Can Project Raven run entirely offline?
No. Capture, echo cancellation, SQLite history and document RAG run locally, but the README says microphone and system audio go to Deepgram or AssemblyAI, and Assist prompts go to Anthropic or OpenAI. The embedding model used for RAG runs on-device, though the first embed may download about 30MB of weights.
Which platforms does Project Raven support?
The release table lists Windows 10/11 x64 and macOS 12 or newer on Apple Silicon. The README states that Intel Macs are not in the DMG and must build from source, and there is no Linux installer listed.
Community notes