# OpenOats: a macOS meeting note-taker that transcribes both sides and suggests replies

> OpenOats is a Swift macOS app that records microphone and system audio, transcribes it locally, and searches a folder of your own Markdown notes for talking points. It is offline by default, Apple Silicon only, and the README is explicit that recording consent is your problem.

**yazinsai/OpenOats** — A meeting note-taker that talks back.

- Repository: https://github.com/yazinsai/OpenOats
- Website: https://openoats.com
- Stars: 2,593 · Forks: 259
- Language: Swift
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/yazinsai-openoats

## The problem OpenOats solves, and who it is actually for

Most meeting recorders answer the question "what was said?" OpenOats answers a different one: "what should I say next?" The README describes an app that sits next to a call, transcribes both sides in real time, and searches your own notes to surface things worth saying while the conversation is still happening. That is a narrower and more opinionated goal than transcription. It assumes you already have a body of written material (prep docs, research notes, customer briefs, competitive analysis) and that the value is in retrieving the right fragment at the right moment rather than in producing a summary afterwards.

The audience follows from that. This is for one person on one Mac who is in the call and wants help inside it. It is not a shared workspace tool, not a bot that joins the meeting, and not a service that produces minutes for people who were absent. The README's feature list points the same way: the app window is hidden from screen sharing by default, sessions are auto-saved as plain text, and the whole thing runs locally. Those are the choices of a personal tool, not a team platform.

The name is a problem for discovery, incidentally. Searching for it returns results about oats as a food, and the related searches confirm that, with queries about an "open oats procedure" and an "open oats price". If you are looking for this project, search the repository owner instead.

## How transcription, retrieval and suggestion fit together

The mechanism has three stages, and the README is clear about where each runs. First, capture: the app takes your microphone and your system audio, so both sides of the call are transcribed. Speech recognition runs entirely on the Mac, and the first run downloads a local speech model of roughly 600 MB. Second, retrieval: you point the app at a folder of Markdown or plain text files, and it chunks, embeds and caches them locally. When the conversation shifts, it searches that index and surfaces only what is relevant. Third, suggestion: an LLM turns the retrieved fragments plus conversation context into talking points.

The interesting part is that the second and third stages are swappable, and the choice determines your privacy posture. With OpenRouter you get cloud models such as GPT-4o, Claude or Gemini. With Ollama you get local models such as Llama, Qwen or Mistral, and the README states that in that configuration nothing touches the network. Embeddings are a separate decision from the LLM: Voyage AI in cloud mode, local Ollama embeddings, or any OpenAI-compatible endpoint implementing /v1/embeddings, which the README lists as llama.cpp, llamaswap, LiteLLM and vLLM.

That separation matters because the two halves leak differently. Audio never leaves the Mac in any configuration. Text does: in cloud mode the README says knowledge-base chunks go to Voyage AI or your chosen endpoint for embedding, and conversation context goes to OpenRouter for suggestions. So "OpenOats is private" is only true if you pick local providers for both, and the README says so rather than burying it.

Transcription itself is model-dependent in a way worth noting. Parakeet and Whisper work on macOS 14.2 and later. Qwen3 ASR requires macOS 15 or later and is only offered on supported systems. On Sonoma, a saved Qwen3 selection resolves to Parakeet v2, including for batch transcription, and the README advises choosing a multilingual model instead if you need one. The selected model's actual name is shown in Settings and recorded in session metadata, which is the right place to check when output looks wrong.

## Installing OpenOats with Homebrew and running a first session

The README gives a Homebrew tap and cask as the primary install path. The tap is fetched from the repository itself, so the command names both the owner and the project:

```bash
brew tap yazinsai/openoats https://github.com/yazinsai/OpenOats
brew install --cask yazinsai/openoats/openoats
```

Upgrades use the same cask name. There is also a DMG on the Releases page, and a build script for source builds, though the README notes that building requires Xcode 26 and Swift 6.2 while the release app does not need Xcode at all.

```bash
brew upgrade --cask yazinsai/openoats/openoats
```

After installing, the quick start is: open the DMG and drag the app to Applications, launch it, and grant microphone plus system audio recording permissions. The app asks you to acknowledge the recording-consent obligations before your first session. Then open Settings with Cmd+, and choose providers. Cloud mode wants an OpenRouter key and a Voyage AI key. Local mode wants Ollama running, with the README suggesting qwen3:8b for suggestions and nomic-embed-text for embeddings. OpenAI-compatible mode means selecting "OpenAI Compatible" as the embedding provider and pointing it at a /v1/embeddings endpoint.

Next, point the app at a folder of .md or .txt files. That folder is the knowledge base, and the app chunks, embeds and caches it locally. Then click Idle to go live, which is the label the README uses for starting a session. Transcripts land in ~/Documents/OpenOats/ automatically, and API keys are stored in the Mac's Keychain.

Two setup details are easy to miss. Select the output device that actually carries the call audio, especially with headphones or an external display, or system audio capture will be wrong. And the first run downloads the speech model, so the first launch is not representative of normal startup.

## Where OpenOats breaks down or is the wrong tool

The hardest constraint is the platform. OpenOats requires an Apple Silicon Mac on macOS 14.2 or later. There is no Windows build and no Intel build, and the related searches for "open oats windows" suggest people keep looking for one. If your team is mixed-platform, this app cannot be the shared answer.

The second constraint is legal rather than technical, and the README is unusually direct about it. It states that many jurisdictions require consent from some or all participants before recording, names two-party and all-party consent states in the U.S. and GDPR in the EU, and places responsibility for determining legality and obtaining consent entirely on you. The developers state they provide no legal advice and accept no liability. The app asks you to acknowledge this before your first recording. The feature that hides the window from screen sharing is a convenience for the user, not a resolution of that question, and in a jurisdiction requiring all-party consent an undisclosed recording is exactly the case the disclaimer is pointing at.

