Product
One key.
Four outcomes.
You hold one chord and speak. What happens next is decided by the key you press or the word you say — not by a classifier guessing at your intent. Every surface below writes into the same encrypted memory, and reads back out of it.
Each section ends with what that surface cannot do yet. Those limits are the honest part of this page, and they are why there is a waitlist rather than a download.
Surface 01
Dictation
Hold the key, speak, let go. Clean text lands in whatever field had your cursor.
The release is the end of the turn
Most dictation tools cut on silence, which means they cut while you are thinking. Here the key release is the signal, so one hold is one request and a pause mid-sentence costs nothing. A 1500 ms safety split was tried and removed — it fired on eight-second holds, ended clips mid-thought, and forced a repair call to fix damage it had caused.
Filler removal happens first and locally, deterministically. Only what a language model uniquely fixes — an unterminated sentence, a spoken self-correction — is worth a round trip.
Names come out right the first time
Speech models mangle exactly the words that matter: people, products, repositories. On-device OCR reads the window in front of you and those terms ride the transcription request, so the spelling is right before you have to correct it — and they are written back to memory, so the next session starts already knowing them.
Order matters and was got wrong once: the screen terms lead, the continuity tail follows, the fixed glossary lands last, because only the final tokens of a prompt carry real weight and a long tail was pushing the rare nouns out of the window.
What it cannot do yet
- No streaming — text arrives when you release the key, not as you speak.
- Transcription is a cloud call. It needs a connection.
- Local speech-to-text is deferred: the hardware people actually have is too uneven to promise it.
Surface 02
Questions
An answer on a card over your work. No window, no prompt box, no pasting your own screen into a chat.
Nothing is typed into your document
Dictation injects; questions never do. The card is an answer, not an edit — which means asking something while your cursor sits in a commit message cannot corrupt the commit message. That separation is enforced by the routing, not by care.
It already has the context
The screen and your accumulated memory are in the request before you finish asking. The reason this feels different from a chat window is not the model — it is that you are not spending the first paragraph describing your own situation.
What it cannot do yet
- One answer, no follow-up thread. The card is a moment, not a conversation.
- It reads the focused window only — not every window you have open.
Surface 03
The agent
Text work lands in place. File and code work is delegated to Claude Code, behind your approval.
The split is deterministic
"Reply to this" and "rewrite that" are text production: screen, memory, tone, and the result appears in the field you were in, at typing latency. No approval gate, because injected text is reversible — you delete it — and we never touch Send.
"Fix the bug", "open the ticket", "write the file" is different work, and it goes to Claude Code: a sandboxed agent with a real terminal and a real file system. We deliberately do not build pixel-clicking computer use. A bot guessing at coordinates is a demo; a terminal is a tool.
Autonomy is not the feature
Everything irreversible stops at a human. That is a structural property of how the tiers are wired, not a setting you can switch off, and it comes directly from the previous product: in a domain where a wrong output has consequences, the only version anyone would use was the one a human signed.
It also costs us nothing. Execution runs on your own Claude Code subscription, under your identity — the most expensive operation in the product is free to us, which is why the pricing can be a single per-seat number.
What it cannot do yet
- Requires Claude Code installed and signed in. There is no hosted fallback.
- Live "watch it work" streaming is partial — you see the result more reliably than the progress.
- Wiring a meeting's commitments straight into this tier is the piece being built right now. Today that hand-off is manual.
Surface 04
Meetings
Two streams, echo cancelled, and every commitment anchored to the second it was said.
No bot joins your call
System audio is captured through WASAPI loopback and your microphone as a second stream. Nobody sees a guest in the participant list, because there is no guest — there is a program on your own machine listening to your own speakers.
That creates the hard problem: played through speakers, the other party's voice reaches your microphone, and a naive transcript attributes their sentences to you. Three layers answer it — acoustic echo cancellation in the signal domain, a correlation gate that skips a transcription request entirely when an utterance is mostly echo, and conditioning before either. The archived audio is never modified; only the copy sent for transcription.
A note you can check instead of trust
What comes out is not a summary asking for your confidence. Every commitment carries the transcript line it came from and a timestamp you can play. A line with nothing to point at is dropped rather than shown.
Quality here is load-bearing, because the meeting engine is the main thing feeding the memory. A bad listener means a bad memory means a bad everything — which is why there is a word-error-rate harness with pass/fail gates rather than a claim on a website.
What it cannot do yet
- No speaker names beyond "you" and "them" — real diarization across several voices is not built.
- Meeting-type templates exist in code but are unreachable: there is no calendar connection to choose one.
- The .wav on your disk has no automatic retention policy. It stays until you delete it.
Underneath all four
One memory, two consumers.
Every surface above writes into one encrypted file on your disk, and every surface reads back out of it. It is exposed over MCP as well, so the delegated agent queries the same store the app does — not a copy of it, and not a summary of it.
This is the part that compounds, and the part nobody can sell you. A model provider can give you intelligence; only your own week can give you your own context.
There is no installer yet.
One month old, ~29,000 lines, 260 tests, one person, zero users outside this machine. The first build goes to the list.