releases

The panel always leaves you a way out.

• A question from your agent always shows up on a card you can answer. The panel used to work out whether a question was on screen in two separate places, and when the two disagreed you got the worst version of both: no card to answer, and a message box that refused to send because it said to answer the card.
• Anything that holds the message box shut now offers two ways past it, on the card and from the keyboard: skip the question, or send your message anyway.
• You can take code an agent wrote. Every fenced block has a copy button, and words in the conversation can be selected with the mouse again.
• A question with several parts to it arrives whole. If one part cannot be read, that part says so instead of the whole question vanishing.
• The remove button on an attached image is a circle again rather than a squashed oval, and the badge that tells you an agent is waiting on you is no longer sliced off at the edge of the dock.

The hint that taught the gesture stopped sitting on your work.

• The hint about drawing a line between two agents sits on its own card. It used to be loose ink on the board, so a node underneath it left both sets of words running through each other and neither could be read.
• The paper texture is the empty board again. It had been painting over boards that already had agents on them, which is the one place it was never meant to be.
• The hint drifts as one card rather than sliding its words around inside a border that stayed still.

The board goes to paper, and colour starts meaning something.

• The canvas is paper rather than blue, and cards sit a shade lighter than the board so they lift off it instead of floating on a colour.
• Every link is drawn in ink, and what it does is carried by its weight and its dash. The only colours left on the board are the ones telling you an agent is working, waiting or blocked.
• Text you read stops moving. A node keeps its tilt only while it is too small to read and straightens the moment its words are legible.
• Nothing you have to read is under 12px, the code editor stopped printing text in colours you could barely see, and around forty controls grew big enough to hit, including allow and deny on a permission prompt.
• Every node stands off the board on a stepped edge, lifts when you point at it, and squashes when you press it. Each of the twelve tools carries its own cursor.

It says what it costs, and it stops when you say stop.

• Every step an agent takes now shows what it cost, and the running total for the turn sits beside the thinking dots while you wait.
• Stop is where your hand already is: while an agent works the send button becomes a square, and pressing it says so instead of leaving you to guess. Messages you send afterwards go straight through.
• You can talk to an agent while it is working. Your message goes now, so you can steer a run that is heading the wrong way instead of stopping it and retyping.
• The slash menu knows every command your agent really has: 264 of them across Claude, Codex, Gemini, Grok, Devin and opencode, read from the tools themselves rather than remembered.
• The effort control is one faster-to-smarter dial, every model wears its own mark, and /fork and /goal each get a small card beside the agent they belong to.

The build that can read a monthly key.

• A licence naming a plan this build has never heard of is no longer rejected as malformed, so a new plan can appear without waiting on an app release ever again.
• Effort is a slider rather than a row of chips, in the New panel and the launch menu, with real keyboard and screen reader support.
• Three tests that failed only when the machine was busy now wait for the thing they are testing instead of sleeping a fixed span. A suite you cannot trust is worse than no suite.

A first canvas worth having, and tests that can actually fail.

• The first button on the welcome screen asks for a folder and opens one real agent in it. It used to hand you a canvas with no folder behind it, which meant terminals opened in your home directory and the git panel had nothing to read.
• Every bug the last two builds shipped lived in a seam the tests could not see, so there are now two harnesses that run real processes and real pixels. Each is proved by re-running it against the old broken behaviour: a test that has never been red is not evidence.
• Two copies of the app sharing one machine could silently un-authenticate each other agents, permanently and without saying so. The first one to write now wins and the second adopts it.

Signed and notarised, and the transcript finally reads.

• The build is signed with a Developer ID and notarised by Apple, so the install is download, drag, open. The line you used to have to run is gone.
• What an agent says is rendered rather than flattened: paragraphs, lists, inline code and fenced blocks, with links that go to your browser instead of nowhere.
• The agent that has been waiting on you longest is now the loudest one on the board, not the quietest. Off-screen agents that need you point at themselves from the edge of the view.
• A queued instruction to another agent re-checks its authority before it lands, so cutting a link revokes a command that was already waiting.
• Arrow labels ride their own wire, so selecting a link no longer hides the word that says what it does.

The second smoke-test batch.

• A pass of fixes found by walking the app the way a first-time user walks it, rather than the way its author does.

Blocked prompts can be answered, and the dial responds instantly.

• An agent asking for permission could be left with no way to answer it from the panel. It can be answered now.
• The permission dial applies as soon as you turn it instead of lagging behind the click.

Legacy sessions stop hijacking panels.

• A relaunch carrying an old --continue flag could attach a panel to the wrong conversation. It cannot now.
• Releases are cut, signed and published by one script rather than by hand, which is the only reason the three fixes above shipped the same day they were found.

