Skip to content

Changelog

v0.22.1

2026-10-14 · build 1359

Agents keep their Quay tools

  • Occasionally, Quay started without its agent tools working, and nothing said so. Agents couldn't add to your Next list, file memory cards, open panels or read project notes until you restarted Quay. Quay now notices when that happens at launch and fixes it right away.
  • Quay no longer risks freezing for several seconds at launch, or when an agent starts driving a browser panel, while it checks whether a port is free.

v0.22.0

2026-10-07 · build 1355

A start page for new browser panels

  • A new browser panel now opens on a start page instead of an empty dark frame. It lists the project's running servers and the pages you recently closed in that project. Start typing to also search ports open anywhere on your Mac, or the web.
  • Each project remembers its last ten closed pages. A page leaves the list when you reopen it.

Browser fixes

  • Signing in through a popup no longer crashes Quay. When a sign-in page, such as Google's “Choose an account”, closed its own window at the end of the flow, Quay could quit on the spot.
  • Closing the developer tools on a browser panel no longer crashes Quay.
  • The address bar no longer freezes. It could get stuck offering to search Google for “about:blank” and stop showing the page you were actually on.

Smaller fixes

  • ⌃Return in an agent panel now reaches the agent, so Claude Code's send-now shortcut works. macOS used to take it to open the context menu.
  • Remove from Space now asks you to confirm and removes the project. Before, the menu item did nothing.
  • A project whose folder no longer exists now reads “Folder missing” instead of showing only a warning triangle.

v0.21.1

2026-09-28 · build 1348

The notch wears Quay's Q

  • The chip now shows Quay's own Q mark in place of the fan of ripples, with a soft glow behind it in the state's colour. You can still tell the states apart by shape: the glow circles while an agent works, holds still when it has finished, and disappears, with the mark dimmed, when nothing is happening. The states that need you carry a badge. It also no longer looks like the green dot macOS shows when the camera is on.
  • The number of sessions in each state now appears only as the digit next to the chip, not also as rings.

To review no longer floods at launch

  • Right after Quay started, To review listed every agent handoff as owed, including ones you had already reviewed, then emptied one row at a time as git caught up. Handoffs git hasn't been asked about yet now show as “Checking N with git…”, and the header reads “checking reviews” instead of claiming nothing is owed. A handoff that has been listed never goes back to “checking”.

v0.21.0

2026-09-28 · build 1345

The notch stays green for as long as an agent is actually working

  • A long tool call no longer reads as idle. Before, the chip went grey about two minutes into any single long step, such as a test run, a build or a `sleep`, even while the row beneath it still said Running. Quay now tracks which tool calls an agent has started and not yet finished, for Claude Code and Codex alike, and a session with a call still open counts as working. A real 335-second call held the chip green the whole way through. On the previous build it went grey at 128 seconds.
  • An agent that stops partway through a turn now gets a colour of its own, amber, next to the orange that means it needs you. Both mean something is waiting on you. Amber means Quay can't tell what, so an unexplained stall still reaches you rather than looking like a finished session.
  • Questions and permission requests have separate colours again. When an agent asks you something the chip turns purple, and a permission prompt stays orange. If both are waiting, orange wins, because nothing moves until a permission prompt is answered.
  • Quay now notices when Codex asks for permission. Codex asks by requesting an escalated sandbox, and Quay used to miss those requests completely.
  • The chip, the expanded notch, the sidebar's NEEDS YOU list and the Dock badge now agree on one count. A single Quay could show a grey chip, four rows under NEEDS YOU and a badge reading 4, all at once.
  • Only the panel you are typing in stays quiet. Before, Quay stayed silent for every other agent in the project you had selected. So if four agents were running and three were blocked, you got no sound, banner or pop from any of them.
  • Two alert sounds no longer play on top of each other. A second blocked or error cue is dropped while one is still playing.

Onboarding sets up the Space you keep

  • The throwaway demo tour is gone. Onboarding is now five steps: agents, attention, berth, your first project, then theme. It creates a real Space and keeps it, and the paywall comes at the end.
  • The theme step comes last so it can preview your own setup: your desktop picture, the Space you just named and the project you just picked. Choosing Glass also shows its slider, so you pick the exact look the app will have.

Spaces and handovers

  • Switching Space brings you back to the panel you were last looking at there. Swiping or clicking the Space row used to keep showing the panel from the Space you had just left.
  • If a repository sits in two Spaces, running a Next item now launches under the Space you are in, including its account, and takes you to the new panel. Before, the choice depended on sidebar order, and the agent could start in a project the sidebar wasn't showing.
  • A handover can now go to a different project. The handover sheet has a project picker, and an agent can suggest a project when it offers a handover. You can still change it.

Smaller things

  • The Glass theme has its own Dock icon, a see-through Q with no rounded square behind it, instead of reusing White's.
  • When a trial starts, Quay loads one page from quayshell.com in the background so the website's analytics can count the new trial. Nothing about your projects or sessions is sent.

v0.20.1

2026-09-18 · build 1314

A shell an agent opens for you arrives with the command in it

  • When an agent opened a shell panel with a command ready for you to run, the panel came up at an empty prompt. Quay filed the command a moment after that panel's shell had already asked for one, so it sat where nothing would read it again — and the agent was told it had been typed, which is how one could go on to say “press Return” over a prompt with nothing on it. The command now travels with the panel as it opens. Nothing else changes: it is typed, never run, and Return is still yours to press.

v0.20.0

2026-09-18 · build 1311

macOS 26 is now required

  • Quay now needs macOS 26 or later. This costs no hardware: Quay has always been Apple silicon only, and every Apple silicon Mac can run macOS 26. If you are still on macOS 14 or 15, Quay simply stops offering you updates — the version you have keeps working exactly as it does today, and nothing is removed.
  • Why: below macOS 26 the system draws the old pre-Liquid-Glass window chrome, so a single download had to be two differently-shaped apps, and only one of the two was ever really looked at. One floor means one design to get right.

The new chrome, repaired

  • The sidebar toggle and the settings gear read as two buttons again. macOS 26 draws one shared plate behind a toolbar's items, which had fused the pair into a single pill beside the traffic lights.
  • The sidebar slides in and out again instead of snapping. Replacing the system toggle with Quay's own button took the system's animation with it, and this puts it back.
  • A panel's bottom edge lands on the divider above the space switcher again. Quay now measures how far macOS insets the sidebar instead of assuming a fixed number — the old value was judged by eye on one machine, and macOS 26 and 27 do not inset it the same.

Licence and trial, out of the way

  • Trial countdowns and licence notices moved out of the band above your panels and into the sidebar, as a card alongside update notices. A window no longer gives up a row of height to say something that is true for at most two days.
  • Entering a licence key is its own window rather than a dropdown wedged under the purchase buttons. The field is monospaced so a mistyped character is visible, there is a Paste button because the key arrives by email, and a key copied with a trailing space or newline now activates instead of being refused as invalid.
  • The "Early Bird · Limited Time" badge is legible: it was being drawn in very nearly the same colour as the panel behind it.

v0.19.1

2026-09-17 · build 1303

Liquid Glass actually renders now

  • v0.19.0 dropped the pre-26 compatibility pin, but every window kept drawing the classic chrome anyway — the release binary was still stamped for an old macOS SDK underneath the flag, so the system never adopted the new look at all. Release builds now carry the real SDK version, so Liquid Glass renders as intended.

v0.19.0

2026-09-17 · build 1300

Durable project notes

  • A project now keeps its own notes, separate from an agent's working memory: select text in any terminal and an Add as note pill fades in, or press ⌘I, or use the new terminal right-click menu. The selection is organized before the note sheet opens, and you can edit the result or keep the raw text if organizing fails.
  • Notes and memory cards answer different questions and now say so: a card is a session's working memory, replaced as the thread moves on, while a note is the project's own reference, kept in the repo. An open memory card offers Keep as note, so a finding worth keeping outlives the thread that found it.
  • Agents can search and read a project's notes as one of their panel tools, scoped to that project and always reading the main checkout's copy — including notes a worktree agent's own checkout never received.
  • Markdown is worth reading now: notes render properly formatted rather than as plain text.

Quay adopts macOS's Liquid Glass look

  • Quay now takes on the newer macOS design rather than pinning the classic one — the titlebar chips, Sky view, the key map overlay and the sidebar were each fitted to the new geometry rather than left to fight it, including a sidebar that now floats as its own card inset from the window edge.

Browser panels can upload, download, and be told apart

  • Uploading a file or downloading one from a browser panel used to do nothing at all, silently — Quay's embedded browser engine only draws the page itself and needs its own dialogs for anything that touches the filesystem. Both now ask, the same way Finder does, and a download asks where to save rather than assuming Downloads.
  • A page's DevTools no longer crashes the app on close.
  • ⌘= and ⌘- now zoom the page itself in a browser panel, not an invisible layer behind it.
  • When a project runs more than one agent, the “let it drive this browser” menu named every candidate the same generic way; it now says which agent it means.

