The work, as it ships.

Dictation now edits out more of how talking actually sounds.

Cleanup and Corrections already caught stutters, "um"s and spoken retakes with a cue word ("no wait", "I mean"). They now catch three more ways a sentence goes sideways out loud. An opening you abandoned and restated disappears: "UI will force the, if I'm touching the plus button will force the window to move" loses its stranded first attempt. A mid-sentence retake over a bare "or" keeps only the version you finished: "it appears on the opposite window than the one I'm or opposite monitor than the one I'm using" comes out saying the monitor, once. And the "like"s that are pure filler come out — ", like," between commas, a "Like," opening a sentence, a "where like I closed" — while every meaningful one stays: "I like it", "it looks like rain", "like I said", and the "like" that means roughly in "when like a thousand people join".

Your notes now sit where the call becomes a record.

Notes you type during a session have moved. They used to open the session; they now close it, sitting between what the conversation produced and what was actually said — the seam where a thought about a call actually belongs. And there is a field there now, so you can write one without leaving the page you are reading: in the Sessions window while a call is running, in the menu bar's Items tab, and on any session in the history browser, including one you are following live from another device. On that last one the field does what it always did — end a line with a question mark and it goes as a question to the device doing the listening — except the answer now arrives directly beneath where you asked it, instead of below the entire transcript.

Everything Cyrano pulled out of a call is editable wherever you can see it.

Tasks, open asks, subtext, next moves and watch hits could always be reworded, dropped, or kept. You just had to know to swipe them, right-click them, or double-click them, which is a poor way to find out that a line reading slightly wrong is yours to fix. Every one of them now carries a small ⋯ button, so those actions are one visible tap away on every screen that lists them: the review, the history browser, and the menu bar.

And you can bring it all back.

Export everything has had a counterpart added underneath it: Restore an export. Point it at a folder an export made — the whole thing, its Sessions folder, or the parent you keep your exports in — and your sessions come back, with their transcripts, tasks, open asks, subtext, next moves and watch hits. This is the half that was missing. Cyrano's sync between your devices is encrypted with a key only your devices hold, and there is no password reset and no copy on our servers, so that folder is what's left if you lose every paired device — and a folder you can't put back isn't a backup.

The panel can come off the menu bar.

Drag anywhere on the popover and it tears off into its own small window — the same cards, the same live view, no title bar, just the close and minimize buttons floating over the same backdrop. Unlike the popover, it doesn't vanish when you click into another app: it stays where you dropped it until you close or minimize it, so a live session's transcript, extracted items, or map can sit at the edge of your screen through a long call. Grab any quiet part of its surface to move it, and if you'd rather not drag, the small window button in the popover's footer detaches it too. The menu bar icon keeps working exactly as before — the popover is still there for the quick glance, and closing the window hands the job back to it.

Transcription now has its own language.

It no longer has to be your device's: set Speech language once and it applies to sessions, Dictate Anywhere, and the Cyrano keyboard, whether transcription runs on-device or through ElevenLabs. Fifteen languages across twenty regional variants, or Automatic to keep following the device. Cyrano remembers the choice across launches and downloads the on-device language file when the system needs one.

Tag a session and decide once what happens to every session like it.

Tags are labels for whole calls — "Acme", "1:1", "media" — and they do two things watch categories can't. They group calls across your whole history, so "everything tagged Acme" is one search here and one question for a connected assistant, instead of opening sessions one by one to find the four that were about the same thing. And each tag carries its own rules: what's kept, whether it's analyzed at all, and where it goes when it ends. Set them once on the tag, and every session you put it on inherits them. (A watch category still does the other job — it looks inside one conversation for the things you care about. A tag is about the conversation itself.)

Assistants can work in your vocabulary.

A connected assistant (Claude Desktop, Codex, or your own) can now ask which tags you use, pull just the sessions carrying one, and get a single distilled rollup of everything tagged "Acme" rather than reading four transcripts to answer one question. It can also label the live call for you — but only with tags you've already made, never a tag it invented, and never one whose rules would discard the session. A session you've tagged as hidden is withheld from every read, including today's rollup, and the hidden tag's name is withheld too: to an assistant it is indistinguishable from a tag that doesn't exist. When something is held back, the assistant is told that much, so a quiet answer reads as "some sessions are held back" instead of "you have no sessions". A call you started on the Mac can now be picked up on your iPhone, and the other way round, without ending it. Follow the live session on the second device and there is a Take over recording button: the device that was listening stops, this one continues the same session, and you end up with one transcript instead of two halves you have to read side by side. Notes, questions, speaker names and everything already extracted come with it, and you can hand it back again later in the same call.

Change what a session is listening to without ending it.

The capture segments and the microphone picker used to disappear the moment a session started, so a call that turned out to be on this Mac, or a headset you had to switch to halfway through, cost you the session — end it, start another, and read one conversation as two transcripts. Both controls now stay live. Turn system audio on when the meeting starts and the meeting feed joins the session already in progress; drop back to system-only when you step away from the desk; swap microphones mid-sentence and capture rebinds in place. Nothing already transcribed is disturbed. The switch is careful about the seams: the new source is brought up before the old one goes down, so a session is never briefly deaf, and a source that refuses to start — Screen Recording still switched off, a mic that just vanished — leaves the session running on exactly what it had, with the control snapping back to the truth rather than showing a change that didn't happen. Turning system audio on mid-session asks for the same one-time acknowledgment that starting a system-audio session does, because it crosses the same line. Duplicate-speech merging re-arms itself around the change, and the speakers-in-the-room warning re-evaluates on the spot. One deliberate limit: a mid-session change applies to that session only. What a new session starts on is still what you set while idle, so flipping once to pick up a call doesn't quietly become your default forever. Tell speakers apart stays a before-you-start choice — clustering voices can't begin part-way through a call without splitting one person across two labels.

Speakers instead of headphones no longer double your transcript.

Play a call through your Mac's speakers with system audio captured and your microphone hears the other side too — so the same sentence arrived twice, once correctly as the remote speaker and once, wrongly, as you. Cyrano now recognizes its own output coming back through the room and keeps a single copy. It listens for it in the audio itself, before a line is ever written, and compares the wording of the two inputs as a backstop, so a slow external interface doesn't slip through. Two rules decide what survives: whichever input got there first keeps its place in the transcript, and the speech is attributed to whoever actually said it — a line your mic caught first is relabelled where it stands rather than moved. Talking over the other side is safe: when your voice and theirs overlap, your words are kept, and if you've turned on Recognize my voice, anything measured as yours is never treated as an echo. This works with laptop speakers, desk speakers, and audio interfaces; headphones simply avoid the situation, and the session card says so when your current setup is likely to duplicate. The review footer tells you how many lines were merged, so a session never just looks short. Merge duplicate speech (Settings → Speakers) turns it off if you'd rather see both raw inputs.

Transcript edits and redactions can be undone.

Fixing a mis-heard name across a session, renaming a voice, or removing personal information from a line are all one step now — and all reversible, with Undo and Redo in the review's toolbar (⌘Z and ⇧⌘Z) and in any line's menu, each naming the exact change it will walk back. Undo works the same on a live session and on one you've opened from your history. Removing personal information stays destructive to the stored transcript, as it should be: it is reversible only while you're still in that session's review, and the undo history lives in memory alone — it is never written to disk, never synced, and gone when you quit, so scrubbing something doesn't quietly leave a second copy of it somewhere. Redact other-party lines remains permanent, because it also removes those lines from the server and nothing here can undo that. It now says so before you tap it, asks once, and clears the undo history when it lands.

Dictation keeps up with you now.

Press the key again the moment you finish a thought — before the last one has even landed — and both come out, in the order you spoke them. Dictation used to have one lane: a new burst started while the previous one was still transcribing either couldn't open the mic or quietly threw the earlier words away. Now every burst stands on its own, they finish in parallel, and nothing is dropped: a burst that has nowhere to type lands on the clipboard, and the menu bar keeps the last few dictations from this session so a chained run can't overwrite itself. That recall list lives in memory only — it is not a history, it is never written to disk, and it is gone when you quit. As a side effect of the restructure, the next burst's engine is warmed the moment the previous one hands its transcriber over, so chained dictation starts hot instead of cold.

Dictated text reads the way you meant it, not the way you said it.

