BrainCue

The AI that's in the room with you — and remembers being there.
BrainCue hears the conversation you're actually in — a standup, a client call, an interview, a study session — contributes through a floating, screen-share-invisible Cue Card, and files what mattered back into the Space it happened in, so the next one starts where the last one ended.
Local-first. Bring your own AI key.

You pick an activity, not a mode

There is one start flow for every conversation. You say what the call is — never which engine to run — and everything else follows from that: what it listens to, when it speaks up, how it frames you, and what shape its summary takes afterwards.

Activity	You are…	BrainCue…
Meeting or call	in a standup, a client call, a sync	answers questions asked in the room; surfaces context, action items, decisions
Project discussion	talking about ongoing work	recalls what was decided before, and what is still open
Interview	the candidate	hears each question and streams a grounded answer cue, framed as you
Study or tutoring	learning something	pulls up the part of your material that bears on what was just said
Personal	dealing with a landlord, a bank, a doctor	keeps the background straight and catches what you agreed to
Game · Just me	playing, or thinking out loud	an ambient presence that stays out of the way
Something else	anything the list misses	contributes only when it is confident

Underneath, these run three engine modes over one pipeline — listen → decide whether to contribute → ground in your documents → respond. The mode is derived, never chosen, because picking a mode and a category was the same question asked twice (docs/18-ACTIVITIES.md). Interviewing someone and guided tutoring are still to come; the vision and plan live in docs/00-VISION.md and docs/10-ROADMAP.md.

Spaces, and the two things it remembers

A Space is one recurring context — Tuesday standup, Senior engineer · Acme, House move — holding the documents that ground it. It is also where a conversation is kept: when a session ends you choose whether to keep it, and in which Space. With no Space, nothing is summarised and nothing is remembered — the session helped live and leaves only its transcript.

Two different things get kept, with two different defaults, because they make two very different promises:

	Session summary	Long-term memory
Answers	"what happened in that call?"	"what should you always know about me?"
Example	"Phase two is blocked on renewal pricing. Priya is chasing legal."	"Never commits to dates in standup."
Default	on	off — until you turn it on
Review	none	every item, one at a time
Scope	its Space, always	its Space, or profile-wide
Lifetime	deleted with its session	outlives it

A summary is a précis of a conversation you chose to run, from a transcript already on your disk. A memory is a standing claim about a person — and a wrong one is repeated forever, which is why nothing is ever remembered silently: memories are only ever proposed, and only the ones you approve are recalled. Details in docs/16-CONTINUITY.md.

_{Proposed, not remembered — what one kept conversation suggested. Nothing here is recalled until you press Approve.}

See it in action

▶ Watch the demo
_{Every feature, end to end — recorded from the real app, against the sample data you can load with one click.}

_{Live, in real time — the question is heard, and a grounded, cited answer streams into the Cue Card.}

_{The same moment, two views — your screen has BrainCue; the shared screen (and any recording) has nothing.}

_{It proposes. You decide. — a conversation only becomes memory if you say so, one item at a time.}

_{Your documents never leave — only the matching lines do, and every answer says where it came from.}

Grounded in your story your material · with its sources

Re-tell it your way General · Technical — behavioral questions take the story shape on their own

Live coding rounds optimal solution + complexity

---

⚠️ Use only where AI assistance is permitted. Your data stays on your machine; only the retrieved context + the current moment of conversation is sent to your AI provider.

Why BrainCue

• 🎙️ Hears both sides — system-audio loopback puts it inside your actual calls; the microphone hears you at the same time. Questions come only from the other side, your own words stay in the transcript, and the call's echo in your mic is dropped.
• 🖥️ Transcribes on your machine — download a speech model once (NVIDIA Nemotron on sherpa-onnx) and live transcription runs on-device: no audio leaves, no key needed for it. Or keep OpenAI's cloud transcription.
• 💡 Grounded contributions — cues are drawn from your documents via on-device retrieval (local RAG), not generic filler — and it says so when it doesn't know, instead of inventing.
• 🪟 The Cue Card — an always-on-top panel excluded from screen sharing & recording: there for you, invisible to everyone else.
• 🤖 Your choice of model — answers from OpenAI, Anthropic, Google, Groq or OpenRouter, picked per task; every catalog model shows in every picker.
• 🧠 Continuity you control — each conversation you keep is summarised into its Space, so the tenth standup is grounded in the previous nine. Long-term memory is separate, off by default, and reviewed item by item: nothing is ever remembered silently.
• ⌨️ Global hotkeys — toggle the Cue Card, solve a copied problem, or drag-select a region of the screen to read and answer.
• 🔒 Local-first & private — data lives in a local database; your API key is encrypted by the OS keychain and never leaves the main process.
• 🔌 Bring your own AI — OpenAI today; a provider abstraction with support for multiple AI providers is on the roadmap.

Download

Grab the latest installer from the Releases page:

• Windows — .exe (NSIS installer)
• macOS — .dmg
• Linux — .AppImage

Builds are currently unsigned, so the OS may warn on first launch — Windows SmartScreen ("More info → Run anyway"), macOS Gatekeeper (right-click → Open).

System requirements

BrainCue is a local desktop app that streams live audio to your AI provider (OpenAI today) for transcription and responses, so a steady internet connection and a microphone matter more than raw compute.

	Minimum	Recommended