Smaller fixes

  • A licence key or trial failure could scroll off screen with nothing to say why; failures stay visible now, and a trial that already ended says so explicitly rather than just offering to start one again.
  • Selecting text sideways in a terminal could swipe the whole project over to its Config page. Paging between a project's panels and its Config now happens only via ⌘←/⌘→, the dots, or the arrows.
  • A shell panel now shows a small pulsing dot while it's running a command, so a ten-minute install doesn't look identical to an idle prompt — kept visually apart from the green that means an agent is working.
  • Closing a panel that lives inside a saved multi-pane layout now takes it out of that layout immediately, instead of leaving a ghost pane behind until the close finished.
  • A private support address is now reachable from the Help menu and Settings, for anything — a licence receipt, an order number — that doesn't belong in a public issue.

v0.18.3

2026-09-12 · build 1277

Run takes you to the panel it opened

  • Pressing Run on a Next card or a thread row from Home now shows you the agent it started, terminal focused, instead of leaving Home on screen with only the sidebar selection moved. The same walk happens from the worktree sheet, from the board, and when you resume a memory card.
  • The panel Run opens is named after the card it came from — the same headline the Next rail shows — so the sidebar row and the card read as one thing rather than an untitled session and a card you have to match to it.
  • When a launch is refused, Quay now says why in words. Running a thread on an instance whose trial had not started showed a bare Swift error code where the sidebar had always had a sentence; every Run path now shares that sentence, and it tells a trial that never began apart from one that ended.

Closing the last panel lands on Home

  • Closing the only panel in a project used to leave you on “Nothing in view” for as long as the agent took to answer the handoff, then drop to Home once the note had landed. The panel is out of view from the moment you close it, and the screen now agrees: you land on Home at once while the handoff completes behind you.
  • ⌘L closes the active panel without asking for a handoff note. It is the same close as ⌘K — the process ends and the worktree is retired — for a panel you already know has nothing to hand over. The session is stamped as never asked rather than settled, so the memory reaper still reads its transcript. It is in the Panel menu and in the key map beside ⌘K; ⌘⇧K was not used because Notion claims it system-wide.

Panels stop wearing another worktree’s branch

  • A panel whose agent had walked back to the main checkout could keep showing its last worktree’s branch and diffstat indefinitely — and since git status is checkout-wide, what it showed was whoever else was editing that worktree. The two worktree caches never removed an entry; they now carry the path each fact was fetched for, drop a late result for a path the panel has left, and answer nothing for any other path, which the chip renders as absence rather than a stale badge.
  • Where a panel is now has four named states — the main checkout, a worktree, somewhere outside the project, or unknown with a reason — and a live working directory on main outranks a stored worktree instead of being read as “keep what we had”. Every change of a panel’s location, its evidence and its session is written to one log under panel-context, so the next mismatch can be read back rather than reconstructed.
  • Agents can tell Quay where they are working. A new panel_context tool takes the agent’s current directory and an optional one-line title; Quay checks the path against a fresh list of the project’s worktrees, works out the location itself, and weighs that report against the transcript. The agent never names a branch or a diffstat, a directory outside the project is refused, and the title sits below any name you gave the panel yourself.

v0.18.2

2026-09-12 · build 1267

Browser panels sign you in again — on purpose

  • Every Chromium panel will ask you to sign in again after this update. Until now Quay's browser stored its cookies under a placeholder key that Chromium itself calls a mock, which meant anything running as your Mac user — an agent, a script, another app — could read them without ever asking to drive a panel. Cookies are now encrypted through the real macOS Keychain, and because the old ones have to be treated as exposed, the old profile is removed rather than migrated. If an account was signed in inside Quay, consider also signing out of it wherever it keeps sessions.
  • An agent asking to drive a page on localhost used to get the browser armed for it automatically, and a localhost page can embed any site you are signed into. Arming is now always yours to grant, whatever the address. A page an agent pins is confined to its starting origin — frames, redirects, images, fetches, workers and popups included — and runs on a throwaway profile that never sees your identity's cookies.
  • Chromium's renderer processes now run inside the macOS sandbox, and the helper apps have shed every entitlement they had not earned: only just-in-time compilation remains. A page that finds a way out of the renderer no longer lands with your user's reach over the filesystem.

Agent access tokens stay off the command line

  • The token that lets an agent drive a browser panel, or call Quay's panel tools, was visible in the agent's own command-line arguments — where any process running as you could read it and pose as that agent. Agents now receive a path to a private file instead, in a directory only your user can enter, deleted when the panel closes.
  • Licence and feedback credentials moved to the Data Protection keychain, readable only while this Mac is unlocked and never carried into a backup or another device. Every keychain call now reports its failure instead of silently continuing.
  • Quay's local endpoints for agents now cap header sizes, connection counts and message sizes, and time out a handshake that stalls. None of this is behaviour you should notice; it closes the door on a misbehaving client holding a listener open.

Codex panels stop showing a subagent that was never one

  • Nearly every Codex panel carried a “1 subagent — Untitled session” drawer in the sidebar. It was not a subagent. Each time Codex asks you to approve an action it runs a short review thread of its own to judge that action, and files it as a child of the panel's session. Quay took every child for delegated work. Those review threads are now recognised for what they are and kept out of the drawer — and out of Home's fork count and the notch's “subagent running” line — while a thread Codex genuinely spawns on your behalf still shows.
  • Sessions already indexed are classified once at launch, so the drawer disappears without waiting for new activity.

Agents can read and retire the Next list

  • An agent can now read its project's open Next items and ask to retire one that turns out to be done, instead of leaving finished work on the list until you noticed. Retiring is proposed, never written: the confirmation names the item, and an agent only ever sees the items filed under its own project.
  • Running a Next item under Codex now takes it off the list and walks you to the panel it opened, as it already did under Claude Code. Codex's session id arrives a moment after launch rather than at it, and the item's retirement had been waiting on an id that was never there. Items run under Codex before this update stay on the list and come off by hand.

v0.18.1

2026-09-11 · build 1260

Browser passkey provisioning

  • Quay now includes an Apple-issued provisioning profile authorizing Chromium’s passkey keychain. This supplies the keychain access required for native Touch ID passkeys in browser panels.
  • Signed builds validate the provisioning profile before packaging, preventing a missing or mismatched profile from producing an app that macOS refuses to launch.

v0.18.0

2026-09-11 · build 1259

Quay stops chewing a core on large repos

  • On a repository with a lot of local branches, Quay could sit at well over half a core indefinitely, doing nothing you asked for. To review was confirming, one branch at a time, whether each unmerged branch still carried work — a separate git process per branch, every few minutes, forever. On a repo with 525 branches it could never finish the sweep before it was due to start again.
  • The cost was not really about how many branches you had. The cheap pre-filter that was supposed to narrow the list asked git which branches were merged — relative to whatever branch you happened to have checked out. Sitting on main it struck almost everything and the sweep was tiny; sitting on a feature branch it struck nothing and every branch went through the slow path. Measured on Quay's own repo, the same 54 branches cost 7 checks from main and 52 from a spike branch.
  • That whole source is gone. Nothing in Quay runs a per-branch git check any more, and what remains costs the same whether a repo has ten branches or a thousand.

To review is pull requests only

  • To review now shows two things: pull requests you opened, and pull requests where someone asked for your review. The second is new — until now a PR waiting on you was invisible in Quay unless you happened to have written it yourself. Those rows are marked “review requested” so you can tell at a glance which are yours to write and which are yours to read.
  • What it no longer shows is a bare branch — one carrying commits with no handoff and no PR. That was the source costing a git process per branch, and it was the least certain signal of the three: a branch can sit unmerged for a dozen honest reasons. A PR is something you or a colleague deliberately put up for review, which is a better definition of work owed attention.
  • A pull request that is both yours and awaiting your review appears once, counted as yours.

Signing in inside a browser panel works

  • Signing into Google in a Chromium panel made Quay's window disappear — no crash, no quit, nothing in a log, with the process and every panel still running behind it. A page that believes it is a popup is allowed to close itself, and the close request was travelling up to the nearest real window, which was Quay's.
  • Popup-based sign-in flows now complete. A popup gets a real window of its own — titled, closable, resizable — rather than being cancelled and reloaded over the panel, which used to break the handoff a credential flow depends on: the sign-in would take your password and then simply stop.
  • Browser identities keep their own persistent profile, so a panel signed into an account stays signed in, and a panel asked to use a context that does not exist now refuses instead of quietly falling back to a shared one.

v0.17.0

2026-09-10 · build 1251

