Changelog · macOS

What's new.

Each release in plain words: a headline, the points that matter, and the full engineering notes one step deeper.

Latest release. v0.7.0-beta.2 01 Aug 2026 5 notes

The app sets itself up

Helmsman installs your agents in real terminals on first launch.
A hostile repo can no longer run code through its git config.
The session cap rises to 50, with a heads-up past each twelve.
Inter and JetBrains Mono ship at last, in the app and terminals.
Deleting a branch cannot tear out a live agent's worktree.

Engineering notes for v0.7.0-beta.2

The same app as v0.7.0-beta.1, cut again under a new number so the release card can take its first turn. The card ships in 0.7.0, but the release that introduces it can never show its own card: the app you updated from predates the feature, so the first launch after the update read as a first run and stayed deliberately silent. Updating to this build shows the 0.7.0 highlights as a card in the app itself. Nothing else changed; the full story of what 0.7.0 brought is in the v0.7.0-beta.1 entry below.

v0.7.0-beta.1 01 Aug 2026 9 sections

The release where Helmsman sets itself up. A first launch now installs the agents you choose, each in a real terminal you can type into; a hostile repository can no longer make git run a program; and the fleet cap rises from 18 sessions to 50. Around those, the ruled design system reaches the last screens that had not moved, and the app ships the typefaces the redesign ruled but never delivered.

Engineering notes for v0.7.0-beta.1

The app sets itself up

On a genuinely fresh install, Helmsman opens a setup over the grid: one row per agent CLI, a probe that already knows which are installed, off your PATH, or too old, and every offer ticked by default. Existing users with projects never see it; the empty grid, the Environment panel, and Settings can all reopen it later.
Pressing Install opens a consent sheet listing every command verbatim, each copyable, with one fact stated up front: nothing here needs sudo or installs a background service. Cancel returns to the roster; only Run starts the installs.
Every install runs in its own real embedded terminal, in parallel. An installer that stops to ask a question, a sudo password, a keychain unlock, an npm one-time code, has somewhere to be answered: a terminal that prints nothing for a minute flags its row and opens its well.
The result is judged by a re-probe of your shell, never by an exit code, because one provider’s installer exits 0 over a broken binary. A failed row keeps its log open and carries a Retry; if nothing survived, there is no forward pill to a dead completion screen. Stopping mid-run kills the running installs but never removes what already succeeded.
The setup installs agents and stops. Each agent signs you in the first time you run it, in its own CLI, in a real cell; Helmsman does not drive a login.
Finishing opens a real session in a seeded ~/Helmsman workspace. If Claude is already signed in, the cell gets a typed prompt, never a CLI argument, asking the agent to explain what the grid and the Fleet tools give it.

Providers

The setup no longer offers to install Gemini CLI. Google ended it for personal accounts in June, so the default tick was installing a binary a fresh user could not sign into. The row stays and says why: an installed gemini still spawns, and Standard and Enterprise seats are unaffected. Only the offer is gone.
Antigravity, Google’s named successor, is the eighth provider, seated directly after Gemini so the withdrawal and its replacement read as one story. It installs through the vendor’s own installer, and its binary is agy, not antigravity.

What a hostile repo can no longer do

A repo’s own git config can no longer run programs. Several config keys name an executable git will run on an ordinary command: a credential helper fires the moment a remote answers 401 on Fetch or Pull, a filter’s smudge fires on Discard, an external diff or a textconv on the panel’s per-file peek. A repo ships its own .git/config, so opening a hostile repo and clicking one Source Control button was enough to run code as you, proven live under the app’s exact argv. Helmsman now reads every program-naming key the repo’s own files declare, including ones pulled in through an include or the worktree config, and resets each on every git spawn. Your own credential helpers are re-added after the reset, git-lfs keeps working because the check reads a filter’s value rather than trusting its name, and a repo’s commit hooks and your ssh command are deliberately left alone.
A symlink cannot reach outside the project. The reader, the file finder, and the CLAUDE.md editor compared path strings but read through links, so a repo shipping notes.md pointing at ~/.ssh/id_rsa handed the reader your private key, a CLAUDE.md that was a link read and saved through to whatever it pointed at, and a dangling link meant merely opening the Config tab created its target. All three now resolve real paths and refuse an escape; a link that resolves back inside the project still works. A hardlink is not caught, and a plain clone cannot deliver one.
The trust boundary reaches every path-taking channel. The git, issues, skills, and worktree IPC channels, twenty-plus in all, now refuse any path outside the folders you added, and the prompt enhancer’s project path goes through the same gate, with reads that check for a regular file so a FIFO cannot wedge the main process. This is depth, not a live hole: it takes an already-compromised renderer to aim these, and that surface is closed; what changed is the blast radius if it ever is not. The probe that proves nothing reaches outside the app widened from eleven APIs to every path-taking channel, so a future handler that skips the gate fails a test instead of shipping.