OS	Windows 10 64-bit (version 2004 / build 19041+), macOS 11, or a modern 64-bit Linux	Windows 11, macOS 13+
CPU	Dual-core x64 / Apple Silicon	Quad-core or better
RAM	4 GB	8 GB+
Disk	~600 MB (app) + room for local data	2 GB+ free (profiles, vectors, transcripts)
GPU	Any (integrated is fine)	Discrete or modern integrated
Display	1280 × 800	1920 × 1080 or larger
Audio	Microphone	Mic + system-audio loopback (to hear the other side)
Network	Broadband internet	Low-latency broadband (not needed for on-device transcription)

You also need your own OpenAI API key (set in Settings): embeddings and résumé parsing still run on it. Answers can run on an Anthropic, Google, Groq or OpenRouter key instead, and transcription can run on-device with a downloaded model — see docs/22-LOCAL-STT.md.

Notes

• Privacy Mode (hiding the app from screen sharing/recording) is most reliable on Windows 10 version 2004+ and Windows 11; on older builds the window may show as black to viewers instead of being cleanly excluded.
• System-audio capture (the other side's voice in online calls) uses Windows loopback automatically. On macOS, capturing system audio needs a virtual audio device (e.g. BlackHole); the microphone path works without one.
• Hybrid-GPU laptops (e.g. NVIDIA Optimus): if a window shows up blank/black, launch with --disable-gpu (or set AI_DISABLE_GPU=1) to fall back to software rendering.

Stack

Electron · React · TypeScript · Vite (electron-vite) · TailwindCSS · Zustand · SQLite (better-sqlite3) · Drizzle ORM · sherpa-onnx (on-device STT) · OpenAI Node SDK + Anthropic SDK + OpenAI-compatible transport (Google, Groq, OpenRouter) · electron-builder.

Design docs

BrainCue is docs-driven — the design documents are the source of truth the implementation follows, not a write-up produced afterwards.

📖 Read them as a site · 📁 Browse them here (index with descriptions)

Start with the Vision (the north star), the PRD (domain model and requirements), and the Roadmap (phases + the development rules). For how v2 actually works: Activities (one list, no mode picker), Spaces & profile, Active profile, and Continuity (summaries, memory, and why a Space is where a conversation is kept). The Engine plan describes the six-stage pipeline every mode configures; Architecture, Database, IPC map, and API key security cover the rest.

Getting started

npm install               # Node 22+ (24 recommended); also rebuilds better-sqlite3 for Electron
npm run dev               # launch the app with HMR

An OpenAI key is optional in dev (copy .env.example to .env, or set it in Settings, encrypted via OS secure storage) — and the first-run screen's Load sample data gives you a full world to explore without one. Full setup, prerequisites, and the pre-push gate: CONTRIBUTING.md.

Scripts

Script	Purpose
npm run dev	electron-vite dev (HMR)
npm run typecheck	type-check main + renderer
npm run test	unit tests (vitest; DB tests run on a sql.js harness)
npm run test:e2e	build, then drive the built app end-to-end
npm run db:generate	generate SQL migrations after editing schema.ts (never on a fresh clone — migrations are committed)
npm run build	typecheck + bundle
npm run icon	regenerate app icons from resources/icon.svg
npm run package / package:win / package:mac	build installer via electron-builder (auto-cleans release/ + kills running app first)

Releasing

Installers are built and published by GitHub Actions (.github/workflows/release.yml) — Windows, macOS, and Linux in parallel.

1. Bump version in package.json (and add a changelog/ entry).
2. Commit, then tag it to match: git tag v0.5.0 && git push origin v0.5.0 (the tag must equal v + the package.json version).
3. The workflow builds each platform and uploads to a draft GitHub Release named v0.5.0. Review it in the Releases tab and click Publish.

To produce installers without publishing (e.g. to test a build), run the workflow manually from the Actions tab — they're attached as downloadable artifacts instead.

Security invariants

• The API key lives only in the main process; the renderer learns a boolean apiKeyPresent and nothing more.
• All provider/DB/secret access happens in main; the renderer talks via the typed window.api preload bridge.
• .env is gitignored; the key is never logged (logger redacts sk-…).

Contributing

Contributions are welcome — see CONTRIBUTING.md for setup, the pre-push gate (typecheck + test + build), the IPC contract, and the privacy/security invariants that must not regress.

Project status

Actively developed, currently v2.2.x. The interview path shipped end-to-end in v1.5 (profiles, live grounded answers, the Cue Card, region/clipboard solve, practice with an AI voice, coaching reports) and is still fully supported — it just no longer defines the product. v2 made meetings and solo sessions the daily case: one activity picker instead of a mode picker, Spaces as the unit of context and of memory, per-activity summaries, a reviewed long-term memory, voice, and one active profile scoping the whole dashboard. v2.1 finished that shift: one activity picker instead of a mode picker, a Space as the only place a conversation is kept, per-activity summaries, and a Help page plus a guided tour that walk through all of it. v2.2 is the "Trust" train: on-device transcription, a choice of AI provider per task, both sides of a call heard, and meetings that answer the question just asked. (Spoken replies are built but hidden for now — in a call you do the talking.)

Next up is interviewing someone and guided tutoring — see docs/10-ROADMAP.md for what's planned and the changelog for what shipped in each release.