Home shows the state of the work

  • Home used to open with a greeting and an “Ask Claude to…” box borrowed from a chat app. It now opens with one line of facts about the Space — projects, agents live, sessions owed a note, and how many are waiting on you. A typed launch already lives in the New tray, so the most valuable strip of the screen carries the state of the work instead of a second composer.
  • Every block says when you were last there rather than only the quiet ones, a live agent’s mark pulses while it is actually moving, and the context meter is one continuous bar with the exact percentage beside it. A review row leads with its head ref, says what the agent did, then how big the diff is, and dismisses in words — recording a watermark is not the same act as closing a row.
  • Next is a stack of compact rows instead of a sideways-scrolling rail: four items no longer cost the whole column and half the block, and there is no second horizontal strip above the Memory deck for a trackpad to confuse. Memory keeps its deck, because a memory card is a document you read and a Next item is a line you act on. Add now sits on the Next zone’s rule, where a control that acts on the whole zone belongs.
  • A project is the only large type on the page now, marked with a filled folder, and its Space reads as a running head above it — so a Space called “Quay” holding a project called “quay” no longer prints the same word twice in the same weight. A project’s zones are indented beneath its header, and a project with work in it folds shut from one chevron that animates out of the header it belongs to. A quiet project gets no chevron: a disclosure that reveals nothing is a control that lies.
  • The memory deck is a 30-point spine seen edge-on — dot, title, byline and age on one line, with the card’s next step printed on a second. A handoff card is filed for its next step, so that line is on the card rather than behind a hover; the full reading still happens on the open face, which is unchanged.

Every launch says which agent runs it

  • Run on Home dispatched to Claude Code and never said so — in a two-agent app, the New tray was the only surface that ever named Codex. Run now asks, at every site it appears (an open card, a flat row, a parked line), and offers only the agents actually found on this machine.
  • The choice travels the whole way through, including the worktree-collision detour: accepting that offer used to launch Claude Code on a row where you had chosen Codex. The picker is drawn by Quay rather than by AppKit, so it keeps the row’s own type and metrics instead of reading as a control borrowed from another application.

Closing a panel keeps its handoff, and its name

  • Chained ⌘K closes now each get their own wait, their own seal and their own toast. The coordinator held one pending panel, so a second close while the first was still writing its note overwrote it — the first panel’s handoff then matched nothing and the panel stayed hidden, a live process you believed was gone, until quit.
  • Every toast leads with the panel’s title as the sidebar showed it, captured at the gesture because the toast outlives the row that knew the name. A saved note is drawn as the card it is — paper and brass, byline, title and its next step, at a size you can read — while the other outcomes stay compact notices, so a chain of empty sessions does not balloon the stack.

Fixes

  • “Review the transcript manually” no longer returns to Home after every launch. Three faults behind one screenshot: a session that had already answered its handoff was reaped again on each launch, the reaper’s own headless reply was itself filed as a card and as a row saying an agent was awaiting you, and the summarizer declining to name a next action was recorded as a work item. A card written at or after your last turn now settles the death for as long as nobody speaks again, the companion’s reply is excluded from both ingest chains, and a card with nothing to propose files no next step at all.
  • Launch does less before the first frame. The orphan sweep — about 63 ms of work against a real index — now runs a tick after the window is up, the handover sheet no longer runs two git commands on every layout pass while an agent proposes a handover, and the Markdown link pattern is compiled once rather than per heading, list item and table cell.
  • Dates on Home print one unit — “33m ago”, “yesterday”, “2d ago” — instead of “33 min, 2 sec”, so a column of them stops being a different width on every line.
  • A memory card’s byline no longer collapses to a single letter beside a long title, and a Next item whose body repeats its own headline no longer quotes the headline back at you.

v0.16.0

2026-09-10 · build 1235

An agent can ask what this project already learned

  • The quay-panels server now lets an agent search the memory cards earlier sessions filed, then read the one or two that hold the answer. Before it re-decides an architecture choice or repeats an investigation, it can ask what this project already worked out and carry the evidence into the work in front of it.
  • Search returns a short excerpt that earned each match, with the session's date, agent and branch beside it; reading the whole card is a separate step. That keeps the archive out of the conversation until the agent has evidence for which card matters, and makes every remembered claim traceable to the session that made it.
  • Retrieval stays local, read-only and inside one project by default. It runs no model and spends no allowance, and its measured ranker found each answerable question first across 296 real cards in about 0.2 seconds. A card filed with memory_capture is no longer a diary nothing reads; it is project memory the next agent can use.

Quay does less work while nothing changes

  • Usage badges for the same account now share one read and one timer instead of each polling the same file, and unchanged values no longer redraw every copy. Branch scans are bounded and reuse the facts one git call already returned, so a board with several projects stops multiplying quiet background work just because more of it is visible.
  • The New tray's digit shortcuts keep working when you correct the route — for example, opening Panel and then switching to Agent. That page change used to remove the focused view without re-arming it, so bare 1–9 went dead while the command-key versions still worked.
  • Updates can be small again. The release pipeline now retrieves recent published archives before building the Sparkle feed, so an isolated release worktree still produces and publishes deltas instead of making every updater download the full app.

v0.15.0

2026-09-10 · build 1213

Your agent writes its memory card while it still knows

  • An agent in a panel can now file its own memory card mid-session — the moment it has decided something, ruled an approach out, or found a trap — instead of only when the session ends. That is when it knows the most, and it used to have nowhere to put it.
  • The card replaces the thread's previous one rather than piling up, so the newest picture is what a fresh session reads. Older ones stay in history; nothing an agent files destroys anything.
  • It writes straight away rather than asking you. A card is the agent's report of its own work, and it has to keep working while you are away. Nothing reaches your Next list — a card is a memory, not a task.

Closing a panel no longer makes you wait

  • ⌘K asks the agent for its handoff and gets out of the way. The panel goes at once, and a small card at the bottom of the sidebar tells you what came back: the note it wrote, or that there was nothing worth keeping.
  • Every closing agent is asked now. Quay used to guess from turn counts whether a session had earned a note, and got it backwards on its own most common shape — a panel dispatched with one prompt that then works alone for an hour scored as a lookup. It asks every time and decides afterwards, on the note that actually arrived.
  • A next step only reaches your Next list when you and the agent actually agreed on one. An agent asked "what's next" will always find an answer, and that filled the board with work nobody had chosen. A session that learned something without committing to anything keeps its card and adds no row.

Codex hands off too

  • Codex has been unable to write its own handoff note for as long as Quay has kept records — one note against sixteen reconstructions pieced together from its transcript afterwards. Two unrelated reasons, both fixed: Quay was pressing Return in a form Codex does not read, and it was never reading Codex's answer at all.
  • Closing a Codex panel now writes its note in seconds, the same as Claude Code. The same fix reaches quitting Quay with Codex panels open, which lost their notes the same way.

v0.14.0

2026-09-09 · build 1182

Your agent can open panels, and write down what's next

  • An agent running in a Quay panel now reaches a second server, quay-panels, alongside the browser one. It can put a page on screen for you to look at, open your dev server in a panel it can read back, open a shell with the command typed ready but not run, and split a tangent out of the conversation into a new agent panel that carries the context with it.
  • It can also add to your Next list. When an agent proposes an item, the Derive Next sheet opens prefilled and editable and you decide — nothing lands on Home behind your back. The whole family holds one rule: these tools create and propose, and never sign in as you or run a command.
  • Codex gets the same server Claude Code has, and an agent panel opened this way no longer steals your focus mid-sentence. Derive Next moves out of the way in return: on a panel with a live agent you can simply ask, so the button now only appears on a dormant panel — the one case with no agent to ask.

Next is a rail of cards

  • A Next item is a title and what is known about it, which never fitted the one-line row the zone used to be. Next is now a horizontal rail of cards — the same stock as the Memory deck, in its own material — and a card opens the way a memory card does, so you can read the whole briefing before you send it.
  • Adding moved into the rail: the first slot is an outline you press to open the same two fields an agent's proposal arrives in, so writing an item by hand and accepting a suggestion are one place and one shape. The rail shows even when it is empty, since that is exactly when you most need the control.
  • The zone leads with whatever was written last, rather than sorting threads ahead of parked items — a freshly added item used to appear below everything and sometimes off the end, which reads as the add having failed. Run is on the open card now, beside the content it will send, instead of a small disc on the resting one. Both kinds of card say Dismiss.

Every shortcut, on the keyboard you are actually typing on

  • ⌘? opens a key map: the shortcuts Quay binds, drawn on a picture of your own keyboard. Chords that lived only in code and appeared in no menu — ⌃Tab, ⌘⇧B, ⌘D-hold — are on it, and anything that cannot be undone says what it costs in words rather than leaving you to find out.
  • It draws the board you have, not a US one: ANSI and ISO are different shapes, and a French keyboard is labelled differently again from a US layout selected on French hardware. Keys are identified by position rather than by the glyph printed on them, so the map stays true when the layout changes.