Stutters ("I I I think"), false starts ("we should — let's start over"), and a much larger family of fillers are now cleaned up deterministically, on every tier, with no model call and nothing leaving your Mac. Your pauses matter too: stop talking for a couple of seconds mid-burst and the text picks up a new paragraph; shorter breaks become sentence starts — reconstructed from when you actually spoke, and skipped automatically when you're dictating into a one-line field where newlines don't belong. Format lists automatically also stops being aspirational: it gets the time it needs (a slightly longer deadline, only when it's on), a local model fallback on Macs without Apple Intelligence, and a minimal deterministic list pass so enumerated speech comes out as a list even when no model wins the race. As always, polish never delays your text past its deadline — the cleaned-up raw transcript is what lands if the model is slow, and a late result is discarded, never pasted over what you wrote.

*The spelling dictionary now catches words that just sound wrong. Teach Cyrano "Serrano → Cyrano" once and it now also fixes "Sarano" and "Serano" — the transcriber's next three spellings of the same spoken word — using sound-alike matching computed entirely from text, on your device. Guardrails keep it conservative: everyday words never fuzzy-match (saying "sat" will never become "SAT"), close-but-different words like "night" and "note" can't fire together, and the dictionary editor shows a small "sounds-like" tag so you can see when it stepped in. If it ever misbehaves for your vocabulary, Match sound-alike spellings turns it off. And with the opt-in Learn words you correct* (off by default, only meaningful with insert-at-cursor), Cyrano notices when you fix a word it just typed and offers the pair back to you in the menu bar — Add or Dismiss, never added silently. To spot the fix it reads the field it just typed into once, compares it to what it sent, and immediately discards the comparison: the only thing that ever persists is the word pair you confirm, on your device, in every tier.

Words that come out spelled right and meant wrong now fix themselves.

"Sink" when you meant sync, "cash" when you meant cache, "sin" when you meant SYN, "Serrano" when you meant Cyrano. A dictionary can't touch these: teach it "sink → sync" and it would rewrite your kitchen sink too. So Cyrano now reads the words around them. A swap happens only when the sentence agrees — "sink my devices" becomes "sync my devices", while "the kitchen sink" is left exactly alone — and it happens instantly, on your device, with no model involved and nothing sent anywhere. Cyrano's own name is the one word you shouldn't have to teach it: Serrano, Sirano and Serano all become Cyrano, unless you're clearly talking about the pepper. Beyond that you pick the vocabularies you actually live in under Settings → Dictate anywhere → Word senses: Software (sync, cache, queue, JSON, git commit, SQL, GUI, kernel), Screens and windows (pane, idle, modal, hover), Networks and security (SYN, NAT, DNS, route, packet), Business and meetings (profit, waive, counsel, moot point, per se), Finance (principal, capital), Music and audio (bass, chord). Cyrano's name, Software and Screens and windows start on, because a word is only ever swapped when its context agrees and an unused pack costs you nothing; the rest wait until you ask. When a word is genuinely ambiguous, Cyrano doesn't guess and doesn't slow you down: it leaves your word alone, and mentions the possibility to the cleanup pass that was already running for that dictation — never a new one, so this costs no waiting at all.

And it knows the difference between a pane and a pain.

The words a screen is made of are exactly the words a transcriber gets wrong: "the pain we split out of that window", "the agent has been idol for ten minutes", "dismiss the model". All three now come out right, from the sentence alone, silently. There's a new Screens and windows pack for them, and the ones that go wrong in a meeting rather than a terminal have their own — "that's a mute point", "bare with me", "per say", "peaked my interest", "this had an affect on latency". Software picked up the rest of a working day: get rebase becomes git rebase, "a sequel query" becomes SQL, "gooey" becomes GUI, "colonel panic" becomes kernel panic, "pseudo apt install" becomes sudo.

It learns your homonyms too, and unlearns them just as fast.

With Learn words you correct on, fixing a real word after a dictation now teaches a rule rather than a blunt substitution: Cyrano remembers what you were talking about at the time and offers "only change it when you're talking about calendar, devices" — you confirm it, as always, and it's listed under Word senses with the context attached. If it can't tell what you were talking about, it doesn't ask, because a homonym rule without a condition is worse than no rule. And it works the other way: if Cyrano swaps a word and you put it straight back, that rule turns itself off. You already answered; it doesn't ask twice. Anything turned off this way is listed with a Restore.

Dictation can pick its own transcription engine.

Sessions and dictation used to share one switch: turn on Fast transcription and both went to the cloud. A new Transcription engine picker under Dictate anywhere separates them — Automatic keeps today's behavior exactly, On device keeps dictation private and instant even while sessions use cloud transcription (and lets dictation pre-warm again, a real latency win), and Hosted sends dictation bursts to ElevenLabs under your own key even when sessions stay local, for accents and vocabulary the on-device engine struggles with. The trade-offs are stated where you choose: hosted opens its connection only while you hold the key and adds a short handshake before the first words land; if no key is set the choice falls back to on-device and the settings row says so instead of failing silently. "Where your data goes" now discloses session and dictation audio independently, so the privacy screen tells the truth for every combination.

Cyrano now works between calls, not just during them.

Cyrano has always been the fastest way to get a conversation into your agent. It is now the fastest way to get anything there. Grab the window in front of you, or whatever you just copied, and hand it straight to your connected agent — with no session running. The grab opens a channel only long enough to deliver it, then closes: no microphone opens, nothing is recorded, and nothing is added to your history. If you would rather keep it, "Start Session" is right beside it and the grab goes into the session instead. When nothing is running, the popover now shows a small Grab something card with the same actions, so this is one click rather than a hotkey you have to remember. Turn the pieces on in Settings → Context sharing; as always, nothing is ever read until you press something.

Attach the window you're looking at, without picking it.

Alongside "Attach a window…" (which shows the macOS picker every time), there is now Attach front window: it grabs whatever was in front of you a second ago — the doc, the dashboard, the error — with no picker step. It reads the window on your Mac and the session gets the text; the picture itself only ever leaves your Mac if you deliberately send it to your agent. This one needs the Screen Recording permission, and Cyrano says so the first time you use it. The picker route still works and still needs no standing permission.

Calls can name themselves from what's on screen.

Your meeting usually already has a name — it's sitting in the window title. Turn on Name calls from what's on screen (Settings → Context sharing) and, when you start a session, Cyrano reads the title of the meeting window in front of you (Zoom, Meet, Teams, Webex, FaceTime) and names the call after it. For the calls whose title says nothing useful — "Zoom Meeting" — it can read the meeting's name off the window itself, on this Mac, and discard what it read a moment later. It is deliberately careful: only meeting windows are ever read, only at the moment a session starts, and a title that is just the product name leaves the call to be named the way it always was, from how the conversation opens. Off by default, and it never interrupts a session start to ask for permission — without Screen Recording access it simply does nothing.

Paste a screenshot straight into a note.

Copy a screenshot, and the note field offers to take it. What the picture says is read on your device and joins the session's understanding immediately, so the analysis knows about the chart or the error you were looking at, and the note lands in the same place your typed notes do — timeline, map, exports. The picture itself is discarded once it has been read, unless you flip Keep the picture with this session, which stores it beside the session on that device only and deletes it whenever the session goes. Type nothing and the note names itself after what the screenshot said. Works on Mac and iPhone.

Choose Light, Dark, or Follow System.

Cyrano used to just go along with whatever macOS was set to, with no way to pin it. Settings → Appearance now lets you choose Light or Dark outright, or leave it on Follow System — the existing behavior, unchanged unless you pick something else. The choice applies everywhere at once: the menu bar popover, the Sessions window, and Settings on Mac, and the app on iPhone.

Your Context Digests now follow you across paired devices.

Create or edit a digest topic on one device and it appears on the other, along with its generated history. If both devices summarize the same window, Cyrano converges on one copy; if you delete a digest, an offline device cannot bring it back. Existing digest topics migrate automatically, and the sync payload remains end-to-end encrypted like session sync.

Let your AI assistant see — and talk with — what you're working on.

If you use an AI assistant on your Mac, you can now hand it your live Cyrano context. Turn on MCP assistants (Settings → Connections), and Cyrano hands the assistant a set of tools: it can read the session running right now — the transcript, what's been committed to, the open asks, your notes — or your whole day. It works with Claude Desktop and Codex out of the box (one click adds Cyrano to Claude Desktop; a paste sets up the rest), and with essentially any other assistant that speaks the same open standard — Cursor, Cline, Continue, Zed, Windsurf, LM Studio and more — via a copy-paste config. The connection goes both ways: the assistant can speak or write back into the live session (a reply is read into your ear like any other whisper), and it is no longer limited to adding a note: it can add, revise, or remove the session's tasks, open asks, decisions, next moves, subtext, watch-category hits, detected categories, and notes. The transcript itself stays untouched as the source record. Every contribution carries a visible label naming the assistant and whether it came through OpenAI, Anthropic, or another MCP client, and Cyrano keeps an AI-change history so an edit or deletion does not lose its provenance. You can also talk to the assistant the way you talk to any agent — ask out loud or from the note field and hear the answer, with a small picker to choose which assistant when more than one is connected. Settings shows each one live as it connects ("Claude Desktop — Connected"). You choose what it can see (just the live session, today, or all of them), and every session is still shown only as far as its own retention setting allows. The important part: this runs entirely on your Mac over a private local connection — nothing leaves the device, no account or cloud required. It's off until you turn it on, and one switch closes it.

Your assistant doesn't have to be on your Mac.

The route above is local, so it only ever reaches assistants running on the same machine. There's now a second one for the assistants that aren't: ChatGPT, Claude on the web, iPhone, iPad, and Android, and anything else that speaks remote MCP. Open Settings → Connections, pick your assistant, and Cyrano hands you an MCP URL and a one-time connection code — paste the URL into ChatGPT's developer-mode apps or claude.ai's custom connectors, enter the code when it asks you to authorize Cyrano, and the two are linked. The code works once and lasts fifteen minutes; when it lapses the screen says so plainly and offers you a new one, rather than leaving a dead code on screen with no way forward. After that the assistant can read your live session — recent transcript, speaker labels, what's hot, the questions waiting on you, attachments you deliberately sent — run Cyrano's workflows over it, and answer a question you asked out loud, spoken back into your ear. This is what makes the phone story work: start a session on your Mac, walk away, and keep talking about it in Claude on your phone. It is deliberately a separate route from local MCP — turning on one never turns on the other, and every connected assistant gets its own row in Settings that you can revoke on its own. Unlike the local bridge, this one does leave your device: it needs a backend or the Pro live relay, and only transcript text crosses the wire — never audio, never your local-only history, never anything you deleted. A session's retention setting still clamps what a remote assistant can see, and it stays request-driven: it pulls context while you're talking to it, it doesn't sit awake watching.

Your assistant comes pre-trained on Cyrano.

A connected assistant doesn't just get raw tools — it gets Cyrano's workflows as ready-to-run commands, in the assistant's own command menu (the + menu in Claude Desktop under "Add from cyrano"; /mcp__cyrano__… in Claude Code's slash menu). /cyrano:review looks over the live session (or the meeting or video it's capturing) for gaps, risks, and unanswered asks; /cyrano:catch_me_up gives you decided / still open / you committed to, in three tight lists; /cyrano:to_requirements turns the session into a numbered, owner-tagged spec; /cyrano:follow_ups drafts the messages your commitments imply; /cyrano:watch_notes has the assistant quietly file notes as things worth keeping come up; /cyrano:listen has it answer questions you ask out loud, spoken back into your ear; and /cyrano:prep pulls what still needs you from today before your next thing. Each command arrives with your context already attached — one keystroke, no "first fetch my session" dance. And the menu is alive: start a session and the in-the-moment commands appear; end it and the day-scoped ones lead. Cyrano nudges you at the right moments — right where "Connected" lights up in Settings, and quietly in the popover during a session — so the commands get found, not just shipped.

Where the free plan ends and Pro begins, drawn honestly.

Reading your finished sessions is free on every plan: once a session has cooled down — 45 minutes with no new transcribed audio — any connected assistant can read it, summarize it, turn it into requirements. The live wire is Pro: reading a session while it's hot, spoken replies, editing session items, and listening for your voice. The cool-down follows the audio itself, not the session timer, so ending a call early doesn't open a side door. When an assistant hits the line it says so plainly and points at the fix — including a one-time 24-hour live unlock, free, right in Settings → Connections → MCP assistants, so you can feel the live experience before deciding on Pro. One more thing for the private tiers: because assistants read the live session from memory, not from disk, even a session set to leave no record can be visible to an assistant you connected — the truest form of the relay. If you'd rather it never be, one switch in Settings → Plan & privacy ("Show the live session to connected assistants") turns exactly that off, and only that.

The note box now answers questions, not just takes notes.

That little field for jotting a note mid-session does double duty: type a plain line and it files as a note like always, but end with a question mark — "what did we agree Sully would do?", "have we talked about pricing yet?" — and Cyrano answers it, right there, from what's actually been said. The answer appears in a bubble under the field and drops into your transcript so there's a record of what you asked. It reads the live conversation while you're in a call, or the whole day's context between them, and it uses whichever engine you already have running: the on-device model, your own cloud key, or the cloud Copilot. Nothing new to set up — the field just grew a second job. (And if you've wired up your own agent, a small Model / Agent switch appears so you can send the question — with the full session as context — straight to it instead.)

Talk to your agent without starting a session.

If you've connected an agent, asking it something used to mean a session had to be running first — so a quick "what's on my calendar after this?" wasn't quick at all. Now, whenever an agent is connected, there's an Ask your agent button right in the menu bar (and on the iPhone home screen) that works from a standing start: tap it, speak your question, and the reply is whispered back, no session required. It's the same private path as before — your words go to the agent you connected and nothing else, the little exchange isn't filed as a session, and the button simply isn't there unless you actually have an agent to reach. On the Mac you can set a hold-to-talk key (Settings → Dictate anywhere → Talk to your agent): hold it, ask out loud, release, and hear the answer — the same walkie-talkie feel as dictation, pointed at your agent. On iPhone, wire it to the Action Button or a Shortcut ("Talk to Agent") for the same hands-free ask.

Now your agent can reach you, too.

Talking to your agent was a one-way street — you asked, it answered. Turn on Let your agent reach you (Connect an Agent) and it can send you a short note on its own: a job finished, a build broke, something needs you. It arrives as a normal notification with a "From your agent" card in the app — never a voice out of nowhere, so nothing ever talks over you. Only agents you've connected can send them, they're short text, and if your Mac was asleep when one fired, it's waiting for you when you're back. It's off until you turn it on, and turning it off closes the channel completely.

Your agent wakes up before you need it — and you don't have to wait around.

The first time you talk to a connected agent from a cold start, it could take a minute or two to come to life. Now, whenever you open Cyrano with an agent connected, it gets a quiet nudge that you're around — no content, just "they're here" — so it can warm up and be ready by the time you actually ask. And if you do ask and the answer's taking its time, you no longer have to sit on the "waiting for your agent" screen: a Start a session while you wait button lets you begin recording right away, with all the usual controls, and the agent's reply drops in when it lands. That pending question and its answer stay out of the saved session — you might have said something you never meant to keep — with a clear "won't be saved" note and a one-tap Keep as note if you do want to hang onto the reply.

Cyrano is better at telling your meeting apart, person by person.

Until now, everyone on the other end of a call was lumped together as one voice, so the analysis would say something like "the other side may be signaling swallowed disagreement" — useless when "the other side" is three people with three different agendas. Now that the copilot reads the same separated voices the transcript already shows (Speaker 2, Speaker 5, and so on), it keeps them apart in everything it writes: a subtext read names the specific person, and so does a task. And tasks now carry an owner — a small badge showing whose task it is, with the person's real name when you've named that voice — plus a filter at the top of the Tasks list to flip between Mine, Theirs (the ones to watch for someone else's follow-through), and All. A list you can tell apart is a list you'll actually use. As ever, the names themselves never leave your device: the copilot works with "Speaker 5," and Cyrano swaps in "Sully" for you on screen.

A new Decisions section captures what the room actually settled.

Tasks are one person's promise and Next moves are nudges for you — but a working meeting mostly produces decisions, and those used to scatter across the other lists as near-duplicate fragments. Now they get their own section, leading the session's items: the concrete outcomes the group converged on ("announce test launches in the bugs channel," "Sully explores staging and reports back"), each with who owns it and whether it was firmly decided or still tentative. Capturing them here is also what lets Next moves shrink back to genuinely open questions instead of restating things already settled. Decisions ride along into your exports too. And they're not a cloud-only trick: the on-device engines — Apple Intelligence, or the bundled model — surface decisions now too, reading the room by the same rules the Copilot does. (One honest note: on a machine with no model at all, the basic rule-based engine can't judge what a room settled, so those sessions still won't show them.)

The read-between-the-lines notes got a lot quieter — and sharper.

Subtext was drowning in "hesitation" flagged on every um, like, and mid-sentence restart, which is just how people talk in meetings — the handful of genuinely interesting reads (a swallowed disagreement, enthusiasm that doesn't match the words) were buried under dozens of them. Cyrano now treats ordinary disfluency as ordinary, holds hesitation to a real bar, caps how much any one moment can surface, and stops re-flagging the same person's same discomfort over and over — while deliberately protecting the swallowed- disagreement and enthusiasm-mismatch reads that are worth your attention. Your watch categories got the same treatment: a category like "chances to be more direct" used to turn into a paraphrase of the whole transcript, one entry per line; now it only surfaces genuine moments, capped, and only about you when the category is about your own habits — not coaching for people you can't act on.

Cyrano stops mangling the names it keeps mis-hearing.

Speech engines have never heard your coworkers or your internal tools, so one person can come through as Suly, Sula, Suey, and Swilly in a single call, and "Optimizely" as "optimizably" — and every misspelling pollutes the transcript and every bit of analysis built on it. There's now a small glossary under Settings → Names & glossary: add the people, products, and terms Cyrano keeps getting wrong, and it fixes their spelling in the transcript and everywhere they show up, catching close mis-hearings automatically and letting you spell out the wilder ones. Better still, it learns: the moment you give a voice a name ("Speaker 2 is Sarah"), that name goes into the glossary, so your next sessions get it right without you lifting a finger. And the glossary doesn't just clean up after the speech engine anymore — it now teaches it: your names and terms (and your dictation dictionary's corrections) are handed to the on-device recognizer before it starts listening, so "Optimizely" tends to come out right the first time instead of being fixed after the fact. The cleanup pass still runs behind it for anything that slips through. It's entirely on your device, off until you add your first name, and the glossary never leaves the machine — the recognizer it teaches is the one on your Mac, never a cloud one.

Cyrano names your calls for you.

A session used to be filed by nothing but its date and time; now it gets a real name, drawn from how the call opens, a few moments after it starts. Say what the call is at the top the way you naturally would — "okay, so this is our Q3 planning sync" — and Cyrano catches it and makes that the name; if nobody says it outright, it reads the opening and sums up what the call's about in a few words. It uses whichever engine you already have running — the on-device model, your own cloud key, or the fast rule-based floor when there's no model at all — so nothing extra leaves your device to do it, and it's timed to land quietly in the background without elbowing the live analysis. The name is always yours to shape: it wears a small suggested tag until you touch it, and you can edit it by hand, keep it with a tap, ask for a fresh suggestion, or swap in a nearby event from your calendar — both the calendar on your device and a connected Google account, with the meeting you're actually in listed first. Once you name a call yourself, the automatic titler never writes over it. The name rides along everywhere the session goes — the sidebar, the window title, your exports, and across sync. Reading your calendar is read-only and asked for only the moment you open that menu, never on a schedule, and Cyrano never changes or stores anything in it. It's on by default, with a switch under Settings → Session if you'd rather sessions stay filed by date. (One honest note: on the cloud Copilot tiers the name is still worked out on your own device for now.)

See the review and the map together — and watch them point at each other.

The Sessions window on Mac has a third view now, Both, right next to Review and Map in the same segmented control: the review list and the topic map, side by side in one resizable split. Click a task, an open ask, a bit of subtext, a watch-category hit, or one of your own notes in the review, and the matching point on the map lights up, pans, and centers itself so you don't have to go hunting for it. Click a point on the map and the review list scrolls to that line and highlights it, in the same color as the dot. It works across a walked trail and the map's filter panel too, not just a plain click. And the link isn't limited to the split view — select something in Review, switch over to Map on its own, and the map opens already focused on it, so the two tabs stay in sync even when you're only looking at one at a time. It's a Mac-only layout for now; Review and Map keep working exactly as they already do on iPhone and iPad.

Jot a note into the conversation while it's happening.

There's now a small Note to session field right in the live session — in the menu bar popover on your Mac, on the home screen on your iPhone. Type the half-thought the way you'd scribble it ("send notes to Ian") and it lands three places at once: in a Your notes section at the top of the session's items, on the map as its own point pinned to the exact moment you wrote it, and into the analysis itself — so the copilot reads your note as part of the conversation's context, not as an afterthought. Then the clever part: if you're running an on-device model, Cyrano waits a beat for the conversation to catch up and quietly sharpens your shorthand using what was actually said around it — "send notes to Ian" becomes "Send Ian notes about project X" when Ian was, in fact, just talking about project X. It's deliberately timid about it: it only fills in references the transcript makes unambiguous, it never adds tasks or opinions or anything you didn't write, a name or number the session never heard is rejected outright, and a note it can't improve is left byte-for-byte alone — which is the normal outcome, not a failure. Nothing is hidden, either: a refined note always shows "You wrote: …" right under it, reverting to your wording is one tap, editing a note pins it against any further meddling, and each note gets exactly one pass — no text mutating under you mid-meeting. The refinement runs entirely on your device, and your notes carry into the session record, sync, and the plain-text export in whichever wording you settled on — yours always wins. And if the automatic pass missed the moment — the clarifying line came a minute later, or it grabbed the wrong stretch of the call — you can do it by hand: choose Reinterpret with context on any note and Cyrano shows you the transcript with the lines it would use already ticked. Tick the ones that actually explain what you meant, hit Reinterpret, and read the proposed wording before deciding — nothing changes until you press Apply, and "nothing to change" is an answer it will honestly give. If you'd rather Cyrano never touch a note at all, there's a switch under Settings → Session (the hand-picked version still works — that one only ever runs when you ask).

Search across every session.

The Sessions window on Mac, and the equivalent on iPhone, now has a real search box. A few keystrokes of "cafe" find "Café," "mtg" finds "meeting," and a name or a half-remembered phrase turns up the sessions that actually said it. It searches everything a session holds — the transcript, the tasks and open asks Cyrano pulled out, the subtext and next moves, the decisions, your watch categories, the notes you typed mid-call, the questions you asked and the answers you got, even who was talking. The name of the call counts most of all — search for "vendor sync" and the session Cyrano titled that way tops the list — a hit on someone's name outranks one buried mid-transcript, and an exact match always beats a fuzzy one. Results show the couple of lines around the hit with your search terms bolded, so you can tell at a glance whether it's the session you meant before you open it. It searches your live session too, and it still works on sessions where you've turned transcript storage down to Minimal or None — the extracted items are there to search even when the words aren't. Runs entirely on your device; nothing leaves it to search.

Sync your sessions across your devices.

Turn on Sync (Settings → Sync) and pair your devices with a quick scan-a-code handshake — no account, no password, nothing to type. From then on, sessions and today's context replicate between them automatically, so a call you took on your Mac shows up on your phone on the train home, and the reverse — and a work Mac, a personal Mac, and your phone can all share one vault. It's end-to-end encrypted through your own iCloud: Apple relays only ciphertext between your devices, the keys never leave them, and nobody — including us — can read what's syncing. Unpair a device and it keeps whatever it already has; the other devices keep their copies too. It's part of Pro.

Browse your sessions by the device that recorded them.

Once you've paired more than one device, your Sessions window fills up with calls from all of them mixed together — which is usually what you want, but not when you're looking for "that thing I recorded on my phone." There's now a filter at the top of the Sessions list: leave it on All devices to see everything as before, or pick one to narrow the whole browser — day folders and search alike — to just what that Mac or that phone captured. Each session already carries a small badge of where it came from; this makes that a dimension you can actually navigate by. It only shows up once you have more than one device paired, so a single machine sees no new clutter.

Follow a session from your phone while it runs on your Mac.

Start a conversation on your computer, pick up your phone, and open Sessions: the running session shows a "Live on {your Mac}" badge and its transcript, map, and read fill in as it happens, a few seconds behind. It's the same private sync as everything else — nothing new leaves your devices — just quicker while a session is live, and it stops speeding up the moment the session ends. Handy for keeping an eye on a meeting the Mac is capturing while you're across the room.

Add notes to a running session from another device.

While you're following that live session on your phone, there's a note box right in its review — jot "circle back on pricing" or "she seemed unsure here," and within a few seconds it lands in the session on your Mac and even feeds the live analysis, exactly as if you'd typed it there. The same box works on any saved session, so you can annotate an old conversation from whichever device is in your hand. Your note travels the same end-to-end-encrypted path as the rest of your sync.

Ask your Mac's agent a question from your phone.

While you're following a session running on your computer, that note box does double duty: end your line with a "?" and instead of filing a note, it fires the question across to the computer — where your connected agent (or, if none, the model) answers it with the live session's full context, and the answer comes back to your phone a few seconds later. "What did she say the budget was?" from across the room, answered by the agent sitting on the machine that's actually in the meeting. Same private sync path; nothing new leaves your devices.

Everything cross-device got snappier — and easier on your battery.

A round of tuning under the hood, nothing to configure: an answer to a question you asked from your phone now pushes back the moment it's ready instead of waiting out the next sync cycle, so "a few seconds" really means a few seconds. A question typed at a connected AI assistant reaches it instantly rather than on its next check-in, and an assistant that's connected but quiet no longer drops out of the picker after a few idle minutes. And when nothing is happening — no session live anywhere, nothing to fetch — Cyrano now checks in a quarter as often as it used to, which your laptop's battery will appreciate. None of this changes what syncs or where it goes; it's the same private paths, paced better.

Your other device tells you when a session is live.

Pick up your phone while a session is running on your Mac and Cyrano says so, front and center: a "Live on {your Mac}" card sits at the top of the home screen, and tapping it drops you straight into following along. It works the other way too. Your Mac — always running in the menu bar — also raises a notification the moment a session starts on another device, even when you're looking at something else. And the important half: following a session only ever watches it; your phone never starts recording for a session running somewhere else.

A session doesn't have to be over the moment it ends.

Stop a session and Cyrano now holds the door open for a minute — pick it back up from the menu bar or from the Sessions window that just popped up, and it's the same session, not a new one: same transcript, same map, right where you left it. If you kept talking after you hit stop, that's not lost either — Cyrano keeps listening for that first minute (it stops on its own once the room goes quiet), and if you choose to continue, everything said since the end slides into the transcript exactly where it happened. Don't continue, and none of it was ever written down: that audio lives in memory only for the minute the offer is open, never touches disk, never leaves your Mac, and is deleted the moment the offer closes — whether it closes because the minute ran out or because you said no. It's on by default (Settings → Session, if you'd rather turn it off) and it's a macOS feature for now.

Dictate anywhere — hold a key, speak, paste.

Cyrano can now be your dictation tool, not just the thing listening in the background. Turn on Dictate anywhere (Settings → Dictate anywhere), record a shortcut, then hold it and talk: the moment you let go, what you said is transcribed on your device and dropped on the clipboard, ready to ⌘V into any app — an email, a Slack message, a code comment. Prefer hands-free? A quick tap of the same key keeps it listening until you tap again. The important part is what doesn't happen: a dictation isn't a session. Nothing is saved, nothing is sent, nothing shows up in review — it's transcribed, handed to you, and gone. The microphone light is on only while you're actually holding the key, and password fields are refused outright. If you'd rather it type straight into whatever you're using instead of copying to the clipboard, turn on Insert at the cursor — Cyrano asks for macOS's Accessibility permission the one time, and until you grant it dictation just keeps copying for you to paste. A little pill shows a live waveform and your words as you speak, so you always know it's listening. And here's the part no other dictation tool does: hold the key with ⇧ and what you said is also filed into today's context — classified right alongside your sessions, so "what did I fire off into Slack this morning" is something Cyrano can actually answer. (After any dictation, the pill also offers a quick ＋ Note if you decide a beat later that it was worth keeping — or flip on "Add every dictation to today's context" and it happens automatically.) Cyrano only types when there's actually a text field waiting for it; dictate with nothing focused and your words are saved instead — grab them any time from Last dictation in the menu bar (click, or right-click for copy/note). The menu bar icon lights up while it's listening, so you always know the mic is live. It's part of Pro and Copilot, and a macOS feature to start.

Dictation is ready when you are.

Press the shortcut and talk — no waiting for Cyrano to wake up. The on-device speech model used to load only when you pressed the key, which could cost a few silent seconds on the first dictation; worse, if you spoke quickly and let go before it finished waking, what you said could be quietly discarded — a beep, an unchanged clipboard, and your words gone. All three parts of that are fixed. The model now warms up the moment dictation is enabled (and re-warms after every burst), so the key finds it ready. Everything you say from the instant you press the key is held and handed to the model the moment it can listen — even a burst you finish before it's fully awake comes through whole. And that held audio behaves the way the rest of dictation does: it lives only in memory, is discarded the moment it's transcribed, and is never written anywhere. The microphone is untouched by any of this — it still opens only while you're holding the key, and the light still goes dark the moment you let go. On the rare occasion the speech model can't start at all, dictation says so immediately with a beep instead of letting you talk into a mic that was never going to hear you. One honest note: the very first dictation after turning the feature on may still take a beat while the model warms in the background — every one after that is instant.

Teach Cyrano your words, and let it clean up as you talk.

Dictate anywhere just got sharper, under Settings → Dictate anywhere. A new Spelling dictionary fixes words the transcriber always mishears: say a name once, correct it there, and every future dictation swaps it in — matched entirely on your device, never sent anywhere. (Your corrections now also prime the on-device transcriber before it listens, so the right spelling increasingly just comes out of the model itself.) Three more toggles layer on top: Clean up filler words strips the "um"s and "so, yeah"s, Fix spoken corrections catches you correcting yourself mid-sentence ("no wait, make that Tuesday") instead of transcribing both halves, and Format lists automatically turns a spoken list into a real one. Where a toggle needs more than pattern-matching to do well, Cyrano briefly asks a language model — on-device first, where that's available — and simply delivers the plain version if the model doesn't answer in time; either way, a dictation is never any less private than it already was.

Capture a thought on your iPhone too — and see a session live on your Lock Screen.

The Mac's dictate-anywhere needs a text cursor to insert into, which iPhone doesn't really have, so iPhone gets its own version: press and hold the hero button on Home, say the thought, let go, and it's noted straight into today's context — no session, nothing saved beyond the note itself. And while a session is running, a Live Activity keeps it visible without opening the app — glance at your Lock Screen or the Dynamic Island and see it's live, with the elapsed time ticking, right where your other live activities show up.

Reanalyze a session after the fact.

If a session's analysis missed something — the wrong engine was selected at the time, or it just had an off moment — right-click it, or open it and use the toolbar, and choose Reanalyze. Cyrano re-runs the whole session through whichever engine you currently have selected: Reanalyze with Copilot sends it through the cloud pass, Reanalyze on device re-runs it locally end to end, and on-device you can even pick a different prompt style to compare. You always see a before/after comparison and choose whether to keep it — nothing replaces your original analysis until you say so. It needs the session's transcript to still be around, and it politely declines while that same session is actively live (one engine can't serve both at once).

Fix today's context by just saying what's wrong.

Today's context — the running document of what your sessions produced — is assembled from what Cyrano heard, and what it heard isn't always what you meant. Now you can correct it in plain language. Open the menu on any section, choose Refine this section…, and type the change the way you'd say it to a person: "change Voice 2 to Jim", "drop anything about the offsite", "make these imperative". Only the change you describe is made — everything else is left alone, and your captured items stay exactly as they were captured; a refinement is written as the section's note, so the model never quietly rewrites the record underneath you. If the instruction doesn't apply — you asked to rename someone who isn't in there — it says "nothing needed changing" and leaves your notes untouched, rather than inventing a plausible-looking edit to seem useful. Changed your mind? Undo refinement puts the section back exactly as it was. This runs on your device, on the Apple Intelligence model, and nothing leaves your Mac. If that model isn't available on your machine, Cyrano won't quietly reach for the network instead — it tells you, and offers: you can send that one section to your backend for that one refinement, and you'll see the exact text before it goes. Refining the whole day asks a second time, because that's your entire day in one payload. Nothing is stored or logged at the other end. And on the two private tiers, where nothing you say leaves the device at all, this option isn't offered at all — not switched off, not there. You can turn the fallback on for good, or leave it as a per-refinement ask, under Settings → Today's context.

Try Pro free for three days — no signup, no card.

The moment you install Cyrano on a Mac, the full Pro smart layer turns on by itself for three days: the copilot running entirely on your device, private and offline, so you can feel what it does before you decide anything. There's nothing to enter and nothing to cancel — when the three days are up it simply steps back to Free, and if you want to keep it there's a one-time Lifetime Pro unlock right where the countdown was. Settings → Plan & Privacy shows how much trial time is left. A couple of honest notes: the trial is one per Mac and it follows the machine, so reinstalling won't start it over — and it's a macOS feature for now. Give it a real conversation or two; that's the whole point.

The on-device copilot stopped letting commitments slip.

If you run the private Pro smart layer, you may have noticed it could be… moody about what it caught — you'd say "I'm going to commit to sending that letter before work is over" and nothing would land. Fixed, twice over. First, a rule-based net now reads every line alongside the model, so the concrete stuff — "I'll…", "I need to…", "I'm gonna make sure…" — simply can't be dropped just because the model had an off moment; whatever the model misses, the net catches, and a quick follow-up pass tidies the wording and picks out the deadline. Second, the on-device model itself now right-sizes to your Mac: machines with 16 GB get a noticeably smarter model, 24 GB and up get the biggest one we ship, and smaller Macs keep the light one so a session never crowds out the call you're actually on. There's a quality override in Settings if you'd rather choose yourself, and whatever's already downloaded keeps working until you fetch the new one — nothing stops mid-stride.

Your own words, credited to you.

With "Recognize my voice" on, a moment of doubt — a new headset, a scratchy mic, someone else's voice bleeding in from speakers — could tip Cyrano into labeling your line as the other person's, which meant your commitment showed up on their side of the ledger. Now a doubtful match just stays honest: only a confident "yes, that's you" claims a line as yours, and anything less falls back to the ordinary speaker detection instead of guessing against you.

It learns your voice on every device — not just the first one.

You don't sound the same through your laptop mic, your AirPods, and the interface on your desk — the same voice lands in a slightly different place through each one. So "Recognize my voice" used to have a quiet blind spot: it learned one signature, and the moment you switched headsets that signature could stop recognizing you, dropping your own lines back to "unknown" until it caught up. Now Cyrano keeps a separate, private signature for each device and builds every one silently in the background — no setup step, nothing to read aloud. Pick up a new headset mid-week and it leans on what it already knows about your voice to keep crediting you correctly while it learns the new device, then tightens up once it has one of its own. It's all still on-device, still behind the same opt-in, and "Forget my voice" wipes every device at once. (Macs get true per-device precision; on iPhone it's per route — your earbuds versus the phone itself.)

Say you're transcribing, and Cyrano notes it on the record.

A small piece of good manners: if you say something out loud like "just so you know, this is being transcribed by AI," Cyrano now hears it and marks the session as announced — a quiet badge in the review so there's a record that the room was told. It only counts when you say it (a voice bleeding in from across the table can't disclose on your behalf), and it simply reads the words already in your transcript — there's no extra listening going on. It's the first step toward giving the people around you a real say in what's captured; for now it's about making the disclosure itself visible.

Send your sessions wherever your work already lives.

Cyrano was never meant to be the final home for what it hears — it's the connective tissue that moves the good stuff to wherever your intelligence already is. So there's a new Integrations screen in Settings where you register destinations and finished sessions flow straight to them, right from your device. Point it at a webhook — any URL that should get a JSON copy of each session (signed, if you set a secret, so your receiver can prove it came from you); an Arepo knowledge base, by pasting an upload link, so your calls become searchable documents your AI can draw on; your Google Drive, where each session lands as a file; your Google Calendar, where the commitments and asks Cyrano hears turn into events on the day they're due; or a connected agent's endpoint. Google connects right on your device — Cyrano signs you in and talks to Google directly, so your account and your sessions never pass through our servers. Send a session by hand from the "Send to…" button, flip a destination to fire as each call finishes, or set it to a once-a-day digest — Cyrano rolls that day's sessions into a single hand-off, so your agent or your notes get one clean "here's today" instead of a trickle. You choose the shape: the whole rendered session, or just the extracted items — commitments, asks, subtext, watch-list matches — as structured data something else can act on. And it all respects the privacy line you've already drawn: a destination can only ever send less than your transcript-storage setting allows, never more, and you can force any destination to "items only, no transcript" on its own. Nothing routes through our servers — the device talks to your tools directly. It's a Pro feature (and included with Copilot or your own backend); more destinations are on the way.

Pick your plan — and see exactly what it sends.

The "Where your data goes" screen used to just tell you what left your device; now it's where you choose. Four plans, laid out plainly: Free — on-device transcription and the live map, nothing ever leaves this device. Pro — the full smart layer, still entirely on your device, on a local model, unlocked with a one-time license. Copilot — the fast, highest-quality cloud copilot, on our API. Custom — point Cyrano at a backend you run, or bring your own API key. Tap a plan and, if you already have what it needs, Cyrano switches to it on the spot; if you don't, it shows you the one step to turn it on — right there, no hunting through Settings. You can even switch mid-conversation — flip from the cloud copilot to the on-device one, or off entirely, and Cyrano changes engines under the hood without dropping the session: the transcript, the map, and the live capture all carry straight on. As you move between plans the privacy breakdown redraws for each one, so you can see the trade before you commit: what stays on your device, what leaves, and where it goes. And the controls that actually change that — how long transcripts are kept, the on-device-versus-cloud switches, what you let Cyrano attach — now live on the same screen, so the moment you flip one (turn on Fast transcription and your audio starts going to ElevenLabs, say) you watch the honest line about it light up right above. One place to connect the dots between the plan you're on, how private it is, and every knob that moves the needle.

Your keys, wherever you need them.

Bringing your own keys used to mean hunting through the self-hosting settings, and it wasn't obvious it was even meant for you. Now every plan puts the right key right where you'd look for it. Turn on Fast transcription or Fast voice and the ElevenLabs field appears in the same place you flipped the switch — one key, billed to your own account, on any plan. And Pro now has an opt-in "use a cloud model with your own key" tucked under an Advanced disclosure: it lets you point a session at your own Anthropic or OpenRouter key when you want the reach of a big cloud model, then drop straight back to the private on-device layer for everything else — one button pins the engine, another line puts you back. It's honestly labeled about what it does: cloud sessions leave your device (your on-device engine stays the default and untouched), and because your key runs on your own bill, that usage isn't metered. It needs a backend to relay through — your own, or ours with an access token — and the screen says so instead of showing you fields that quietly do nothing. Copilot stays the simple, metered subscription it always was.

Run the copilot on your own cloud key — with no server in the loop at all.

Bringing your own key used to route through a backend, yours or ours. Now Pro has a direct path: pin the engine to Your key · direct (Settings → Session engine, or the Advanced disclosure under bring-your-own-key) and your Mac talks straight to Anthropic or OpenRouter — no Cyrano server anywhere in the loop, nothing relayed, billed to your own account and never metered by us. It's the same private on-device pipeline you already run, just with a frontier cloud model at its head instead of the local one, so you get the reach of a big model on the calls that want it and drop back to the fully on-device layer for everything else with one tap. Choosing a model is easier too: type or paste a model id, or hit Load available models and pick from the live list your key can actually reach. Your key lives in the Keychain and is never stored on a server of ours. Two honest notes, the same ones as always: a direct session's transcript does leave your device to reach the model you picked (your on-device engine stays the untouched default), and this only ever runs when you explicitly pin it — Automatic never spends your key unasked. Pro only, and a macOS-first power feature.

Run the engine you want, when you want.

If you've got more than one way to power the smart layer set up — a Pro license and a subscription, say, or your own backend alongside ours — Cyrano no longer just picks for you silently. A new Session engine control in Settings lets you leave it on Automatic (Cyrano prefers your private on-device Pro layer if you have it, then your backend, then nothing — same as before) or pin a specific one: force the cloud copilot even with Pro unlocked, force everything on-device, or turn the smart layer off entirely for a session. It only ever offers the engines you've actually configured, and if one falls away — a license lapses, a backend gets cleared — it quietly falls back to Automatic rather than leaving you stranded. Handy for power users and for anyone who just wants to know, and decide, which brain is running.

Let the room know Cyrano is listening.

Recording quietly is easy; disclosing it honestly should be too. Now, when a session starts, Cyrano can announce itself — a soft chime followed by a spoken line, "This call is being transcribed by A.I." — so nobody is recorded without a heads-up. It plays once, at the top of a normal session, and it always finishes: talking over it won't cut it off, and it won't get elbowed aside by a whisper. A couple of honest notes: it plays on your device, so you and anyone in the room hear it — remote callers on the far end don't, unless you route Cyrano into the call (that's coming later). It's on by default — recording disclosure is the right default, and in places that require everyone's consent to record, the safer one — and you can turn it off under Settings → Whispers.

Decide how much Cyrano keeps in its own words.

Separate from how long a session is kept, you can now choose how much of the actual transcript is ever written down — a simple three-way choice in Settings. Full keeps the complete transcript, as always. Minimal throws the transcript away and holds onto only the lines that actually produced something — the sentence behind each commitment, ask, or watched category, plus the line just before it for context — so you keep the "why" without keeping every word. None keeps only what Cyrano concluded — the commitments and categories themselves — and no verbatim lines or quotes at all. It's set to Full to start; dial it down whenever you'd rather Cyrano remember the gist than the transcript. (One honest note: when analysis runs on Cyrano's servers, the transcript still has to reach them to be read — this setting governs what's kept on your device; the fully on-device tier is the one where nothing is sent at all.)

Cyrano flags what looks personal — and now points at the exact words.

Turn on Flag personal information (Settings → Personal information) and lines that look like an email, a phone or card number, or that stray into personal territory — family mentions, childhood stories, that kind of thing — render fainter in the transcript and today's context, each with a small "Personal info" tag and a one-click Remove personal info. New in this pass: the flag doesn't just dim the whole line and leave you hunting for why — it underlines exactly what it saw, the address, the number, the phrase, so you can judge the flag at a glance. You can add your own phrases to watch for (a project codename, a pet's name), and the whole thing is plain pattern matching on your device — no model reads your transcript to do it, and nothing leaves the machine. Removal stays deliberately in your hands: Cyrano flags, you decide.

Keep exactly the parts of a conversation worth keeping.

Every extracted item — a task, an open ask, a topic on the map — now has a quiet keep-or-drop control right next to it: swipe or right-click any item and mark it "don't keep," and it drops out of exports, shares, and Obsidian notes while your underlying session stays exactly as recorded. Change your mind any time — a dropped item is greyed out with a "Not kept" tag, never deleted, and one tap brings it back. It's entirely local and non-destructive: nothing is rewritten, only what travels onward is filtered. (You may also notice "Commitment" now reads as Task everywhere in the app — same feature, clearer name.)

Take everything with you, any time you like.

There's now one button — Export everything, in Settings — that writes your entire Cyrano history out as plain Markdown: every stored session, every day document, into a dated folder you pick. One file per session, named by date, with the analysis laid out under headings and the transcript at the end; one file per day for the "today's context" rollups, including anything you wrote or reworded by hand. A README sits alongside them explaining what's there. Nothing in that folder needs Cyrano to read it — no app, no account, no key, just text files any editor can open, and it's yours to keep whether or not you keep using Cyrano. Sessions you redacted export redacted, lines you chose not to retain stay out, and anything you reworded arrives in your words. You can leave the transcripts out entirely and export only what Cyrano concluded. The README is equally straightforward about what isn't included: sessions set to ephemeral were never written down in the first place, 24-hour sessions that already expired are gone, and there's no audio — there never was any, because Cyrano transcribes as it listens and never records to disk. Each export goes into its own dated folder, so running it again next month won't overwrite the copy you made today. And it goes both ways now — see Restore an export above for putting one of these folders back.

Hand Cyrano what you're talking about.

Cyrano hears the conversation, but until now it couldn't see the thing the conversation was about — the ticket you just copied, the doc open in the next window. Turn on Context sharing in Settings and you can hand it over, deliberately, one piece at a time: an Attach clipboard action (and a global shortcut on Mac) grabs whatever you've copied, and on a Mac you can snapshot a single app window straight from macOS's own window picker — no standing screen-recording permission, you just pick the one window each time. Every attachment always asks where it goes — into this session's analysis, or straight to your connected agent — so nothing is ever routed by surprise. What reaches the analysis is only ever text: a window snapshot is read on your Mac and only the words travel; the picture itself leaves the machine only if you explicitly send it to your agent. Attachments are used once and discarded by default, with a per-attachment "keep with session" toggle for the ones worth keeping on the record. It's off until you turn it on, and Cyrano never so much as glances at your clipboard except at the exact moment you press attach.

A companion for your dictation, right alongside it.

If you dictate with a tool like Wispr Flow or Handy, Cyrano can ride along: the moment your dictation app opens the mic, Cyrano starts a short burst — your mic, transcribed and sorted on-device — so what you just spoke turns into commitments, asks, and the rest without you lifting a finger. Prefer a key? Record the same shortcut your dictation tool already uses as a shadow hotkey, and one press starts a burst — Cyrano only listens for the shortcut, so the keystroke still reaches your dictation app — and pressing it again stops the burst. A burst also ends itself after a few seconds of quiet or its time window, whichever comes first; and if you're still going as the clock runs down, an Extend button appears right in the menu bar to buy another window with one tap. That same one-tap extend now shows up for any session about to hit its limit, burst or not, so a long call never gets cut off mid-sentence. It's off until you turn it on, under Settings → Dictation companion. Mac only.

An update no longer costs you the conversation.

Cyrano used to have to be quit to install an update — and if a session was running, that was the end of it. Now, if you install an update while a session is live, Cyrano holds the session, relaunches into the new version, and quietly picks the conversation right back up — the transcript intact, the map where you left it, still listening. A small note tells you it resumed and which version you're on. The same rescue covers an unexpected quit or crash: as long as it happens inside the session's normal lifetime, you come back to a live session, not a dead one. (Sessions set to expire immediately are the one exception — they leave nothing on disk to come back to, which is the whole point of that setting.)

The session map came alive — and stays crystal clear.

The map that lays out a conversation — topics as circles, every commitment, open ask, and observation hanging off the moment it came from — now moves like a living thing: topics drift and settle into place, new points ease in as the conversation grows, and you can grab any node and pull it while the rest of the map flows around your hand and stays where you leave it. Point at anything and its connections light up in that item's own color; click to pin that focus while you read the details. And it's legible at any size — every element resizes with the zoom and re-renders sharp rather than being blown up like a blurry image, so a whole conversation fits into a small space as clean, tidy dots and opens up crisply as you zoom in; on a Mac you can scroll to zoom right where the pointer is. All that motion settles to a complete stop within a second or two, so a map left open through a long call costs nothing while it sits idle. And while a session is live, the topic the conversation is landing in right now wears a soft, breathing glow — so you can always see where you are on the map as it's being drawn.

It reads left to right — and fans out where it's busy.

The map lays a conversation out along its timeline, earlier on the left and later on the right, so you can always tell which way it's flowing. Where the talk was quiet, topics sit along a single line; where it got busy, they fan up and down into stacked lanes instead of piling into one crowded column — so a dense stretch spreads into something you can actually read, while the whole thing keeps its left-to-right direction and never doubles back on itself. A subject that comes back much later still appears as its own point further along, with a link you can trace to the first, so you see not just what was discussed but when, and how the conversation came back around to it. And rather than treating every passing remark as an equal topic, the map ranks each one by how much of the conversation it holds and what it carries — a commitment, an open ask, a category you're watching, or a link to other important topics all count for more. The overview shows just the handful of topics that matter most — so a five-minute chat and a three-hour one are equally readable — and the smaller ones fade in as you zoom into a region. Topics holding something you care about wear a subtle colored halo so your eye lands on them, and it all updates live as the conversation produces commitments and hits your watch categories. And now that Cyrano tells voices apart, a real back-and-forth between people counts for more than one person talking — and on a multi-voice call you can tap a name to see just what that person's part of the conversation touched.

A hard call no longer shatters the map.

Some conversations don't cluster: a bad connection, a noisy room, three people over each other — the transcript comes through as fragments that don't resemble one another, and the map used to take that literally. Nearly every line became its own point, and a twenty-minute call could sprawl into hundreds of near-duplicate dots webbed together by thousands of faint lines. It read like static, and it moved like it too. Now the map has a ceiling on how many points it will draw: past it, it groups more coarsely instead of shattering — folding the fragments together until the picture is something you can actually read. Nothing said is dropped; it's grouped, and every grouped point still opens to show you the lines it holds. The connecting lines got the same treatment — each topic keeps its few strongest links rather than a thread to everything it faintly resembles, so the shape of the conversation shows through instead of a haze. (The path the conversation actually walked is never thinned.) The honest trade: on a session that dense the grouping is broader, so two related-but-distinct subjects may share a point — which is the right call when the alternative is an unreadable web. Underneath, the map is now assembled in the background rather than on the spot, so it no longer stutters the app while it thinks — on a long live call, it simply keeps up.

Walk the conversation — and see what set each thing off.

The map is no longer just something you look at; it's something you move through. Click any point to open it, then step forward and back through the conversation with the arrow keys or the arrows on the card — the map walks you from one moment to the next, bringing each to center as you go. Hold Shift and click to string moments into a bright trail — the ask, the topic it landed in, the commitment that came of it — laid out in order as a single thread you can read top to bottom. And every commitment, open ask, or watched-category hit now shows the line that actually set it off: the exact sentence that was said, with the moment just before it for context, right there on the card — so you never have to wonder what turned a passing remark into a commitment. (Shift-click and the arrow keys are Mac; on iPhone the card's own arrows walk you through.)

Optional: a map that learns what you care about.

New and experimental, off until you turn it on — a small Adaptive toggle in the corner of the map. Flip it on and Cyrano starts paying attention to how you use the map: the topics you click into, drag around, or linger on. The more you engage, the more it floats those topics — and the threads leading to and from them — up toward the top, so what matters to you keeps surfacing without you having to hunt for it. The categories you've defined to watch count for the most of all. Because you opted in, it now remembers between launches, so it keeps getting to know you over days and weeks — while gently letting older interests fade, so it tracks what you care about lately rather than everything you ever glanced at. It's a gentle layer on top of the map you already have: leave the toggle off and nothing changes, everything it learns stays on your device, and you can wipe the slate any time — right-click the toggle and choose Forget what it's learned. We're shipping it early on purpose, to let it prove itself over real use.

A live minimap, right in the menu bar.

You no longer have to open the full Sessions window to see the shape of what's being said. While a session is running, open Cyrano from the menu bar and tab over to Map — the active conversation's map, live and interactive in the popover. Scroll to zoom, drag to move around, and click any point to read the exact commitment, ask, or category behind it, without ever leaving the menu bar.

Choose which mic hears you — and keep your headphones sounding great.

If you wear AirPods or Bluetooth headphones, you may have noticed the audio playing in them drops in quality the moment a session starts. That's a hard limit of Bluetooth itself: a headset can play in rich stereo or run its microphone, never both at once — so the instant Cyrano opens the headset mic, everything playing through it collapses to muffled call quality (and it can dull how you sound to people on a call, too). Now, on a Mac, you can pick exactly which microphone captures your voice. Open Cyrano from the menu bar and choose your built-in mic, a USB or wired mic, or any input under Voice input — leave it on Automatic to follow the system default as before. Point Cyrano at a non-Bluetooth mic and your headphones never get pulled into call mode: they stay in full, crisp stereo the whole session. You can switch mid-session, and Cyrano moves to the new mic without missing a beat.

Every session can graduate into your Obsidian vault.

Cyrano's sessions are ephemeral by design — they expire and clear out after a day — but the ones worth keeping no longer have to vanish with them. Point Cyrano at an Obsidian vault and each session is written out as a clean Markdown note: YAML frontmatter with dates, duration and per-section tags (#cyrano/commitment and friends), a heading per category you care about, and — if you want it — the full transcript folded in. A session about to expire is exported the instant before it's purged, so a fleeting 24-hour session graduates into a permanent note instead of disappearing. You can also export any single session on the spot from the Sessions window, or "Export all now" from Settings. Choose exactly which sections travel (one, some, or all) and whether the transcript comes along — redaction is always honored. Set it up under Settings → Obsidian export with a vault picker. Mac only for now.

Get any session out — to anything.

A session is only as useful as the tools you can hand it to, so Cyrano now shares like a first-class citizen. There's a real Share button on every session — live or saved — that opens the system share sheet: send a session to Mail, Messages, Notes, AirDrop, or any app you've taught your Mac or phone to receive things, including your own AI. Prefer a file? Export to File writes the session as clean Markdown, plain text, or JSON, named to line up with your notes. And you no longer have to take the whole thing: right-click (or long-press) any single line — a commitment, an open ask, one turn of the transcript — to copy or share just that. Redaction is always honored, and it all works the same on Mac and iPhone.

Tell everyone on the call apart.

When Cyrano captures a meeting or video on your Mac, the far side used to arrive as one undifferentiated voice — everything the other end said, no matter who said it, filed under a single label. Turn on "Tell speakers apart" (it appears under the capture controls whenever you're capturing system audio, and it's off until you flip it) and Cyrano hears the distinct voices on that feed and keeps them apart: the transcript reads as Speaker 2, Speaker 3, and so on, each in its own color, so a three-person call finally looks like a three-person call. Right-click any line to give a voice a real name — "Sarah," "the client" — and it carries through the whole session, the transcript, and every export, so what you hand your notes app or your agent already knows who's who. You are always simply You. This happens entirely on your device and only in the moment: Cyrano listens to how a voice sounds just long enough to group it, then lets that go — nothing about a voice is ever recorded, saved, or sent anywhere. All that's kept is the label and any name you choose to give it. It's off by default because it bundles an on-device voice model that adds to the app's size. Mac only, since it works on captured call audio.

The copilot knows who's who on a multi-voice call now.

When Cyrano tells the voices apart on a captured meeting (Tell speakers apart), the analysis understands them as distinct people too. Before, everyone on the far side was folded into one "other side" before the copilot ever read it — so the subtext could announce that "the other side seems hesitant" about what was really three people, one of whom just paused for breath. Now the copilot sees Speaker 2, Speaker 3, and so on as separate voices and reads each on their own, and the names you gave them are filled back in when you look — the model itself only ever sees the numbers, so the names you attach to people never leave your device. The same pass got quieter across the board while we were in there: it stopped mistaking filler and mid-sentence self-corrections for "hesitation," it holds subtext to the few reads genuinely worth surfacing instead of one for every pause, and a watch category you defined now reports what it actually caught rather than parroting the transcript back at you. Sharper on a crowded call, and less noise on every call.

Tap any voice to rename it.

Every speaker tag in a transcript — You, a numbered Speaker, or the general "other side" label — can now be renamed with a tap or from its row's context menu, not just the ones Cyrano already told apart automatically. Name someone once and it carries through the whole session: the transcript, the map, copy/share text, Obsidian notes, and search. It's still per-session and stays on your device, exactly like the automatic speaker names it extends.

Cyrano can learn to recognize you.

You may have noticed your own lines sometimes show up as "Unknown" — the old way of telling your voice apart (how loud and how close you are) is easily thrown off by a different mic or a quiet moment. Turn on "Recognize my voice" in Settings → Your voice, and Cyrano quietly learns what you sound like from your own speech — no setup, no reading a script, nothing to record. Once it's learned (usually within a session or two), your lines read as You instead of Unknown, everywhere — and it can tell you apart from someone else in the room, so a face-to-face conversation gets clean You / Other labels too. It's off until you turn it on, learned and used entirely on your device, and never leaves it — this is the one thing Cyrano keeps a lasting signature of, and it's yours alone: the "Where your data goes" screen says so plainly, and one tap — Forget my voice — erases it for good.

Start with no backend at all.

Cyrano no longer needs a server to get going. Open it fresh, start a session, and transcription and the live topic map run entirely on your device — nothing to set up, no account, no URL to paste, nothing streamed anywhere. The hosted copilot is still there whenever you want the extra smarts; this just means the free, on-device core works the moment you install it, out of the box.

Lifetime Pro: the whole copilot, entirely on your device.

A new one-time Lifetime Pro unlock runs Cyrano's full smart layer — commitments, open asks, the quiet subtext, and next moves — with no backend and nothing leaving your machine. On a Mac with Apple Intelligence it runs on Apple's own on-device model; on other Macs it uses a small model Cyrano downloads once and keeps local; and a fast, rule-based floor sits beneath both so the essentials work on any device, offline, immediately. It's an opt-in, all-local way to run the smart layer — the hosted copilot you may already use stays exactly as it is. Unlock it once with a license key under Settings → Lifetime Pro (or a cyrano://unlock link) and it's yours for good — one payment, no subscription, no sign-in, and the key rides a generous offline grace window so a trip or an outage never locks you out.

Report a bug right from the app.

Something not working? Settings → Report a Bug sends a short report straight to us — what happened, your OS and app version, and, if you want a reply, your email. It never includes your transcripts, notes, or audio; only the handful of fields you actually see on the screen before you send it.

"Never send anywhere" now covers the live relay too.

A session tagged so that it never leaves the device was still opening the opt-in Pro relay socket, which is the channel that pushes your live context out for a connected agent to poll. Blocking delivery and relaying live context are the same promise from where you sit, so they are now the same switch: a blocking tag stops the relay from starting, and tagging a running session that way closes a relay already open. Only relevant if you had turned the relay on deliberately; it is off unless you asked for it. Related: a tag that blocks delivery now describes itself as "never sent to your destinations" rather than "never leaves this device", because on the hosted engine the transcript still reaches the backend for analysis — that's governed by your engine choice, and a tag shouldn't claim otherwise.

Notes you typed during a call now survive the update that interrupted it.

When a session was picked back up after an app update or a crash — the "Resumed your session where it left off" case — the notes you'd typed into it, any questions asked from another device, and the record of changes a connected assistant had made were dropped from the saved session a few seconds later. The transcript itself was always fine; it was the typed material around it that went missing, which is the part you can't get back by listening again. The resumed session now carries all of it forward. If you sync to another device the notes came back on their own within a minute, so this was invisible there; on a single device they were simply gone.

Asking a question on-device works during a real conversation, not just a short one.

Typing a question into the note field while running on-device intelligence would answer fine for the first minute or two of a call and then start replying "this device's engine can't answer questions yet" for the rest of it. The question was being handed the entire conversation, sized for the hosted copilot's limits — far more than an on-device model can read at once, and past that point it simply failed. Questions are now sized to the engine that's about to answer them, keeping the most recent part of the conversation (which is what you're almost always asking about) and marking clearly when older context was left out. When an on-device engine genuinely can't take a question, it now says which thing to change instead of implying the feature is unfinished: no local model downloaded is a different message from the Light quality tier, which doesn't run free-form questions at all.

The map no longer flashes a zoomed-in frame when it opens.

Opening the topic map, or switching to it, could paint one garbled, over-zoomed frame before it settled — the canvas hadn't reported its real size yet, so the very first layout was scaled off a placeholder size (or a momentarily-too-wide split pane). The map now holds its points back until the size is stable, so it always opens clean instead of snapping into place.

Holding the dictation shortcut could crash Cyrano outright.

On some Macs, the small pill that shows a live waveform while you're dictating would occasionally fight itself over its own size the instant it appeared — two different pieces of layout code disagreeing on the pill's dimensions, each correcting the other in an endless loop until the app ran out of stack and crashed. Fixed: exactly one piece of code decides the pill's size now, so the fight can't start.

Insert-at-cursor no longer touches your clipboard.

Dictating with Insert at the cursor turned on used to work by quietly copying your transcript onto the clipboard, synthesizing a paste, then restoring whatever was there before — which meant every dictation briefly read and overwrote your actual clipboard, even though none of that ever showed on screen. It now writes directly into the focused field for the great majority of apps and never touches the clipboard doing it; the old copy-paste-restore dance is now only a fallback for the rare app that refuses a direct write.

The sessions list could show two rows drawn on top of each other.

Starting or ending a session while the Sessions window was open could leave a stale "Today" row visible right under the new current-session row, so it looked like two things were sharing one spot in the sidebar. Fixed at the source — the list now rebuilds cleanly at exactly the moments that used to confuse it, instead of animating a diff that could leave old rows behind.

iOS sessions could silently stop transcribing.

If a whisper played, or the recording-announcement chime fired, while a session was capturing on iPhone, the shared audio engine those used could quietly break the transcription tap underneath it — the mic indicator stayed lit and everything looked normal, but nothing after that point was actually being written down. Capture and playback now run on two fully separate audio engines, so one can never disturb the other.

The menu bar popover could jump to the wrong screen.

On a multi-display Mac, opening or resizing the popover — switching tabs, a callout appearing — could make it re-derive its position and land on a completely different monitor than the one you were looking at. It now pins itself to the screen it opened on and snaps back if anything ever tries to move it off that screen.

So could the Sessions and Settings windows.

The same multi-display fault, on the two windows that had no protection against it. Clicking something that changed what the window was showing — the + beside the note field, the tag editor opening — could throw the whole window onto another monitor mid-click. Closing it on the screen you were using and opening it again could put it on the other one too, because the position it saved on the way out had been mangled the same way. Each window now knows which screen is its own, snaps back if anything moves it off, and remembers that across quitting the app. Moving one yourself is unchanged: drag it to another display and that is where it lives from then on. If you move windows with a keyboard shortcut or a window manager instead of dragging, Cyrano can't tell the first attempt apart from the fault and will undo it — press again and it goes where you asked, for good.

Redaction works on the on-device plans now.

If you run Cyrano with no backend — the free tier, or Pro's local smart layer — the "remove the other party's lines" action used to fail with an error about a server you'd never configured, and nothing got removed. That was exactly backwards: with no backend there IS no server copy, so the local copy is the whole job. Redaction now just does it. (Plans that do use a backend still require the server copy to be scrubbed first, as before — redacting only your local copy while a server holds the words would be a false promise.)

The app now explains missing features in your language, not the operator's.

Screens that need a backend — Connect an Agent, context attachments, server redaction — used to fail with "No bearer token is set — add one in Settings → Backend," which is only meaningful if you deployed the Worker yourself. Each surface now knows why the backend is absent and says so in those terms: on the on-device plans it explains the trade and names the way in; an unfinished Copilot activation points back at the activation flow; self-hosters still get the precise AUTH_TOKEN language, because for them it's correct. And since most people opening "Connect an Agent" on an on-device plan really want their sessions sent to an agent — which works fine without any backend — that screen now says so and links straight to Integrations.

Unlocking Pro can no longer deadlock against your own machine.

Reinstalling or updating the app could make it lose track of its own device identity, so entering your license key produced "already unlocked on MacBook Pro — deactivate it there first" on that very MacBook Pro, with no way to comply. Device identity now survives reinstalls and updates, so the key recognizes the machine it's already bound to.

Sync setup always has a way back.

If device sync got stuck half-configured — say you closed the pairing window partway through — the Sync section could show an error with no exit anywhere on the screen. There's now a Stop syncing on this device button that works no matter what state sync is in: sessions on the device stay, other devices keep their copies, and pairing starts fresh next time. A brand new sync setup also no longer greets you with a scary "Did not find record type" error — an empty iCloud container now correctly reads as "nothing synced yet."

"Recognize my voice" now corrects lines it missed the first time.

When voiceprint enrollment is on, the embedding that identifies your voice arrives a beat after the transcriber has already committed the text — so on calls where the diarizer's RMS+centroid classifier is unreliable (phone calls on speaker, AirPods HFP, any setup where both voices share one mic), your lines could land as UNKNOWN or OTHER and stay that way. The voiceprint verdict was being recorded but never applied retroactively to lines that already existed. The mic feed now mirrors the system feed's correction path: once a positive voiceprint match lands, any UNKNOWN or OTHER lines inside that span are restamped to You, re-sent to the server under the same seq, and the local smart layer is re-ingested — so commitments, asks, and subtext see the right owner from the start.

Search now takes you to the line, not the session.

Searching your sessions always showed you a snippet of where the word was said — and then opening the result dropped you at the top of the transcript to go find it again yourself. Picking a result now opens the session scrolled to that line, briefly highlighted so your eye lands where the match did. It works for whatever kind of line matched: a transcript line, something Cyrano said back, a task, an open ask, a decision, a watch hit, or a note you typed. A hit on the session's title or a speaker's name still opens at the top, because those aren't a place in the conversation.

Bring your own key — any model, unlimited, on your own bill.

Cyrano now runs on whatever LLM you want to pay for directly. In Settings → Backend, pick Anthropic and paste an Anthropic API key, or pick OpenRouter and paste an OpenRouter key plus a model name — Claude, GPT, Gemini, Llama, anything OpenRouter reaches — and the smart layer runs on your account with no quota from us. Your keys live in the Keychain and are never stored on the backend; a bring-your-own-key call is billed to you, not metered against anyone else. (Heads up: Settings "Test connection" checks the backend and its own key, not a per-session key you bring — so a bad key first shows up as a banner on the next analysis tick, not at test time.)

Host Cyrano for a few other people without sharing your key.

A new per-user token system lets you hand out individual credentials from your own backend instead of sharing one master token or your Anthropic key. Each person's sessions are theirs alone — reachable only by them (or you, as operator) — and their usage is tracked separately. The single-token self-host setup you already had keeps working exactly as before.

Per-user cost metering with a safety ceiling.

For hosted use on our key, every billed call now records its real dollar cost against the paying user, rolled up over a 30-day period, readable at GET /usage. A $25-per-period backstop means a runaway script or shared login can never produce a catastrophic bill — well above any real use, purely an abuse guard. If someone does blow past it, only their cloud smart layer pauses; transcription, the map, and on-device whispers keep working.

No more paying to analyze "yeah."

The analysis pass used to fire a full, multi-call tick after every single utterance — so a one-word acknowledgment cost the same as a full paragraph. Cyrano now waits until there's actually something to analyze (at least a few real words) before spending on a tick, and anything short is held over rather than dropped, so a terse-but-real "send it Monday" still gets caught on the next qualifying tick. In ordinary back-and-forth this cuts analysis cost by well over half.