Fifty sessions

The cap rises from 18 to 50. Eighteen was two full pages of nine under the original 3x3 grid; the page grew to twelve four days later and the cap never followed. Fifty is a deliberate round ceiling, well past any fleet a person supervises. Driven live before shipping: 50 running PTYs cost about a gigabyte of memory and under one percent CPU at rest, and the 51st spawn is refused out loud.
Protecting your Mac is the load warning’s job now, not the cap’s: a sticky heads-up as running sessions pass twelve, and again at each twelve after, with a permanent mute in Settings. It names the threshold you crossed, never a live count, and it yields to the grid-full toast so the two never talk over each other.
Fleet MCP follows the cap: wait_for_sessions takes up to 50 ids, where a lead waiting on more than 18 delegates used to get a validation error.

The ruled design system, and the real typefaces

The app ships its typefaces at last. Inter and JetBrains Mono were ruled into the design system, but no font file ever shipped, so every label and every terminal was silently set in macOS system fonts. Both now ship bundled, and terminals wait for the font before opening: xterm measures its cell size once, so a terminal that opened before the font parsed would cache the wrong width forever and paint mixed typefaces into clipped cells.
The deck tab strip across the top of the canvas is gone. Decks live as a centered cluster of dots in the bottom status bar: the active deck grows into a capsule wearing its name, a background deck whose agent needs you breathes in white ink, hovering peeks its cells, and dragging a session unfolds the dots into full drop targets. A web page is now an ordinary grid cell with the standard header and a URL bar instead of a full-window surface. Cmd+Alt+T mints a browser cell, Cmd+Shift+T reopens the last closed cell, Cmd+L focuses the address bar; Cmd+T means new terminal, nothing else.
The last holdout screens move onto the ruled system: the Activity and Hail history drawers give up their all-caps mastheads, dotted rules, and eof footers; the command palette, the deck-move menu, and the decks popup share one borderless, edge-lit card recipe; every modal dims the screen with the one scrim token instead of three near-identical blacks; the Hail mic pill and onboarding drop their caps and their second loading indicator; and the voice overlay rebuilds its prototype-era gradients from real tokens, spending the accent once.
The first-run analytics notice states its fact and stops: no footer pills, the Settings link lives inside the sentence, and the dismiss is visible at rest.

Branches and worktrees keep your work

Deleting a branch from Source Control can no longer tear out a worktree a running agent is working in. The only guard was “this is not the checked-out branch”, and git worktree remove --force overrides git’s own uncommitted-changes check, so one click could discard another cell’s in-progress work. A live tree is refused with a toast telling you to close its cell first; a Helmsman-provisioned tree tears down through the journalled removal path; and a failed removal aborts the branch delete instead of leaving a row pointing at nothing.
A commit made on a detached HEAD inside a cell survives the cell’s close. The close reported the work as kept while removing the only ref that could reach it, leaving the commit to git gc. The SHA is now pinned under refs/helmsman/detached/ before any removal.
Closing a cell whose agent checked out one of your existing branches no longer deletes that branch. The close-epilogue deletes only the branch it provisioned, and its worth-keeping check reads the tree’s real current branch instead of the name recorded at spawn.
A worktree removal interrupted mid-delete no longer masquerades as uncommitted work forever. Removal runs on its own five-minute budget instead of the 20-second query clock, records its phase before the first destructive call so a relaunch finishes its own footprint instead of refusing to touch it, and unlinks the gitignored bulk first, so a death midway still reads clean.

The release card

Helmsman updates itself silently, and until now the running app never said what changed. The first launch after an update shows a release card once: the version as a document in the reading room, the release’s points as a numbered index. It shipped minutes after the last release went out, so this entry is its announcement.