A wrapped panel is a full panel

  • If you launch agents through a wrapper — a sandbox command, ollama launch, your own script — your override used to replace everything Quay passes, so the panel started with no session id: no model or context badge, no history, no handoff card, no Derive Next, no review. For a wrapper Quay recognises, your command is now composed with Quay's arguments instead of replacing them, and the panel starts bound on first open with all of that intact.
  • The arguments travel as real arguments, never pasted into the command string, so a path with a space in it and a sentence with backticks in it reach the agent as written rather than being interpreted by the shell. An override Quay cannot read still starts unbound, and the wrapped badge's tooltip now says which of the two you have and what it costs.
  • Fixes a regression for anyone launching through Ollama: ollama launch claude puts the agent's name last and consumes what follows it, so Quay's arguments were handed to the wrong program and the panel exited with "unknown flag: --session-id" before drawing a frame. Each wrapper now declares how it treats what follows, because nothing in the command string can tell the two conventions apart.

Derive Next can offer the tangent

  • A pass over a session had to return exactly one instruction, so a conversation with a main thread and an unfinished side quest lost the side quest — which, often enough, was the thing worth doing. It now offers up to three, each marked as the main thread or a tangent, and you pick. Adding still adds one item.
  • It reads a longer window of the conversation — 120 messages rather than 40 — so a tangent raised earlier is still in scope.

v0.13.2

2026-09-09 · build 1136

A browser panel asks where to go

  • A browser panel opened with nothing picked used to show the blank white frame the engine starts on, and quietly put the cursor in the small address bar at the top without saying so. The panel now focuses that field and opens its dropdown, so the question is on the field where the answer gets typed rather than on a card in front of the page.
  • The dropdown lists the localhost servers running in the project you are in, so a dev server is a keystroke away instead of a port you have to remember. Your Mac's other listening sockets are still reachable — type "ollama" or a port number and they appear under their own quieter header — but they no longer fill the list with ControlCenter and rapportd before you have typed anything.
  • New ▸ Panel loses its Browser page as a result: Browser opens a panel directly and the panel asks. The port scan now runs when you are actually looking at the list, rather than on a page that closes the moment you pick.

New ▸ Agent holds the runtimes

  • Agent used to lead to a list of roles, while the two things almost every session starts as sat under Panel. They have swapped. Agent now opens on Claude Code, Codex, your Ollama models and a Custom agents chevron; Reviewer and your own agents are one level down behind that chevron. Panel keeps what is not an agent — Shell and Browser.
  • Ollama models moved across with them, because a local model has always run in an agent panel and only sat under Panel by accident of where the runtimes were. The digit keys moved too: 1 and 2 are Claude Code and Codex, and a digit now lands on exactly the row a click would — including one for an agent you have not installed, which leads to its install guide rather than silently starting nothing.
  • An empty pane opens on the agent root and gains a row across to Panel, since it has no Agent and Panel buttons of its own and half the tray was otherwise unreachable there. ⇧⌘O still forces a worktree, and now reaches the runtimes directly.

Ollama says which gate is actually missing

  • The model picker told everyone with no models to run ollama pull, and everyone with a cloud model that cloud models need ollama signin — one fixed sentence each, true only by coincidence. They are two independent gates: ollama pull succeeds while you are signed out, so a cloud model could sit in your list looking ready and then fail at the first prompt with an error the notice had called metering. Each notice now names only the gate you are missing, and the account that will be billed.
  • When the sign-in is what is missing, a Provision row hands it back and opens the page Ollama's own refusal pointed at. It opens in your system browser rather than a Quay panel, deliberately: it redirects to a third-party hosted sign-in, which is the class of page that took the whole app down in v0.13.0. Quay then re-checks for up to five minutes, so the notice corrects itself where you are looking.
  • The Accounts pane now says, on the row itself, that this sign-in is not per-identity. Ollama's credential is a keypair its daemon holds once per Mac, so unlike every other row there it is shared across your identities. A daemon that is not answering gets no section at all. Measured against ollama 0.32.14.

The notch stops impersonating the camera, and stops lying about Done

  • The working mark was a filled green disc a few points from the camera housing — the same hue, the same size and the same place as macOS's own camera-in-use indicator. It is now a fan of arcs that is never a filled shape at any point in its cycle, so it cannot be read as that light. Green stays, because green is what running means everywhere else in Quay; it is the shape that stops colliding.
  • A row said Running for two minutes after a turn had visibly ended, and for a Codex session could not have said anything else. Quay now keeps the finish's own timestamp and asks whether anything happened after it, so the chip can carry a real Done state — held for as long as the session counts as live, and distinct from the one-second flash that announces the finish. A second of that flash over a green chip is a cheap announcement; two minutes of it while an agent is running was a wrong one.
  • The notch width setting only ever resized the window and never the band laid out inside it, so pulling it in made the chip narrower and left the margins to whatever overflowed. Both now follow from the same number, and the ripple sits where the gap says it should instead of hard against the project name.

v0.13.1

2026-09-09 · build 1128

A sign-in page no longer takes Quay down

  • Signing in to Google in a browser panel could kill Quay outright, and every agent panel with it. Nothing about the sign-in was at fault: Google offers to use a nearby phone as a security key, and merely checking whether that is possible reads the Bluetooth adapter. macOS ends an app that reaches for private data it never declared, with no prompt to refuse and nothing an app can catch. Quay declares it now, so the worst case is a permission request you can decline.
  • Declining costs you only the phone-as-security-key option on pages that offer it. Everything else about signing in is unaffected, and passwords and passkeys already on this Mac never needed Bluetooth.
  • This was reachable from any page, not just Google's; anything asking about passkeys would have done it. If a browser panel has ever taken Quay down on you, this is why.

Camera and location can now be granted, not just refused

  • A page asking for your camera or your location was being turned down before you were asked, because Quay had not declared those either. Both now reach you as a normal macOS permission request, once, and your answer sticks.
  • Quay itself still wants neither. These belong to whatever page you opened in a browser panel, which is also why the request names what the page is for rather than Quay.

v0.13.0

2026-09-09 · build 1126

Run an Ollama Cloud model

  • The model tray's Ollama page now lists cloud models beside the ones you have downloaded. Pick one and it launches the same agent panel a local model does. The panel's label says Cloud, and still says it after Quay relaunches that panel.
  • Quay never sees your Ollama account. It talks to your own Ollama server and runs your installed ollama CLI, so sign-in, credentials, quotas and transport all stay with Ollama. Cloud models appear once you have registered one — ollama pull gpt-oss:120b-cloud — and running one needs ollama signin.
  • That sign-in belongs to your Ollama installation and is shared across Quay identities. Identities isolate agent configuration; they do not pretend to isolate an external account.

Glass, on a bar you can move

  • Appearance settings has a glass bar with four settings — Frosted, Tuned, Showcase and Crazy. Each is a hand-tuned set rather than a point on a slider, because making the terminal clearer requires a panel's edges to get brighter rather than fainter, and one scalar moved both the wrong way. Tuned is the default.
  • Your desktop reads through the window now. The frost was homogenising whatever sat behind it into flat grey at every setting, which is what made tinting it harder never help.
  • A panel card has a lit top band and a bevelled rim, so it reads as a card rather than as a dim rectangle with text along its top. The rim yields to the accent colour when a pane is focused, because the focus ring states a fact and the bevel only states thickness.
  • The bar appears on the Glass theme and nowhere else. There is no setting for no glass — glass at zero and the Dark theme are the same picture, and whether there is glass is the theme's question.

Memory carries into the next session

  • Running work from a memory-backed Home row now hands the next agent the whole card — objective, decisions, gotchas and the files that were touched — stamped with where it came from and flagged as an unverified agent report. It used to arrive as a status line and a next step.
  • A dormant session in History offers Create Summary when it has none and Refresh Summary when it has one. The pass runs on the runtime and the account that own that transcript, never a substitute, and it refuses to file a card when it cannot prove which branch the work was on.
  • Nothing is written until you choose Save Summary; closing the sheet discards it. Saving files a new version of the card and leaves the earlier ones on disk. It is a memory correction, not an instruction to put the thread back on Home's work queue.

Codex threads get asked for a handoff note

  • A Codex session is now asked to write a handoff note when it has done enough work to have something to say. Not one shell command, file edit or tool call Codex ran had ever been counted, so every Codex thread scored zero work — and the threads carrying the most to hand over were the ones structurally certain to be skipped.
  • Sessions already indexed start counting from their next tool call and reach the threshold within a turn. Ones that were already closed without being asked stay that way: that record is a claim about a conversation that happened, and rewriting it here would be a guess.

The menu-bar chip

  • The mark ripples while agents are working. Rings are evenly phased at a fixed period, so more sessions read as density rather than as speed — a busy morning should not look like an emergency. Idle stays still because stillness is the signal, and Reduce Motion drops the rings rather than freezing them.
  • Its margins match on both sides now, in both states. The right inset ran up to 16pt further in than the left and shifted when the chip opened, while the left never moved.
  • Clean and Detailed do something again. The setting had a picker, a saved preference and no effect at all since 22 August, when the commit that made the chip expand deleted the only thing that rendered it. Both halves of the band strip together in Clean, and Detailed is the default.
  • The band names the project and nothing else, open or closed. The open state used to show a rollup of its own, so the two halves of one surface described different things.