Retrieval quality is the third soft spot, and it is inherent to the design. The suggestions are only as good as the folder you point at. A thin or stale knowledge base produces either nothing useful or something irrelevant, and the README's phrasing ("only surfaces what's actually relevant") is a description of intent, not a guarantee. There is no evaluation harness described in the README for measuring whether a surfaced suggestion was good.

Finally, the app is a personal tool with a single-user model. Sessions save as plain-text transcripts and structured session logs, which is good for portability, but there is no described mechanism for a team to share a knowledge base, review each other's sessions, or run the recorder on a shared machine. If you need a hosted recorder that joins meetings on your behalf, this is not that, and the README's own sponsorship note points at Recall.ai for exactly that use case.

## OpenOats against Recall.ai and the hosted recording approach

The README carries a sponsorship note from Recall.ai, described as an API for desktop recording that records Zoom, Google Meet, Microsoft Teams and in-person meetings. The difference in approach is architectural, not cosmetic. Recall.ai is a hosted API: the recording happens through a service, which means a bot or an agent participates, audio is processed off your machine, and the output can be wired into a backend that many people share. OpenOats is the opposite: a local app you run yourself, where speech recognition never leaves the Mac and the only network traffic in cloud mode is text for embeddings and suggestions.

That trade runs in both directions. Hosted recording gives you multi-platform coverage, no dependency on your laptop being awake and present, and a natural path to team-wide transcripts. OpenOats gives you no bot in the meeting, an app that is hidden from screen sharing, and an option to run with zero network calls at all if Ollama handles both the LLM and the embeddings. It also gives you a plain-text transcript on your own disk in ~/Documents/OpenOats/ rather than a record in someone else's system.

If your problem is "get every meeting transcribed and searchable for the whole company", the hosted route fits better. If your problem is "help me in this call, using notes I already wrote, without sending audio anywhere", OpenOats is aimed squarely at that. The two are not substitutes, and the fact that the project's own README advertises the hosted option suggests the maintainers see it the same way.

## Maintenance, licence and what upgrading costs you

The repository is not archived, and the last push was on 2026-09-24, four days before this writing. Releases are frequent and small rather than rare and large: v1.88.0 on 2026-09-24 added macOS Sonoma support and custom model mirrors, v1.87.1 the same day covered Gemini via OpenAI-compatible endpoints, and v1.87.0 on 2026-09-13 added auto-record and quieter recording. That cadence tells you two things. Fixes and provider integrations arrive quickly. It also means the surface moves under you, so pinning a version matters if you depend on a specific provider path.

Maintenance cost for users is mostly provider drift. OpenOats sits between your Mac, an LLM provider and an embedding provider, and any of those can change independently. The OpenAI-compatible embedding path is the hedge: if Voyage AI or a specific cloud model stops working for you, an endpoint implementing /v1/embeddings is a drop-in alternative, and Ollama removes the network dependency entirely. The cost of that hedge is local hardware and model management, since you are then responsible for running Ollama and choosing models such as qwen3:8b and nomic-embed-text.

The licence is MIT, which is permissive: you can use, modify and redistribute the code, including commercially, provided the licence and copyright notice are preserved. Note the distinction between the code and the distribution channel. The Homebrew cask lives in the repository's Casks/ directory and installs from this tap, so a fork that wants brew installs needs its own tap rather than the yazinsai one. The MIT licence covers the software; it says nothing about the legality of the recordings you make with it, which the README handles separately and leaves with you. This is not legal advice, and the project explicitly does not offer any.

## Conclusion

Adopt OpenOats if you take calls on an Apple Silicon Mac running macOS 14.2 or later and you already keep written notes you would want surfaced mid-conversation. Skip it if you are on Windows or Intel, if you need a hosted recorder that works across a team, or if you cannot obtain recording consent from the other party. Before your first real call, verify three things: that the app is hidden from screen sharing on your setup, that the correct output device is selected so system audio is captured, and whether your chosen embedding provider means note text leaves the machine. The MIT licence lets you fork, but the Casks/ directory is what Homebrew installs from, so a fork that wants brew installs has to publish its own tap.

## FAQ

### Does OpenOats send my audio to the cloud?

No. Speech recognition runs entirely on your Mac, and the README states that audio never leaves the device in any configuration. In cloud mode only text leaves: knowledge-base chunks go to your embedding provider and conversation context goes to OpenRouter for suggestions. With Ollama handling both the LLM and the embeddings, the README says nothing touches the network at all.

### Can I run OpenOats on Windows or an Intel Mac?

No. The README lists Apple Silicon Mac with macOS 14.2 (Sonoma) or later as the requirement, and the install path is a Homebrew cask or a DMG for Mac. There is no Windows or Intel build described.

### Where are OpenOats transcripts saved?

Transcripts are saved locally to ~/Documents/OpenOats/ according to the README, and every conversation is auto-saved as a plain-text transcript plus a structured session log with no manual export. API keys are stored separately in the Mac's Keychain.

## Sources

- [License: MIT](https://github.com/yazinsai/OpenOats/blob/main/LICENSE)
- [Project website](https://openoats.com)
- [README](https://github.com/yazinsai/OpenOats/blob/main/README.md)
- [Releases](https://github.com/yazinsai/OpenOats/releases)
- [yazinsai/OpenOats on GitHub](https://github.com/yazinsai/OpenOats)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/yazinsai-openoats