0.59.0 — hands-free voice that talks while it works, a conversation you can share, and the agent's browser on screen

The nine-item list audited on 2026-09-16 — what the marketing said against what the product did — shipped one pull request per item over two days, each measured before it was built and tested against the running app afterwards. This release is that list, plus what its live tests found.

Hands-free voice on the Code screen — and it keeps talking while it works

Voice beside the dictation button keeps the microphone open: what you say is cut into utterances on silence, transcribed, and sent as a turn; the answer is read aloud with the window's own voices, and speaking over it stops the reading and becomes the next message. The first live test found the voice robotic, the first sentence slow, the answers long and the odd word swapped — each with a cause that could be measured, and each fixed: the reader waits for the browser's voice list and ranks the natural voices first (Settings → Voice lets you pick one and listen to it), the speech model is built once and warmed when the mode comes on, the first sentence is read while the answer is still streaming, the model is told it is being heard and answers for the ear, and the reasoning models are asked not to think before a spoken reply.

Two models, both yours to choose in Settings → Voice: one for spoken turns, listed likely-quick first, and one for the work you ask for by voice. And a spoken request for work no longer runs in the conversation — it becomes a background work on the work model, in the folder you named, and the voice keeps the conversation: "how is it going?" is answered from the work's record, "stop it" and "undo it" act, several works run at once with one running per folder, and a Background works panel on the screen shows each one with the same Stop and Undo buttons. The wake word is not here.

A conversation you can share

Share beside a conversation's title mints a link a second person opens in a browser — on your machine, in this project, with your tools and your spend, short of approving cards. A token per share, never the server token; a network door you open and close, never open at launch; both windows draw the same turn as it happens, with who asked what, and a governance card a guest's turn raises lands on your screen, the only place it can be answered. One thing seen live and left honest: the link carries the address your machine had when the panel listed it, so a laptop that changes network needs the link copied again.

The agent's browser draws on the screen

After every browser action the viewport appears under the turn — one frame per action, never on a timer — with the page's address beside it, because a picture of a page is a claim and the address is the part you can check.

It does more at once

A step that asks for several read-only tools gets them at the same time. run_shell can start a command as a background job the turn does not wait for, and the next turn hears how it ended. The hierarchy's workers can read the web, so "read these five sites and compare them" hands five workers something they can actually open — the answer says when it was made from something a worker fetched, and the plan says, before the run, what the measurement said about splitting.

It remembers, and it runs without a key

Every finished coding turn joins a history index, and recall_history finds the turn that fixed the login function a fortnight after the conversation itself forgot it. The memory backend defaults to SQLite/FTS5 — measured to rank the same as the JSON store and to answer in 0.2 ms where the JSON store took 70 ms at four thousand facts — and an existing memory.json is imported once. A machine that already runs Ollama or LM Studio needs no API key, and the first-run screen finds the model itself. The desktop starts with the trust kernel in observe, and a path outside the project folder is a card that asks you, not a refusal.

Fixed

The Code screen's live diff and undo offer were silently off for every governed turn — the edit capture looked at the wrapper and not the tool inside it — found while testing background works, and fixed. A coding turn walked the whole disk before calling the model (8.7 s a turn on a large checkout, for an undo snapshot that need not even include the source); inside a repository it now asks git for the project's files, 0.3 s, none left out. The SQLite memory store refused every recall off the thread that opened it, one message away from every surface the bot lives on. The desktop backend listens before it announces its port, a third off the launch. And a streamed turn's receipt learns which route answered when the conversation is reopened — the route is only knowable seconds after the stream ends, so it is filled on reopen, never guessed.

Caveats

Installers are unsigned outside the updater path and will warn on first run. Cancellation is cooperative: it stops before the next model call, and calls already in flight finish and are billed. Stopping a background work is the same kind of stop. The barge-in floor and the utterance cut are heuristics with numbers in them, stated so they can be measured against a real room rather than believed. The talking model can only see the work's record, not its screen; the work's full transcript is a route, not yet a panel.