v0.12.1

2026-09-07 · build 1117

Only offered when it can happen

  • A browser panel no longer offers to let an agent drive it unless there is a browser engine behind it to drive. Where the engine is missing or damaged, the panel falls back to WebKit and the control is simply absent, rather than present and unable to do what it says.
  • You will not see a difference in a healthy install, where the engine is always there. This matters when it is not — which, before v0.12.0 shipped the engine, was every install.

v0.12.0

2026-09-07 · build 1113

Let an agent drive a browser

  • A browser panel can be handed to an agent running beside it. Open the drive menu in the panel's chrome, pick the agent, and it can navigate, click, type and read the page — through the same Playwright tools it would use anywhere else. The panel says who is driving it while it happens, and Stop driving takes it back.
  • One agent, one panel, and only while you say so. Arming opens a loopback connection scoped to that panel and nothing else; disarming closes it. Nothing is armed by default, and changing a Space's identity disarms everything.
  • This has been in Quay since v0.11.0 as code that could not run. Released builds carried no browser engine, so the panel fell back to WebKit and there was nothing for an agent to drive — which is why no earlier release mentioned it.

Browser panels run on Chromium

  • The engine is in the app now, so pages render the way they do in Chrome, and the toolbar's hammer docks Chromium's own DevTools beside the page.
  • You will be signed out of sites you were signed into in a browser panel. WebKit and Chromium keep separate cookie stores and nothing carries over between them. This happens once.
  • The download is larger than it was — around 145 MB against 10 MB — because the engine ships with the app rather than being fetched later. Updates after this one stay small: the engine only changes when Quay deliberately moves to a new version of it.
  • If the engine is ever missing or damaged, browser panels fall back to WebKit and keep working. You lose driving and DevTools, not the panel.

Every identity keeps its own browser

  • A browser panel's cookies and logins belong to its Space's identity, exactly as they already did on WebKit. Sign into something as one account in one Space and a Space on another identity does not see that session.
  • Two panels on the same identity do share a browser, so opening a second one does not sign you out of the first.

v0.11.1

2026-09-07 · build 1107

Nothing you can see

  • This release carries the tooling that produces the screenshots on quayshell.com, and two environment variables that point Quay's session-history roots somewhere else. Both are unset in normal use, so Quay reads exactly the history it read in v0.11.0.
  • It exists so the website's screenshots can be taken against a seeded fixture rather than real projects. Redirecting the home directory did not achieve that — a capture instance indexed 540 real sessions anyway — so the roots are now an explicit lever instead.

v0.11.0

2026-09-07 · build 1101

Ask the panel what to do next

  • Derive Next asks the agent already attached to a live panel for one concrete next instruction, drawn from the conversation you have just had with it. You see the exact text before anything happens to it, and it has three exits: Add as Next puts it on the branch's Next list, Run it goes through Quay's normal branch and worktree rules, Discard leaves no record at all.
  • It is always something you ask for. No idle timer, no close hook and no reaper event can trigger a derivation, because each one spends your allowance.
  • The pass uses the panel's own runtime and account, not a global reviewer preference or the Home identity — the same launch facts that make a resume correct. It reads the newest 40 messages of that conversation and nothing else, runs in a scratch directory outside your checkout, and cannot use tools.
  • If no branch can be named for the panel, Derive Next is unavailable rather than queueing work against an invented main.

Background model calls now spend the right allowance

  • Every panel-less model call in Quay — memory recovery, second opinion, synthesis, and now Derive Next — goes through one seam that owns the runtime, the model, the account identity and the timeout. Each of those calls spends your allowance without a panel to show it, and which account it spends was previously decided independently in three places.
  • A dead Codex session is now summarized by Codex, on the identity that ran it. It was being summarized by Claude Code on the Home identity, while the memory card it produced said Codex had authored the session.

Codex sub-threads stop stealing the session

  • codex-cli 0.150 spawns a short-lived guardian thread to judge a planned action, and files it beside the panel's own thread — same directory, same project, same identity, about a tenth of a second later. An idle panel would adopt it. The guardian then took the panel's close stamp and the session that had actually done the work was left with no end cause, no memory card, and a handoff note nothing would ever read.
  • Quay now reads the parent thread id Codex writes into the session's own metadata, so a sub-thread can never be mistaken for a successor, is never owed a note, and never has a memory card manufactured about it.

Smaller things

  • Closing a dormant panel no longer discards its transcript. The close stamp asserted the handoff note question had been settled, and one of the cases it covered was “the panel was dormant and there was nobody to ask” — the opposite of settled. An afternoon of work became unreapable at the moment its panel was closed, and the note is the one thing a close cannot recover.
  • Filing a bug or feature request ends the form and tells you what happens next, instead of leaving you looking at a sheet that has already submitted.
  • A permissions problem on the issue tracker is no longer reported as an expired sign-in, and no longer deletes the token you just obtained.
  • The price card is in US dollars, matching what checkout actually charges.

v0.10.1

2026-09-05 · build 1057

Next steps can be dismissed

  • A thread on Home's Next list can be taken off it. Until now a next-step you had typed yourself — with no memory card behind it and no worktree left to retire — carried no controls at all, so the only way to clear it was to write another next-step over the top.
  • Dismiss is not Retire and it is not a delete. Retire removes a worktree and a branch; Dismiss says only that this thread is no longer what you are doing next. The note keeps its text, and the next handoff or Next… on that branch brings the thread straight back.

v0.10.0

2026-09-05 · build 1054

Skills say what an agent will actually load

  • The Skills pane's By scope axis listed one directory per row and called that an answer. Graph replaces it: a node is a place you actually run an agent, and its count is what that agent will load there — the project's own skills, your shared toolbox, and that agent's own plugin cache, counted by skill name rather than by directory entry. Two links pointing at one skill stop being counted as two.
  • Codex's plugins are counted too. Quay had hardcoded Claude Code's plugin directory as the only global root, so the skills Codex loads from its own cache were missing from the pane entirely — 33 of them on a machine the pane was reporting as 1.
  • Quay no longer offers to link plugin skills. Every identity's plugins directory already points at the shared one, so a plugin's skills load everywhere its plugin is installed; the old pane offered to link 62 of them and failed all 62 on every click. A plugin skill you want to route deliberately can be forked into your library instead — including for the agent whose plugins the other one cannot reach.
  • One space can be given its own skills without a whole migration. Until now the only route to per-space routing fired when unmanaged skills existed, which for most machines is never.
  • A skill defined twice — once in your library, once in a plugin — is shown as defined twice, and Quay claims no winner. Precedence belongs to the agent, not to the pane describing it.

You can tell us what broke

  • Report a bug or request a feature without leaving Quay — from the Help menu or Settings > About. The sheet asks the questions a first reply would otherwise have to ask, searches existing issues before you file a duplicate, and keeps a browser route that works even when everything else about the submission fails.
  • Nothing leaves your machine that you have not read. The diagnostic report is assembled locally, redacted, and shown to you in full as plain text before it is attached by your own action. It exports as a .txt rather than a .zip on purpose: the whole point rests on you reading what you publish, and a zip is a thing people attach unread.
  • No new backend and no secret to leak. Signing in to file an issue uses GitHub's device flow, which ships only a public identifier, and the app is installed on the tracker repository alone.
  • The tracker is public, at github.com/quayshell/quay, so you can see what other people have hit and add weight to it rather than filing it again.
  • Naming an agent is optional on a bug report. A layout bug, a theme bug and an updater bug have no agent, and a guessed answer reads as signal when it is noise.

Smaller things

  • Each agent carries its own colour in the New tray, so the row you are aiming for is identifiable before you read it.
  • A panel is guaranteed a colour-capable terminal. An inherited NO_COLOR could make Claude Code and other TUIs render flat inside a panel that had promised them a palette.

v0.9.2

2026-09-04 · build 1017

Your own agents

  • An agent is now a role you can write, not just the runtime that happens to execute it. Quay had been using one word for both: "Claude Code session" named the engine and pretended to name the work. A role carries a name, its own instructions and optional launch preferences; a project carries the repository and its context; a runtime merely runs the two together. You choose in that order.
  • Create, edit and delete your own agents in Settings > Agents. They persist, so a role you write once — a release captain, an accessibility reviewer — is there the next time the work comes round.
  • A project's New footer asks the first question directly: Panel (⌘P) for a shell or a browser, Agent (⌘O) for a configured role. Runtime choice stops being presented as the identity of the panel, and picking a role no longer competes with Shell and Browser for the same list.
  • A custom role launches through either Claude Code or Codex, carrying its instructions the way that runtime expects them. Quay reads the models each account can actually reach rather than offering a hardcoded list.