Fixes

Source Control opens a brand-new repository. git init with zero commits leaves an unborn HEAD, which read as a transient failure and dead-ended at a “Try again” that could never work. The unborn branch is read through symbolic-ref now, a machine with no git installed is told that instead of offered a retry, and Unstage works before the first commit exists.
A file whose name holds a space, a quote, or a backslash can be staged, unstaged, discarded, and diffed. git status wraps such names in C-style quotes, the literal quotes traveled into every pathspec, and Stage did nothing at all, with no error anywhere. The decoder reassembles octal escapes as UTF-8 bytes, so accented filenames stop mangling too.
Claude’s /copy and /export land on the system clipboard. Both work by an escape sequence xterm recognizes but had no handler for, so the copy vanished, and the alternate screen has no scrollback to drag-select from. Clipboard reads are never answered, so a session in an untrusted repo cannot see what you last copied, and payloads are size-capped. For the whole conversation, Claude Code’s own Ctrl+O then [ moves the transcript into real scrollback, and a test now pins that the gesture works.
Content search sees your cell worktrees. # searched only the main checkout, so text an agent had written in its worktree answered “No matches”, which reads as the agent never wrote it. Hits carry their root and branch, same as name search.
A file that exists only in a cell’s worktree still cannot be pinned to the grid, since pinning one minted wrong-file tiles, but the refusal now explains itself: a split pill names the branch holding the file and offers to send a fresh cell to land it in the main checkout.
An issue sent to an agent reads as the work order it is. The old frame declared everything the issue said untrusted and told the agent to refuse anything directive, so ordinary instructions in your own team’s issues were refused out loud. The frame now says follow the thread, and holds four hard nevers: no credentials, no piping fetched content into a shell, no services the project does not already use, and no silently skipped steps.

Under the hood

The renderer’s App component went from 3,752 lines to 2,116 across nine PRs, one feature hook per slice, each re-driven through a Playwright audit of the core flows. Nothing about the app changes: no visual change, no timing change, and no speed claim. The point is that the next grid feature lands without regressing an unrelated one.

v0.6.1-beta.1 26 Jul 2026 4 notes

The ghost windows are gone

Windows that opened and closed behind your work on 0.6.0 were hook events booting a whole second app. Hook events travel by curl now, and curl cannot launch anything.
Each ghost boot wiped the running fleet's per-cell tokens, so Claude cells fell back to a coarser signal and Codex cells lost their state entirely. Both are whole again.
Helmsman refuses to start twice. A second launch hands focus to the window you already have instead of sweeping the first one's live session state.
A text selection in a running agent cell stays on the text you picked. Claude repaints its frame in place, so the highlight used to slide onto words you never selected.

Engineering notes for v0.6.1-beta.1

A fix release, and the fix is the whole story: if you started your first session on 0.6.0 and saw Helmsman windows open and close behind your work, this is the release that stops it. Upgrade if you are on 0.6.0-beta.1.

The ghost windows

A hook no longer boots a second Helmsman. Every Claude Code lifecycle event ran the courier as ELECTRON_RUN_AS_NODE=1 "<the app binary>". A packaged build cannot honour that: the release build disables the runAsNode fuse on purpose, so Electron ignored the variable and started normally. A first prompt fires four events, so a first-time user got four apps. The courier is a curl one-liner now, which cannot become the app under any fuse, and macOS always ships curl, so the zero-node-dependence the old form was reaching for finally holds.
Your session tokens survive. Helmsman clears its per-cell token directory on every start because that directory belongs to exactly one running app. Each ghost boot therefore deleted the live instance’s per-cell MCP tokens and hook settings, once per hook event.
Agent state comes back. With the courier never running, Claude cells silently degraded to a coarser fallback signal and Codex cells, which have no fallback, had no state or resume at all. Distillation moved to the app side of the wire, so the payload a hook posts is now parsed by code that has tests.
Prompts stop stalling. Each event sat out its full ten-second hook timeout waiting on a courier that could not answer.
Helmsman refuses to run twice. Whatever the route, a second instance does not merely duplicate the window: it deletes the first one’s live tokens, rewrites the fleet manifest and orphans every PTY. The second launch now quits and hands focus to the window you already have. The curl courier closes the specific hole; this closes the class.

Fixes

A text selection in a running agent cell stays on the text it highlighted. xterm anchors a selection to a buffer row, and Claude Code repaints its frame in place on the alternate screen, so the orange highlight stayed where it was while new text was drawn underneath it. Copying handed you something you never picked, and Cmd+E enhanced it. The repaint is held while you drag, and released the moment the selection is.

Under the hood

The deck’s swipe stage binds from a ref callback, so mounting a page costs the app one render instead of two.

v0.6.0-beta.1 25 Jul 2026 5 notes

The app installs its own CLI

Helmsman installs and repairs the Claude CLI itself.
The renderer can no longer read outside your added folders.
Settings, Config, and Source Control move onto the ruled system.
Codex and Grok wear their real provider marks.
Opus 5 sessions show a real price, not an estimate.

Engineering notes for v0.6.0-beta.1

The release where the app stops handing you to the docs. Helmsman now installs and repairs the Claude Code CLI itself, a security pass closes the renderer’s reach into your filesystem, and the ruled design system finishes its walk through Settings, Config and Source Control.

The app installs its own CLI

A missing claude used to end at a link to the setup docs. Every install action now opens one confirm showing the exact command verbatim, then runs it in a real repair cell whose output stays on screen. The docs link survives only as a last resort on a failed install.
The install is judged by a probe, never by an exit code: a curl that dies inside a pipe still reports success, so Helmsman re-queries your login shell and smoke-tests the binary before it says installed. A binary that is present but broken gets a name (a quarantine xattr, an x86_64 build with no Rosetta) and a copyable fix.
A tool that is installed but off your PATH no longer blocks a spawn. Helmsman pins the absolute path it found, prepends its directory to every cell’s environment so your own hooks find it too, and scans nvm installs, picking the highest healthy version instead of a stale copy in /usr/local/bin.
To make the fix stick, the Environment panel offers an append-only edit to your shell profile, previewing the exact file and the exact block before it writes anything. Fish gets the fish-correct line to copy.
Helmsman’s own hooks stopped needing your node: they run on the Node inside the app. A missing node surfaces once as a dismissible notice that explains what it costs you, instead of failing quietly.
Re-check re-reads your shell before it probes, so a CLI you installed after launching Helmsman is found. The welcome screen carries a quiet status strip: the facts when healthy, the install prompt when not.

A security pass across the boundary

The renderer got a trust boundary. files:*, reader:*, config:*, projects:reveal and server:start now refuse any path outside the folders you added or the worktrees the app itself provisioned, checked at the IPC boundary rather than inside each handler. server:start no longer takes a command string at all, and the generic bridge that sat beside the curated API, making it decorative, is gone. A golden journey reproduces the old exploit against an unfixed build and proves it dead against this one.
Untrusted repo content can no longer run code. A Procfile line is accepted only as a plain command, a repo’s .git/config can no longer execute through core.fsmonitor or diff.external on any git call the app makes, a catalog entry cannot traverse out of its own directory, and a symlinked .helmsman is refused.
Issue and PR text arrives marked. What gh issue view returns now lands inside a fence that names it as third-party data and lists what it may never talk an agent into. The title moved inside that fence, so a crafted title can no longer close the quoting and read as your own instruction.
Pre-approving a worker needs your hand. A lead agent asking for acceptEdits or allowedTools is asking for a worker that never prompts. That now requires a per-project opt-in you set in the project row’s menu, and a spawn without it fails loudly instead of downgrading in silence.
Installing a skill from a pasted URL asks first, validates the git URL (closing an ext:: remote that could run a command), stages the clone so no dotfile lands in a directory Claude Code loads from, and refuses a repo with no SKILL.md.
Nine production dependency advisories clear with a lockfile refresh.

The ruled design system, everywhere else

Settings, the Config view, Source Control, Profile, the Marketplace’s Apps half, the sidebar’s + menu, the cell cost popover and the web-cell error states all move onto the ruled system, most of them through a critic loop run on top of the redesign.
Source Control loses all three spinners (the brand wheel is the app’s only loading indicator), gains a real sign column and word-level emphasis in the inline diff, and gives every armed destructive action the same vivid danger treatment.
Every markdown surface now renders the same document the same way. Five per-surface dialects became one: h4 through h6 had never been ruled at all and fell through to weight 700, the accent was spent fourteen times a document instead of once, and links were identified by colour alone.
The reader family retires its eof lines and old-register chrome, and the residue left behind by retired scales is swept out of the shared chrome.

Providers

Codex wore an invented hexagon and Grok a diagonal slash. Both are gone: every provider resolves its own real mark, and a new provider with no logo fails typecheck instead of quietly wearing a generic robot. Identity renders in the ink ramp, so the accent stays the app’s.
Providers with no lifecycle model, Cursor among them, are readable through read_session at last. Their output never reached the capture buffer, so an orchestrator saw an empty screen where an authentication prompt was waiting.
Opus 5 sessions show a real price instead of a hedged estimate. The money was already right and only the label was wrong, and two guards now stand against a third occurrence of that bug.

Fleet and the grid

A supervised worker stays visible after its tile is gone. A close, a restart, a resume or a removed project used to drop the row outright, so a lead could not tell “my worker died” from “you made that id up”. Retired cells now keep a place in a bounded ledger, and a restarted or resumed cell inherits its parent link so its lead can still steer it.
“Run as goal” starts an actual goal run. It used to ask the spawned session to compose one, which no session can fire, so it behaved like a plain send: no armed goal, no evaluator, no loop.
A tile you grab right after a two-finger swipe stays under your pointer. The deck strip has two position writers and the drag pin was watching only one of them.

Fixes

Toasts count down on the app’s own clock. The toast library keeps one provider-wide pause flag that could be stranded true, leaving the next toast with no timer at all, and an Undo offer could outlive the session it belonged to.
A file drag entering the window closes any open menu, so a drop cannot land underneath an open card. The menus are also non-modal now, so the drag reaches the cell in the first place.
The Activity and Hail history drawers close on an outside click.
Screenshots pasted into an issue or PR render in the app. Main fetches the bytes with your own authenticated gh and hands the renderer a data URI, behind a host allowlist and a magic-number check.
“Report a bug” opens a real mail draft again. It was building a mailto: in the renderer and handing it to a guard that allows only http and https, so the click did nothing at the exact moment a session had failed to launch. It was also addressed to nobody and carried 5 of its 11 diagnostics fields.
Extra usage shows only on positive spend, in the payload’s own currency units.
A failed spawn’s re-probe now reaches the Environment panel instead of being computed and thrown away.

Under the hood

Typecheck runs on the TypeScript 7 native compiler: 32.7s down to 6.3s in CI.
The five zones under src/ are enforced by lint instead of by discipline.
The signed DMG builds on a Node that is still supported, and the stated Node floor now points at the single .nvmrc pin.
Three more pieces move out of the App() god-file: the deck-paging swipe, the recent-files store, and the critic-loop findings on both seams.

v0.5.0-beta.1 23 Jul 2026 7 notes

Send an issue to almost any agent

Send an issue to Codex, Gemini, or almost any installed provider, not just Claude: a split pill remembers your default and opens a full picker on demand
The cost pill was undercounting actual spend by roughly 26% against /usage: unread subagent transcripts, a dedup bug on growing duplicates, and two missing pricing rates are now all counted
The file finder now searches your cell worktrees too, and flags a checkout that has fallen behind origin
The Usage chip shows a clear resting state the moment a Claude subscription links, instead of sitting dim until data arrives
Empty states, keycaps, and option cards move onto the ruled design system's weight and accent rules
Re-check now sees a Claude CLI installed after Helmsman launched, instead of looping on "not installed" forever
The truncated cell-name tooltip no longer gets stuck open after a resize

Engineering notes for v0.5.0-beta.1

The issue board stops assuming Claude, and the cost pill stops lying. This release makes sending an issue multi-provider, closes a real accuracy gap in cost tracking, and carries the ruled design system into the app’s empty states.

Send an issue to almost any agent

The issue board’s send action was hardcoded to Claude on three seams: the label, the spawn, and the timeline copy. It is now a split pill: the main segment sends to your remembered default provider in one click, and the chevron opens a full picker with the same tiers, health facts, and typeahead as the launch menu.
A muted auto tag marks an inferred default, which re-arms itself if your explicit pick ever breaks. Kimi Code is left off the picker, since its CLI cannot take an argv prompt.

A real cost number

The cost pill was undercounting actual spend by roughly 26% against /usage. Four bugs, now fixed: subagent transcripts were never read at all; a keep-first dedup mispriced growing subagent duplicates; claude-sonnet-5 was missing from the pricing table; and web-search fees went uncounted. The popover now shows a main/subagent split and discloses a small ~2% floor for internal calls that never hit disk.

The file finder learns your worktrees

The ⌘P file finder only ever searched the main checkout, so files that landed in a cell worktree were invisible to search. It now searches the union of the main checkout and your registered worktrees, tags worktree-only files with a branch badge, and shows a quiet banner (with a one-click pull) when the checkout has fallen behind origin.

Re-check stops lying about a missing CLI

The cell Re-check button used to loop on “not installed” forever if you installed the Claude CLI after Helmsman launched, because the shell PATH was only read once at startup. Re-check now re-reads your shell before probing, and shows a “Checking…” state so a real re-probe doesn’t look like a dead button.

The ruled design system spreads further

Empty states, keycaps, and option cards drop to the design system’s weight ceiling and give up their stray accent fills: hover states now move by border and ink instead of a color wash.
The truncated cell-name tooltip is now the same gated Tip primitive used everywhere else in the app, replacing a hand-rolled pill that could get stuck open after a resize.

Fixes and hardening

The Usage chip gains a linked-no-data resting state, so a freshly linked Claude subscription reads as “linked, no data yet” instead of sitting in the same dim state as a fetch failure.
The provider picker’s fact column no longer overlaps long provider names, Codex and Grok get their own glyphs instead of sharing one, and every broken row (missing CLI, bad PATH) is now keyboard-reachable and teaches its own fix.
The file-viewer overlay’s earlier fixes (focus trap, find/goto affordances, an outline rail with type-to-filter) are now ported onto the pinned reader cell and re-verified there.
The Issues rail label reads “Threads”.

v0.4.0-beta.1 22 Jul 2026 6 notes

Your skills, per project

Turn a skill off for one project and it stays off: toggles now write Claude Code's own skill overrides, so sessions actually obey them
The Skills library is a quiet two-line register now, with a single-axis reader page
The Marketplace joins the ruled design system and spends its one accent on the update dot
The full-window reader speaks the pinned reader cell's design language
Release notes reach members automatically the moment a build lands on the download page
Caffeinate can no longer mistake an idle agent for a working one: the running-vs-busy matrix is pinned by tests

Engineering notes for v0.4.0-beta.1

The skill switchboard tells the truth now, and the surfaces around it go quiet. This release makes per-project skill toggles real, sweeps the Skills library and Marketplace onto the ruled design system, and teaches the ship’s log to mail itself.

Skills, per project

Turning a skill off for a project now writes Claude Code’s own mechanism, so new sessions actually honor the choice. The old toggle kept a private map that changed nothing; the library could say “0 enabled” while every skill loaded anyway.
The library reads truthfully: switches default to on, the header says “all available” or “N off in this project”, and startup sweeps away the symlinks the retired system left behind.

The ruled design system spreads

The Skills library becomes a quiet two-line row list with a single-axis reader page: three working grays, ghost pills, hover-revealed row meta, and one weightless accent.
The Marketplace recasts from the card grid to the same directory register: 56px two-line rows grouped by space, a quiet search field, hover-revealed Install, and the single accent spent on the update dot.
The full-window reader now renders in the pinned reader cell’s design language, so reading a file looks the same whether it is pinned in the grid or filling the window.

Release notes that sail themselves

The changelog entry carries the release email as reviewed frontmatter, and a workflow mails every accepted member automatically when a build reaches the download page: same suppression, unsubscribe headers, and idempotency as the admin console, and a re-run can never double-send.
A campaign CLI backs it up with preview, canary, and blast modes for hand-run sends.

Fixes and hardening

A grid showing a single cell drops the focus ring; the highlight returns the moment a second cell joins the deck.
The caffeinate hold and the status bar answer different questions, and the full running-vs-busy state matrix is now pinned by tests: cells idle at their prompts keep “N running” on the status bar while the display hold releases on time.

v0.3.0-beta.1 21 Jul 2026 6 notes

Every agent, one grid

Run OpenAI Codex and opencode as first-class cells, with the same grid controls and live state as a Claude cell
Point the grid at Gemini, Grok, Kimi Code, or Cursor: four new provider rows, honest about what each one reports
Hand-started a CLI in a cell? Helmsman now adopts it in place and supervises it like its own
Work GitHub issues without leaving the grid: a two-pane workspace with threads, reviews, and direct agent handoff
The launch menu adapts to the providers actually installed on your machine
Web cells paint up to seven times faster, and worktree cells open at their real size

Engineering notes for v0.3.0-beta.1

The grid stops being Claude-only. This release seats other agent CLIs as first-class cells, adopts sessions you started by hand, and rebuilds the issue board into a real workspace.

Run more than Claude

OpenAI Codex and opencode now run as first-class cells: spawn them from the launch menu and they get the same lifecycle state, cost surface, and grid controls as a Claude cell.
Gemini, Grok, Kimi Code, and Cursor join as provider rows, honest about what each one can and cannot report.
The launch menu adapts to the providers actually installed on your machine, and every ⌘N surface now means the same launch.

Adoption

Start an agent CLI by hand in any cell and Helmsman adopts it in place: it is recognized, badged, and supervised with the same fidelity as a cell Helmsman spawned itself.

The Issues workspace

The single-pane issue board is gone. In its place: a two-pane workspace with threads, review comments, and pull requests, plus guided issue creation and direct agent handoff - point an issue at a cell and watch the after-state come back.

Quality of life

Web cells load visibly behind an opaque cover, so first paint is three to seven times faster.
Web and reader cells sit in a real card shell: proper viewport, scrolling, and drag shadow.
A cell drag can start from its title, and worktree cells no longer paint at 80x24 before snapping to their real size.
The usage dashboard now shows the Fable weekly limit alongside the session meters.

Fixes and hardening

The trust gate for codex project hooks now recognizes every TOML spelling of a hooks key, so a repository cannot slip its own unreviewed hooks past Helmsman’s scan.
The settings cog is symmetric again, sign-in code digits sit centered in their cells, and the focus ring follows the ruled style app-wide.

v0.2.0-beta.1 18 Jul 2026 2 sections

A small, fast follow to yesterday's beta.6: the app now notices new releases the way you would want it to. Until now it asked the update feed once every six hours on a plain timer, and a Mac that slept through the night quietly stretched that even further. That is how beta.6 itself sat invisible overnight for anyone already running the app.

Engineering notes for v0.2.0-beta.1

A small, fast follow to yesterday’s beta.6: the app now notices new releases the way you would want it to. Until now it asked the update feed once every six hours on a plain timer, and a Mac that slept through the night quietly stretched that even further. That is how beta.6 itself sat invisible overnight for anyone already running the app.

What is new

The app checks for updates every hour instead of every six.
It also checks the moment your Mac wakes from sleep and when you come back to the window, so a release you slept through is offered as soon as you sit down, not hours later.
A failed check now retries once after ten minutes instead of waiting out the whole interval, so a network blip cannot hide a release.
All of this stays quiet: nothing changes on screen until an update is actually found, and a download in progress or an update waiting to install is never disturbed.

One-time note when updating from beta.5 or earlier

Beta.6 turned on cookie encryption at rest. Session cookies from older builds cannot be read by the new one, so the first launch after updating may ask you to sign in again. Sign in once and you are set.

v0.1.0-beta.6 17 Jul 2026 1 section

The sixth macOS beta is the biggest visual step Helmsman has taken: the whole app was redesigned into one calm, dark register, from the titlebar down to the smallest toast. Under the new coat it is also a different ship: sessions survive a quit or a crash, every agent can work on its own branch, and your voice, your phone, and a fleet lead all get more to do.

Engineering notes for v0.1.0-beta.6

What is new

The app wears a full redesign: new chrome, grid cells, dialogs, menus, toasts, and loading screens, all drawn from one design system so every surface finally speaks the same language.
Fleet restore: quit the app, or crash it, and on relaunch Helmsman offers to bring your whole fleet back, with each Claude session resuming its conversation where it stopped.
Fresh worktrees: a Claude cell can now work on its own git branch in an isolated worktree, so agents never trample your live tree. Finished work squash-merges from the Source Control panel, and unfinished work is always kept, never lost.
Web pages join the grid: open a live page as a cell next to your terminals, or as a browser tab above the grid, so docs and dev servers live where the work is.
Grid decks let you group cells into named screens and slide between them, so one project can hold more sessions than one screen.
Hail, voice dictation: hold Fn and speak. Local transcription turns it into clean text in whatever cell has your focus.
Apps arrive in the Marketplace: install a skill plus a local web app that share one data plane, starting with the Image Studio bundle. Every marketplace item now carries a proper icon.
Pin a file from the ⌘P search as a read-only reader cell, so a spec or a brief can sit in the grid beside the sessions building it. The search palette itself was restyled to the new design.
A lead agent can pick each worker’s Claude model when it spawns sessions over the Fleet MCP, and the cell header quietly shows the model it chose.
Keep-awake was simplified to two plain switches, and the app hardened its process and IPC security throughout.

v0.1.0-beta.5 05 Jul 2026 1 section

The fifth macOS beta, and the first one that lands on its own: if you are on beta.4, the titlebar chip offers this build in place, with no trip back to the members page. It is also the largest beta yet, growing a real control deck around the grid: a usage dashboard, an activity center, a rebuilt Skills library, and a Source Control panel that works the way your editor does.

Engineering notes for v0.1.0-beta.5

What is new

A new Usage view keeps your plan limits in one place, tracking Claude and Codex sessions side by side so you can see how close you are to a ceiling.
An Activity center gathers what happens across the fleet: a bell in the status bar, an event drawer to scroll, and a clear signal when a session is waiting on you.
The Skills tab is rebuilt into the ship’s library: browse and read the skills you have installed, and find new ones in a marketplace.
Source Control was redesigned to work the way VS Code and Cursor do, so you can review and commit changes without leaving the grid.
Settings moved into the library bar and now tie to your account, so your preferences follow you to every Mac you sign in on.
Close a cell in a single click, with ten seconds to bring it back before the session actually ends.
A two-finger swipe pages through the grid, and paging is steadier everywhere it appears.
Cells take their name from the first prompt you send, so a full grid stays readable at a glance.

v0.1.0-beta.4 01 Jul 2026 1 section

The fourth macOS beta. From this build on, Helmsman updates itself: when a newer beta ships, the titlebar chip offers it, downloads it in the background, and a restart lands you on the new version. No more re-downloading from the members page.

Engineering notes for v0.1.0-beta.4

What is new

In-app auto-update is live. Helmsman now checks a private, invite-gated update feed and offers new builds right in the titlebar.
One-time step for beta.2 and beta.3: those builds cannot see the new feed, so grab beta.4 once from the members download page. Every update after that arrives in-app.
Update problems now leave a clear trace in the app log instead of failing silently.

v0.1.0-beta.3 29 Jun 2026 1 section

The third macOS beta. Sign in to Helmsman with your account, meet the generative avatar in the Account chip, and find the update status now tucked into the titlebar next to your project.

Engineering notes for v0.1.0-beta.3

The third macOS beta. Sign in to Helmsman with your account, meet the generative avatar in the Account chip, and find the update status now tucked into the titlebar next to your project.

What is new

Sign in to Helmsman with your waitlist account, right from the desktop app.
A generative pixel-art avatar in the Account chip and its popover.
The update chip moved into the titlebar, beside the project name.
Cells now render Claude Code’s real orange instead of red.
Fixed the Caffeinate popover being unclickable when it overlapped a terminal.

v0.1.0-beta.2 29 Jun 2026

The first official Helmsman beta for macOS. Spawn Claude Code into a grid of up to twelve live terminals and steer a whole fleet of agents from one window. Signed, notarized, and running entirely on your Mac.

Pre-release unreleased 08 Jun 2026 2 sections

Helmsman is being built in public. There is no shipped version yet, so this is the only entry for now. Each shipped release will get its own entry here, newest first.

Engineering notes for Pre-release

Helmsman is being built in public. There is no shipped version yet, so this is the only entry for now. Each shipped release will get its own entry here, newest first.

What is taking shape

The grid of up to twelve live Claude Code sessions per page, each a real embedded terminal.
Spawning a session into a cell from a projects folder you choose.
Focus a cell to steer it, then step back to watch the whole grid.

What is next

The first public build will be a signed and notarized macOS app. Join the waitlist on the download page to get one email the day it ships.