The signing kit, and the cleanup behind it.

• The pieces a signed and notarised build needs are in the repository, which is the last engineering step before the app stops asking you to clear a quarantine flag by hand.

The dock, the arrow language, and an update notice.

• Links wear an animated midpoint pill that says which way authority runs, so a glance at the board tells you who commands whom.
• The dock at the bottom of the canvas holds the fleet and says which agent is waiting on you.
• The app checks for a new version and tells you. Nothing upgrades itself.

Agent nodes show their history.

• An agent node keeps and shows what it has already done, so reopening one is not starting from a blank pane.

An agent-node reliability sweep.

• A batch of fixes to the node that runs an agent: what it shows, when it shows it, and what happens when the agent underneath it misbehaves.

Multi-open panels, every model in the New panel, and a steadier dock.

• More than one agent panel can be open at once, and an agent can be renamed.
• The model selector is a real dropdown carrying the agent mark and the model generation, rather than a list of strings.
• The launcher opens on the same hero the site leads with, and the recent-project cards draw a working minimap.
• Installed skills appear in the composer slash menu instead of being invisible until typed exactly.
• The code node keeps its editor shortcuts to itself and has a focus mode.
• Devin is no longer offered anywhere: not in the New panel, the palette, or the digit chords. It was added in 0.0.16 and did not earn its place.
• A trial could be extended by moving the system clock. The install date is clamped and a future date no longer buys anything.

Drawing never orphans a stroke, and the top bar sits properly.

• Pressing a second mouse button mid-stroke used to leave the stroke behind and lose the pan. Neither happens now.
• The top bar respects the platform titlebar inset, and the tabs join the canvas rather than floating above it.

The spawn tether, the context gauge, and panels you can resize.

• Pulling a new agent off an existing one draws a visible tether, so the link you are about to create is not a surprise.
• Each agent card carries a context gauge.
• Folding a card gives the keyboard back instead of swallowing it.
• Composer menus handle Escape and folder walking the way every other menu on the machine does.

Composer commands, file mentions, copy and rollback.

• The composer takes slash commands and file mentions, copies what an agent said, and can roll a turn back.

The git node stops lying, and the meter tells the truth at a glance.

• The git node could wedge, misreport, and hide its own Send button. All three are fixed.
• The meter is readable without opening it, and the board is reachable by keyboard.
• The terminal behaves like a terminal, and the board says out loud what it just did.

A two-pane focus view, and per-node model choice.

• Fullscreen focus puts the conversation and the work side by side.
• A Claude node picks its own model and effort level.
• The composer takes images and resizes by hand.
• A breathing indicator while the agent works, so a long turn does not look like a hang.

The bridge meters every verb honestly.

• Dispatch, report and share are all metered, and an observed run still never gates. Only a run you started can be stopped by a threshold.
• Ten findings from an interaction audit of the agent node.
• The canvas speaks at the moments that teach it, rather than at every moment.

Agent chat arrives on time.

• Answers land when they land rather than after the next event, thinking is shown condensed, and an agent that is waiting never refuses your typing.

An agent node can be removed, and every agent knows where it woke up.

• Removing an agent node works, and IPC errors stop leaking their internals into the interface.
• Hook scripts install on launch, so status works on a fresh machine without a setup step.
• Every agent is handed a briefing on start: which board it is on, who it is linked to, and what it may do.

Agents spawn agents.

• An agent can put another agent on the canvas, linked to itself as a child, and hand it the context it needs to start knowing why it exists.

The certification sweep, closed.

• Two rounds of hostile re-review of the previous week: the fixes’ fixes, the journeys nobody had walked, and the six trust-critical findings among them.

The draw layer tells the truth and the bridge authenticates.

• A drawn gesture does what it looked like it did, a dispatch is authenticated rather than trusted, and a fix that fails says so.

Forty-three findings across five subsystems.

• The previous day’s features and fixes, put back under review and repaired.

The file rail becomes the working set.

• A changed zone, a find field, and real file icons, rather than a tree of everything.

The pre-launch review pass.

• Twenty-four verified findings across seven subsystems.

The git strip chart, and the agent node becomes a conversation.

• The git node draws time on the X axis with a lane per member of the fleet, and its sockets become real wires.
• The agent node is a conversation you can hold rather than a light you can watch.

Three ways to end a session.

• End one node’s session and keep the node, end the ones that are genuinely idle, or opt out of tmux continuity entirely on quit. The app says why it will not end the rest.

The New panel, and games that give your attention back.

• Everything you can put on the canvas comes from one panel, opening in the middle.
• Three idle games ship. They mint no agent, so they are never paywalled.