Home says where an agent actually is

  • Run is offered per branch instead of per repository. Home asked "is a panel already on this?" of a set of repository paths, so a single busy agent anywhere in a repo told every thread in that repo that its work was already covered — with two agents live in one project, Run was unreachable across the whole field, including on review follow-ups whose own tooltip promised it.
  • Show opens the panel rather than the neighbourhood it lives in. It had been focusing the row's project, which on that project's own Home field does nothing at all.
  • Where I'm at holds a settled thread so its Retire survives, and now shows only the ones that can still be retired. Accepted threads no longer pile up above your live agents, struck through and weeks old, with no worktree left to remove. Nothing is destroyed — the threads keep their rows and their memory cards; the field just stops calling them the present.
  • A review follow-up reads as a sentence and says where it came from, instead of arriving as a raw markdown heading from the synthesis document behind it.

v0.9.1

2026-09-04 · build 1002

A handoff note reaches the panel that wrote it

  • Closing a panel with a handoff no longer throws the note away. Quay's own headless runs — a review pass, a synthesis, the memory reaper — land in the same transcript root as the panel that asked for them, so a panel could quietly adopt one of them as its session; the note it then asked for was answered, refused and left to stall to the timeout. Quay's own runs now name themselves and are never mistaken for your agent, a panel only follows a session in the directory its agent actually occupies rather than the one it launched in, and a note that cannot be placed yet is held and reconsidered instead of dropped.

Launch survives a database it cannot read

  • An unreadable index file used to end every launch before the window appeared — no dialog, no message, and a recovery that meant deleting a file in a directory you would have to know about. The session index is a cache over your transcripts, so it now recovers: in place, then a fresh file after the unreadable one is set aside, then in memory.
  • What you wrote is treated as the only copy of itself. Your queue, next steps, tangents, reviews and finding notes are never rebuilt, renamed or moved; that board simply comes up empty for the session and stays recoverable for a launch that can read it. Every disk-caused launch crash is gone — corrupt file, unwritable directory, full disk, missing parent.

Settings

  • The Settings header reads as one block instead of seven badges. Seven coloured tiles with their labels beside them ran out of width in the sheet, so SwiftUI wrapped the words rather than shrink the row — "Appearan/ce", "Notificatio/ns". Each tab is now a glyph over a single-line label, the row is centred on one recessed band with the title, and the accent colour alone says which pane you are in.
  • An installed copy of Quay no longer offers to launch a dev build from its app menu.

v0.9.0

2026-09-04 · build 994

Review what you actually merge

  • A review is now a batch of commits rather than a branch. A branch diffed against its merge-base was wrong in both directions — too big to read, and blind to code that lands straight on main or arrives through a pull request that gathers several sessions' work. Anything that is a commit range can be reviewed, and where it came from is decoration on that range rather than the thing that decides whether a review is possible at all.
  • Your agent walks you through the diff instead of handing you a list. Findings arrive as a stream that reports its own losses, each one anchored in the code it is about, and you answer them a rung at a time; a second pass reconciles your answers with the findings and turns the result into something you can run.
  • The diff reads like a diff. Two columns, numbered lines, the excerpt cut from the parse Quay already did rather than a second read of the file — and it remembers how you like to read one.
  • A review names its cost before you spend it, and lets you choose the agent and model that will do the pass.
  • Reading a batch records how far you looked, so returning to one shows you what has arrived since rather than starting you at the top again. A batch can be discharged when you have read it to the tip, and you can be done with one for now without reading it at all.

Home is a dashboard

  • Home is four panels, each with one job: where you are, what you did before, what is waiting to be reviewed, and what you marked as next. Next up had been holding two different verbs — work to do, and judgement of work already done — under the name of one of them.
  • A pull request and a branch draw through the same row, because they are the same thing wearing different provenance. A branch carrying commits worth reading now appears on Home even when nobody wrote a next-step for it; previously it was visible only if it happened to be a pull request.
  • A memory card no longer repeats what the row above it just said.

Notes survive the way sessions really end

  • Quay used to ask for a handoff note at exactly one moment — a panel being closed — and that is not how threads actually end. Measured against the live index, closing accounts for a small minority of endings; most sessions are found dead at a later launch. Notes are now kept through the ways a session is really abandoned.
  • The agents get to write their notes before the app goes away, so quitting no longer costs you the context of everything that was running.

Fixes

  • Clicking a scope no longer crashes when two skills share a name; the duplicate is survived rather than trapped on.
  • The review page no longer reloads itself forever, and a failed headless run says what went wrong instead of leaving you to guess.
  • A pass still writing is told apart from one that died, and an empty range says nothing rather than claiming to be empty.

v0.8.0

2026-09-03 · build 886

Attention that means something

  • Quay now raises an error only when an agent has actually stopped on a request failure that needs you. Recoverable tool failures and API retries stay quiet while the agent handles them, and authentication, rate-limit, server, model and invalid-request failures no longer disappear from view.
  • The notch reports live interruptions, not standing review work. Failed checks and branches awaiting review remain in the inbox, where persistent work belongs, without holding the menu-bar signal red all day.
  • Attention surfacing can be switched off completely when another companion already watches your agents. This is separate from mute: turning attention off hides the notch chip and silences alerts, banners and every lifecycle cue, while mute continues to keep the visible state without interrupting you.

Sessions and handoffs

  • Long-running work now earns a handoff even when it began as a dispatched prompt or produced its progress through tools instead of prose. Quay counts the work the agent did, so the sessions with the most context are no longer the ones most likely to lose it on close.
  • Notes dispatched from Home are always treated as text, even when they begin with a slash. A note such as /exit no longer becomes a command that kills the new panel before it can start.
  • Session refresh and transcript indexing do less repeated work, keeping active conversations and history more responsive as the index grows.

Home and the sidebar

  • A memory card can be deleted after you open it. The source file is removed as well as the indexed copy, so a future index rebuild cannot bring a stale or mistaken card back; when an older card exists beneath it, that card becomes visible again.
  • Expanded sidebar rows now keep the session glyph beside the title it describes and place a worktree beside its own diff stat on a stable left edge. Main-checkout panels stay compact, and showing the close button no longer shifts the row underneath it.
  • The resource meter no longer rounds a measurable cost down to nothing, and its detailed sweep opens when you hover so the panel using the machine is quicker to find.

v0.7.0

2026-09-02 · build 870

Spaces

  • A Space now has one place to be edited and one place to be made. Four different routes used to lead to two near-copies of the same form — view-layer copies bound to the same draft, so they could drift apart without breaking a single test, and one of them said so in its own doc comment rather than fixing it. There is one form now, and every route arrives at it.
  • The sky view is a map with no holes in it. Every position resolves to something you can see and aim at instead of leaving gaps you could neither read nor click, and its columns have handles, so the layout is yours to arrange rather than the app's to decide.
  • Spaces sit in the middle of the switcher, where Arc keeps them — the position your hand already expects.
  • Elsewhere is gone. A block's project is a fact now, not a category for the ones that didn't fit anywhere: a bucket named for the absence of an answer is a question the app should have answered itself.

Knowing what Quay costs you

  • The window's bottom edge reports what Quay costs. CPU and memory are sampled on the tick the app already runs, so the reading costs nothing extra to take, and the total includes the panel it is measuring by construction rather than by remembering to add it.
  • When something is eating the machine, the meter names the panel doing it. A number telling you the machine is busy leaves you to find the culprit by hand; the point of measuring was to skip that step. Each panel is answerable for its own processes, decided explicitly rather than guessed from a process tree.

The sidebar and the panels

  • Sidebar rows can be expanded, from Appearance settings. The collapsed row fits the glyph, the title, the model note and the checkout mark onto one line — and the title is the only thing on that line that can shrink, so a long session name is always the thing that loses its characters, to a worktree slug it matters more than. An expanded row gives the title a line of its own: glyph and close above it, the checkout on the left of the line below and what it has changed on the right. The row you have selected spends a second line on its title when it needs one. Collapsed remains the default and is unchanged.
  • Every agent wears a checkout pill, not only the ones running in an isolated worktree. An unmarked row used to mean three different things — on the main checkout, not a git repo at all, or git simply hadn't been asked yet — and the level of isolation an agent was running at had to be inferred from a silence.
  • Config is a page the project has, rather than one you opened. It is somewhere you can go back to, not a mode you fall out of.
  • Open a whole project in your editor, not just one file. Handing over a single file makes the editor a viewer; handing over the project makes it the tool you actually work in.

Elsewhere in the app

  • ⌘⇧N sends the current terminal selection straight to the thread's Next. Capturing a next action used to mean selecting it, copying it, finding Home, and pasting into the field — now it is one keystroke from the panel you are already looking at. A terminal selection is not typed text but a rectangle lifted off a character grid, so it arrives carrying the grid's artefacts: it is cleaned of the NUL bytes standing in for cells nobody wrote, and of the row breaks left wherever a line wrapped. The note lands on the panel's own branch, read from its working directory — a thought caught deep in a worktree belongs to that worktree's work. ⌘⇧N previously opened a new shell panel; that binding is retired, since the New tray on ⌘P already offers Shell and the chord saved a single keystroke. The menu item stays.
  • The six lifecycle cues have real sounds, and the masters they were made from are kept alongside them.
  • The break feed gives you your place back when you return to it, and lets you move on from there.

v0.6.1

2026-09-01 · build 834

Fixes

  • A panel no longer wears the name of a session it has moved on from. Home named each live row from the first thing you typed and remembered that name per panel — but a panel's session changes underneath it: waking one fresh starts a new conversation, and Quay rebinds a session that has rotated on its own. The name was worked out once and then never revisited, so the row kept answering for the previous session for as long as Quay stayed open. The sidebar had this right already; Home now does too

Improvements

  • The pane header says which session it is bound to — eight grey characters of its id beside the mode switcher, the whole id on hover, and selectable so you can copy it. Nothing on screen said so before, which is what made a name left over from an earlier session impossible to tell from a name that was simply wrong

v0.6.0

2026-09-01 · build 829

New

  • The Home field is three zones with independent budgets — what is running now, what is next up, and the memory deck — instead of one shared row budget they all competed for. Thirteen thread rows used to bury the deck at position 14, and live rows were nominally exempt from the cap while still spending it, so a fan-out could leave nothing else on screen. The collision is now unrepresentable rather than arbitrated: live is uncapped, threads and parked work share a cap of four, and memory spines are never dropped
  • A live row on Home says what the agent is doing. A 6pt green dot and a branch name become a state glyph, the branch, the activity right now, then the model, a seven-bar context meter that turns amber under 30%, elapsed time and fork count. A row waiting on you takes an amber wash and a leading stripe. The colour comes from the one place a session state's colour is decided, so Home, the sidebar and the notch cannot drift apart about what a session is doing
  • ⌘⇧P opens the New tray in worktree mode: whatever you pick from it gets its own checkout and asks you to name the branch. ⌘P opens the same tray and means the main checkout — nothing launched from it raises the worktree dialog. The offer used to arrive after the click, interrupting to ask a question whose answer you already knew; shift now says it on the way in. Clicking the New pill states nothing about placement, so it still warns when a live agent already holds the checkout
  • ⌘↓ and ⌘↑ walk the Space's panels, across project boundaries, wrapping at both ends. They step in the order ⌘1-9 counts in rather than the order a card happens to draw, so grids coming and going never reshuffle the sequence, and a step never lands inside a folded project card

Improvements

  • Thread rows rank their actions instead of offering four equal blue links. One primary per row — Run, Run-as-redo in amber when the last review said needs work, or Show — with Review independent beside it, and Next…, Retire and Open transcript moved into a ⋯ menu. Hit targets go from about 14pt to 23pt. The review verdict and a branch that is gone become chips with a 3pt leading stripe keyed to the same state, rather than tertiary grey words sitting indistinguishable from the branch name
  • The mode switcher is one glyph instead of a pill carrying two labels, one of which only repeated the state the pane was already in. It shows the destination — a speech bubble in Terminal, a terminal in Chat — and picks up the Space accent in Chat, which is read-only: a pane parked there with no marker silently eats keystrokes. Both tooltips now name ⌘/, which has toggled the two all along with nothing on screen saying so
  • A panel opened and closed on a single question closes immediately instead of stopping to ask for a handoff note. Two full round-trips is the floor. The count comes from text-bearing messages only, so tool calls cannot inflate it, and a panel with no bound session still gets asked — unknown is not empty, and the note is the part that cannot be recovered afterwards
  • A block header shows its live count as a green capsule rather than a dot beside a grey caption, and Elsewhere gains a subtitle where a quiet date would sit. It counts distinct repositories rather than rows: two orphan threads in one unregistered repo are one repo

Fixes

  • The memory deck renders. Its filter selected cards whose repository and branch had no thread row — a state the writers cannot produce, since capturing a thread writes the row and the card together in one call and nothing ever deletes the row. So the filter matched nothing, on every tick, and the deck had never appeared once in production. Elsewhere carried the same dead filter. Verified against the live index: zero of the twelve latest cards lacked a thread row
  • Handoff & Close no longer stalls to the timeout alert when a panel's session binding is best-effort. Such a panel is matched on the cwd its capture was written in, and the note path never passed one — so a real note matched nothing and the close waited out the full three minutes, while 'nothing to hand off' worked fine. The coordinator's own tests always supplied a cwd, so the gap lived in the wiring, where nothing was looking

v0.5.0

2026-09-01 · build 813

New

  • ⌘⇧B takes a break. A short-form feed — YouTube Shorts or Instagram Reels — opens over your work, and ⌘⇧B again closes it. There is no menu entry, no toolbar button and no settings row for this, deliberately: a break belongs on the surface you asked for it on and nowhere else. It signs in once and stays signed in, in a cookie jar of its own that deleting an Identity cannot reach
  • A break can shrink out of the way. The button at the top-right of the overlay drops the feed into a small floating panel that survives Cmd-Tab, can be dragged to a second display by its frame, and leaves every keystroke to whatever you were working in. It sits above your panels and below the notch, so nothing about a break can ever cover the thing that tells you an agent is waiting
  • An agent that needs you while you are on a break slides a card in from the left, and the video keeps playing. Return jumps to the panel that is waiting, Esc clears the cards and leaves the break running. Nothing stops the feed for you — a break you have to restart every time an agent finishes something is not a break
  • Two feeds, and buttons to the left of the video to change between them. Each keeps its own scroll position and its own login, so switching back returns you where you were

Improvements

  • Close every dormant session in a Space in one sweep, instead of one row and one button at a time. Only sleeping agents qualify: a shell is not a session, a browser panel is never live, a worktree panel would retire its checkout, a panel with no controller may still be bound to a session running outside Quay, and a stopped session that errored is the one row you must not scroll past — so none of those are touched
  • ⌘= and ⌘- now zoom the page when a browser panel is focused, instead of resizing the terminals in the panels behind it. ⌘F finds on the page, which was previously not bound to anything at all. Zoom is a fixed ladder rather than a multiplier, the way Safari's View › Zoom works, so coming back down lands exactly on 100%

Fixes

  • Codex sessions are readable again on codex-cli 0.151. That release replaced the old flat message events with a single typed item, which Quay did not know how to read — so every Codex turn came back with no role and no text, and there was no search, no title, no memory cards and no handoff note. Handoff & Close sat spinning for the full three minutes while Codex had in fact written a perfectly good note. Rollouts written by 0.149 still read correctly
  • The fullscreen button on an embedded video works in a browser panel. WebKit documents element fullscreen as off by default and Quay never turned it on, so that button has silently done nothing since browser panels shipped

v0.4.3

2026-08-31 · build 785

Performance

  • A session card no longer costs more the longer you have used Quay. The two lookups behind each dormant card went to the full-text search table, which carries no index on the session column, so each one read every message Quay had ever indexed — about 35 milliseconds a card against an index of 22,000 messages, and growing. They are now indexed lookups, at about 0.08 milliseconds. This is the cause underneath v0.4.1's fixes: those stopped the lookups happening on every layout pass, this makes the lookups themselves cheap
  • Your existing index is upgraded in the background the first time you open this version — under a fifth of a second on a 22,000-message index, and about 2 MB on disk. Until it finishes Quay keeps using the old lookups, so nothing is missing in the meantime, only slower

Fixes

  • An agent running in a panel now has the PATH your own terminal has. Quay launched from the Dock inherits launchd's environment, which has no Homebrew and nothing from your .zprofile or .zshrc, so an agent could not find gh even though the same command resolves fine when you type it yourself. A Space that sets PATH itself still wins
  • Codex is found when npm is set to install global packages somewhere other than the default. npm config set prefix ~/.npm-global — the usual way around npm install -g asking for sudo — puts the codex binary where neither Quay's shell probe nor its fallback paths looked, so Check again never found it however many times you pressed it
  • A managed identity now says that it keeps its own plugin logins. Each identity gets its own config directory and a CLI's MCP OAuth tokens live inside it, so plugins you signed in to under a different identity are simply not there. Nothing said so, and it surfaced as a plugin failing with a badly formatted Authorization header — which names neither the cause nor the fix

v0.4.2

2026-08-31 · build 777

Fixes

  • Install an agent while Quay is open and Quay now notices. The install page that v0.4.1 added told you what to run and then had no way to find out that you had run it — the row stayed dimmed and the page kept saying "Not found on this Mac" until you quit and reopened the app. There is now a Check again button, and the page steps aside on its own once the agent turns up

v0.4.1

2026-08-31 · build 775

Performance

  • Quay no longer burns a CPU sitting still. An idle app was holding around half a core, all of it on the main thread and none of it producing a new answer: three separate reads — a dormant panel's transcript summary, the Keychain, the session index — were each written assuming they ran rarely, and were in fact re-running on every layout pass. The transcript one scanned your entire history each time, so it got worse the longer you used Quay
  • Home stops rescanning your transcripts for a title that hasn't been written yet. A session's title is looked for once, and again when the session actually says something, instead of on a retry nothing bounded

Fixes

  • An agent you haven't installed is now visible in the New tray instead of missing from it. Without the Codex CLI on your Mac, Codex left no trace anywhere in Quay — no row, no explanation, no way to add it — so there was nothing to click and nothing to read. The row is still there, dimmed, and leads to the command that installs it
  • Onboarding now tells you how to install Codex. It used to say "Optional — add it later" and then never mention it again; every agent now gets the same install command, docs link and Check again button. And Quay only calls it a problem when it finds no agent at all — either one alone is a complete first run
  • Accounts no longer say "Provisioned" for an account that has never been signed into. Setting an agent up for an identity creates its config and deliberately never copies a login across, so the status now reads "Set up — not signed in yet" until you have actually signed in, and the button says Set up
  • A setup error now appears next to the button that failed. It used to render below every identity section, which put it off-screen the moment you had more than one account — a press that failed looked like a press that did nothing
  • Spaces no longer say Claude specifically will ask you to sign in, since the agent is chosen per panel

v0.4.0

2026-08-31 · build 770

Features

  • Skills are now something you manage rather than something that happens to you. One library holds them all, and you choose which agents see each one — so the skills you wrote for Claude are available to Codex too, instead of sitting in a folder only one of them reads
  • Every skill can be switched on per agent, per space, and per project. A client-confidential skill can live in one space and nowhere else; a skill you only want in one repo stays there. Two views of the same page: By skill answers "where does this go?", By scope answers "what does this space have?" — and the second can hand a whole library to a new agent in one action
  • Quay finds the skills you already have and offers to adopt them, showing exactly what will happen to each folder first. Skills you keep in your own directory are linked rather than moved, so that directory stays the original
  • A Skills page in Settings, reachable from a space or a project as well as ⌘, — so "why didn't that skill fire here?" is one click from where you are asking it
  • Local models: panels can run against Ollama, chosen per panel from the New tray, with the model shown on the panel's own row

Improvements

  • The skills list says where each skill comes from and what would revert an edit — your library, a plugin, a repo, or the agent itself — and warns when a skill's declared name differs from its folder, which is the usual reason a skill silently never loads
  • Quay refuses to overwrite or delete anything in a skills folder that it did not create, and says why in place rather than failing quietly
  • The notch now reports one session state, drives its prompts from the screen, and its rows can be answered directly; sidebar rows and the Space dot read the same state
  • A worktree an agent creates and enters mid-session is now noticed, rather than only the ones Quay made itself

v0.3.10

2026-08-30 · build 723

Features

  • Quay now looks for a new version every time it starts, on top of its own schedule. It does this quietly — nothing interrupts a launch — and the news waits for you in the sidebar's Update Available card, on the gear, and in About. Quitting every evening no longer means going days out of date while the app looks current

Improvements

  • The Release Notes sheet now reads as an announcement rather than a document: the app icon, the version you came from → the one now running, and each category as a section you can fold away

v0.3.9

2026-08-29 · build 720

Features

  • The handoff note a closing agent writes now stays on screen for a minute, with a countdown and a Close now button — so you can ask a panel to close, go work somewhere else, and come back to read the card it wrote. Coming back to it restarts the minute; Return closes it straight away
  • ⌘K closes the panel you are in, down the same path as the sidebar's ✕, so a running agent still gets to write its handoff note first. ⌘⌥K only takes the pane out of view

Breaking

  • The ⌘K command palette is gone, and ⌘K now closes the current panel. Everything the palette reached is still there: Spaces and panels in the sidebar and on ⌘1–9 / ⌘⇧1–9, notch settings under Notifications, and past sessions in history search

Fixes

  • Closing an agent panel and then switching to another panel no longer quietly abandons the handoff. Switching away cancelled the wait, so the pane lost its blur, the note that arrived seconds later closed nothing, and nothing on screen said why
  • A pane's X is only offered when there is more than one pane. In single view it could only remove the pane you were looking at, leaving you on "Nothing in view" with the panel still running and the real close still to find in the sidebar

v0.3.8

2026-08-29 · build 715

Features

  • The sidebar now tells you about updates: an Update Available card while one is waiting, and an Update Complete card the first time you open the new version

Fixes

  • The divider beside the Changes and Config file lists is far easier to grab, and dragging it no longer flickers a second divider on screen — you drag a guide line and the panes settle when you let go
  • The disk image you install from is redrawn around Quay's Q-mark logo

v0.3.7

2026-08-29 · build 710

Fixes

  • Fixed a crash when opening a new panel: the worktree-offer sheet no longer blocks the main thread on a git subprocess while presenting

v0.3.6

2026-08-29 · build 708

Features

  • Memory cards on Home are now a horizontal deck of cream cards — titles read at a glance, and clicking a card opens its full story (status, next step, decisions, gotchas, touched files) right on the card
  • Closing a panel seals it with the memory card the session just wrote — the close reads as "this is what it remembered", in the same cream card it becomes on Home
  • New Appearance settings: Dark, White, Glass, or follow the System — the Dock icon changes with the theme
  • Glass theme: white-frost translucent chrome across the window, with the terminal joining the veil
  • Settings redesigned: an Arc-style horizontal tab bar, each account's agents grouped in a bordered box, and tappable icon and colour grids in the Space editor

Fixes

  • Handoff capture no longer loses a card when a panel closes with stale bindings

v0.3.5

2026-08-28 · build 684

Features

  • Licences are now checked with the licence server: paste the short QUAY-XXXX-XXXX-XXXX key from your receipt and Quay activates this Mac
  • Settings → About gains a Licence section — your key, which Macs it covers, and a way to release a Mac you no longer use
  • Quay keeps working offline for 30 days between licence checks, and only mentions it in the last week
  • The paywall lets you pick 1, 2 or 3 Macs, and takes you straight to that tier's checkout
  • The Changes page shows a checkout outline and recent commits, with plainer staging controls
  • New app icon

Breaking

  • Licence keys issued before this version no longer work. If you hold one, contact support and a replacement key will be issued — the app will otherwise fall back to the trial or ask you to buy

v0.3.4

2026-08-27 · build 667

Fixes

  • Install and Relaunch now completes when started from Settings — the Settings sheet no longer springs back and blocks the quit
  • A new session opened in a pane no longer briefly shows the title of the session it replaced

v0.3.3

2026-08-27 · build 664

Features

  • Browser panels reload with ⌘R, open the Web Inspector, and preview a page at iPhone and iPad sizes with a matching mobile user agent
  • Home shows a memory rail: handoff cards from sessions that ended without a next-step note appear as spines in their project, opening the full card with Resume and Transcript
  • Handoff cards now feed thread rows directly — when a card is newer than a thread's note, the row shows what the card says

Fixes

  • Resuming a session after an account migration no longer starts a blank conversation
  • Closing a session that never received a turn no longer leaves it stuck — empty sessions can be escaped
  • A handoff captured while a session is sealing no longer races the capture and is lost

v0.3.2

2026-08-27 · build 648

Fixes

  • Install and Relaunch no longer stalls when triggered from Settings — the update dismisses open sheets before quitting
  • An update relaunch skips the Quit confirmation: live sessions are snapshotted and resume automatically after the update
  • Delta updates download correctly instead of silently falling back to the full download

v0.3.1

2026-08-27 · build 646

Fixes

  • The update badge on the gear now follows you into Settings: the About tab shows the same badge, and the pane says which version is waiting with an Install button
  • License keys are now signed by the rotated release authority

v0.3.0

2026-08-27 · build 642

Features

  • Session memory: every agent session leaves a handoff card — written by the agent when you close its panel, or recovered from the transcript after /exit, a crash, or a quit
  • Dormant panels open with their card's summary, and History sessions gain a Chat/Summary toggle
  • Start new session hands the previous session's card to the new agent; account switches carry it too
  • Agents launched into a repo find a whiteboard of parallel worktree threads in .claude/quay/STATE.md
  • Sky view: Ctrl-Tab toggles a cross-Space overlay of every session, one column per Space
  • First-run onboarding: a live demo, agent setup, and your first Space
  • Licensing: 7-day trial and offline license keys, with the Buy flow in the new About pane
  • Changes page: stage, diff, and commit per checkout, with each file attributed to the session that last edited it
  • Release notes in-app: shown once after an update, always available from About

Fixes

  • Dictation releases the microphone when it stops
  • Live session rows honor a panel's custom title
  • The trial clock starts when you start the trial, not when you installed
  • Browser access and release-security hardening

v0.2.4

2026-08-26 · build 549

Features

  • Live agent sessions automatically resume after an app update
  • Panel header shows your Claude rate-limit usage

Fixes

  • Add Project now uses the same pill styling as a project card's + New button
← Back