Changelog

What’s new in Exponential, newest first: the same entries as the app’s What’s new card. Libraries keep their own changelogs (eUI: packages/exponential-ui/CHANGELOG.md).

November 2026

End-to-end encrypted, in plain words

2026-11-03

Chats, errors and the website now say end-to-end encrypted where they used to say sealed.

Wording: what used to read “sealed” now reads “end-to-end encrypted”, in the apps, their messages and on exponential.at.

MCP servers on your own machine

2026-11-03

A team MCP server can run on an owner’s desktop app or CLI daemon, so apps can use command servers and servers only your network reaches.

Runs on: when adding or editing a server, a team owner picks one of their own machines to run it on; the server’s row reads “Runs on ”.
Apps: that owner’s app tools, upstream reads and the automations they sponsor run there; nobody else’s calls use the machine.
Offline: while the machine is offline, apps keep their default values and show “ runs on , offline”.
LAN addresses: plain http:// is accepted for local addresses (192.168.x.x, .local, .lan).

Apps with several screens

2026-11-03

An app can have several screens: the preview shows them in a sidebar, or a tab bar on phones, and a link can open any screen.

Screens: an app can list up to five screens; the editor’s preview shows them as a sidebar on wide frames and as the bottom tab bar on phones and in the Phone frame.
Links to a screen: a link like /t/team/apps/crm/deals?stage=won opens the app’s editor on that screen, on the web and in the apps.
Navigation from the app: buttons and actions in an app can open another of its screens, with parameters.

Import spreadsheets into apps

2026-11-03

Bring a CSV into an app’s records from the Data tab, or hand a CSV or Excel file to the app’s editor agent.

Import in the Data tab: Import… takes a pasted or chosen CSV, matches its columns to the kind’s fields, shows each row’s problems before anything is written, and imports the ready rows at once, with Undo for 10 seconds.
Authors: team owners can map a column to the member each row belongs to, by email or name.
Agents: attach a CSV or Excel file in an app’s editor chat; the agent maps it, shows a dry run and imports it after you confirm.

Steadier live sessions, apps that work offline

2026-11-03

Live sessions on Android reconnect only what you are looking at, app edits made offline are sent when you are back, and apps can run automations and step records through states.

Live sessions on Android: coming back to the app reconnects only the screens you can see, a thread keeps one live stream for its queue, and a refused connection no longer retries in a loop.
Offline app edits: records you add or change in an app without a connection are kept and sent once you are back online, exactly once.
Automations: an app can run actions on a schedule or when a record changes; its Settings tab lists them.
States: an app can move a record through states (open, in review, done) with rules for who may make each step.
Record migrations: publishing a new app version can rename, fill or convert the fields of existing records.

Undo and history for app records

2026-11-03

Changes to an app’s records can be undone for 10 seconds, and every record keeps a history you can restore from.

Undo: adding, saving or deleting a record in an app’s Data tab, and an app action that writes records, shows Undo for 10 seconds.
History: editing a record shows its history, who changed what and when, and Restore puts back any earlier state.
Agents: exponential_apps gained records_history and records_restore.

Computed fields in apps

2026-11-03

An app can compute a field from a record’s other fields, and filter, sort and group on it like any other field.

Computed fields: an app’s record kind can define fields computed from the record (a total, a due-in-days count); they update as the record changes and work in filters, sorting and grouping.
Team time zone on desktop: the desktop app knows every time zone a team can pick, older names included.

Publish apps when they are ready

2026-11-03

App edits are drafts until someone presses Publish, a team can set its own time zone for apps, and read-only members see an app’s inputs disabled.

Draft and publish: every edit to an app, by you or its editor agent, is a draft; the team keeps using the published version until someone presses Publish. Publishing an older version rolls back.
Team time zone: owners pick the team’s time zone in Settings › General; apps read today and dates in it, so everyone sees the same month.
Read-only access: a member with read access sees an app’s own inputs and save buttons disabled instead of a refusal after pressing.
Safer installs: an app that names a missing component or reads a value that can be empty is refused when it is saved, with the path to fix.

Built-in skills for apps, UI and Motion

2026-11-03

Every team now has three read-only built-in skills that teach agents eApps, Exponential UI and Motion, and every app editor session runs with them.

Built-in skills: exponential-apps, exponential-ui and exponential-motion are in every team’s Settings › Skills, marked Built-in and read-only.
App editor: every app editor session runs with them, so the agent knows the package format, records, queries, actions and tests.
Everywhere else: pick them from the + menu, set them as an agent’s skills, or read them with exponential_skills get.

Sessions start fast again

2026-11-03

Fresh sessions start in seconds, a login stuck behind a wall no longer holds a launch, and encrypted messages open as soon as the key holder starts.

Fast starts: a fresh session starts in seconds again instead of waiting on a 3-minute git stall.
Stuck logins: a login that needs you to act no longer holds up a launch, and a start that dies or hangs says so.
Encrypted messages: end-to-end encrypted messages open as soon as the device holding the key starts.

App buttons work on desktop

2026-11-03

Pressing an app’s action button no longer closes the desktop app, and apps get record rules per kind and a Data tab.

Desktop: pressing a button that runs an app’s action no longer crashes the desktop app.
Missing fields: an app reads a record’s missing field as empty instead of failing the whole view.
Record rules: an app can say per kind who may add, change or delete its records; the Data tab follows them on every app.
Run as: owners can preview an app in the editor as another member.

Reliability fixes

2026-11-03

The Linux app starts without PipeWire, Update tells you when there is nothing to install, and moving a session leaves its pull request alone.

Linux: the AppImage starts on a system without PipeWire; screen sharing and audio stay unavailable there.
Update: on a machine running the CLI, Update says why when it finds nothing to install (already newest, no build for that machine, a failed check).
Moving a session: moving a session to another device no longer pushes commits to its open pull request; the work follows it as before.
Merging: Merge no longer reports a pull request as queued forever when GitHub’s merge got stuck.
CI: sessions hear when their pull request’s checks finish, even when no one is looking at the pull request.

Team skills

2026-11-03

Owners keep a library of skills in Settings › Skills; pick them for a run in the + menu, or give an agent its own.

Settings › Skills: write a skill once (a name, when to use it and its instructions) and the whole team can run with it; owners edit, everyone reads.
+ menu › Skills: pick the skills a new session runs with; the ones set to Pre-select in new sessions start picked.
Agents: an agent’s page has a Skills row, so every run of that agent starts with them.

Exponential tools in groups

2026-11-03

Settings › MCP lists Exponential’s own tools in groups, and agents get one tool per kind of thing: labels, statuses, prompts, agents, MCP servers and repositories.

Grouped tools: Settings › MCP shows Exponential’s tools in bands: Work, Tracker, Team, Agents, Sessions, Apps and Activity. The filter searches every band.
One tool per kind: agents now use separate tools for labels, statuses, prompts, agents, MCP servers and repositories, so each one is easier to find. An agent can also read one agent’s setup.
Old sessions: transcripts from before the change still show these calls with their names.

Voice works on Windows

2026-11-03

Voice loads on every Windows machine again, Stop silences a spoken reply at once, and calls tell your voice from the speaker’s echo better.

Windows: voice loads on Windows again; it never started on any Windows machine before.
Stop: Stop silences a spoken reply right away, like talking over it.
Talking over a reply: the call learns how loud your speaker’s echo is, so you can interrupt sooner, and a quick answer right after a question is no longer dropped as echo.
Microphone: a microphone that never opens now shows an error instead of hanging.
Slow start: a slow voice warm-up is retried instead of switching to the CPU for good.

App actions save all or nothing

2026-11-02

An app’s button now saves every record it changes together or none of them, and the Android composer comes back after a shaky start.

All or nothing: when an app’s action writes several records, they save together; if one is refused, none of them land.
Missing values: an app shows its own fallback where a value is missing, instead of a blank.
App tests: an app’s own tests run when it is installed, so a broken app is caught before you use it.
Android composer: the Agent composer comes back on its own when the app started before the network was up.

Apps look the same everywhere

2026-11-02

App surfaces now draw their composer, charts, disabled fields, lists and pictures the same on web, desktop, iPhone and Android.

Composer: the send button looks the same on every app, dimmed while the draft is empty.
Charts: the top axis label no longer runs into the chart’s title on desktop, iPhone and Android.
Disabled fields: number, chip and upload fields dim as a whole, like on web.
Lists and bullets: side-by-side lists get their dividers, and Markdown bullets match on phones.
Pictures: a zoomable picture that hasn’t loaded shows a placeholder card instead of a broken image.
Desktop text: labels and titles no longer look heavier than on web.

Passkeys on your iPhone

2026-11-02

Add a passkey from the iOS app, and the Assistant wears its own mark in its chat on every phone.

Add passkey on iPhone: Settings, Account, Passkeys now has Add passkey on iOS too, like the web and Android.
Assistant mark: the Assistant’s chat header and call show the Exponential mark on iOS and Android, not a robot.

2026-11-02

Pick the model a new chat’s subagents run on from the + menu, and menu rows show their value on the right on every app.

Subagents: a new Claude chat’s + menu has Subagents again, the model its subagents run on.
Menu values: on the desktop app a menu row shows its current value muted on the right before the arrow (Device, Account, Model, Effort, Checks), like on web and phones.

Desktop confirms fit their content

2026-11-02

Desktop confirm dialogs and Add device are now as tall as what they show, like the web app.

No empty band: every desktop confirm, from Delete issue to Merge stack, sizes to its question and buttons instead of a fixed height.
Add device: the dialog fits both device cards and scrolls only when the window is too short.

2026-11-02

Claude sign-ins use the browser login again, and any Claude account can now persist its login for a year.

Browser login again: adding or signing in a Claude account uses the browser login, which shows every usage window and names the account.
Persist login: on a signed-in Claude account, Persist login keeps its runs signed in for a year, even if the browser login expires. Nothing to name or type.
What’s active: an account’s card says whether usage comes from the browser login or, once that expired, from the persisted login.
Still fixed: sign-ins from your phone get their link and code field, and an unfinished sign-in stops on the machine.

Keep signed in, fixed

2026-11-02

Keep signed in from your phone shows its link again, names the account you add, and never leaves a sign-in running.

Link and code: a Keep signed in started from another device gets its link and code field again, and a rejected code now says so instead of spinning.
Name it: when you add a Keep signed in account you can give it a name, so two of them are easy to tell apart.
Switch adds: switching an account to Keep signed in adds a new one and leaves the browser login as it was.
No leftovers: closing the sign-in stops it on the machine, and a sign-in nobody finishes stops by itself after 10 minutes.
Weekly usage: a Keep signed in account shows weekly usage only, which is all Claude reports for it.

Sessions keep track of their work

2026-11-02

A continued session keeps its plans and stories, pull requests find the session that pushed them, and encrypted chats refuse clearly.

Continued sessions: a session that continues an ended one keeps its plans, stories and pull request.
Pull requests: a pull request opened outside Exponential links to the session that pushed its branch.
Encrypted chats: a message that can’t be encrypted yet says what to do instead of asking you to update an app that is already current.

Live chats stay smooth

2026-11-02

Chats stay smooth while an agent works, and live sessions reconnect cleanly after the app was in the background.

Smooth on iOS: live updates no longer re-render the whole chat or the composer, and long transcripts load without freezing.
Back in seconds: the connection to your machines recovers within seconds instead of waiting.
Android in the background: live sessions pause cleanly when you leave the app and reconnect when you return, instead of failing while Android freezes it.
Desktop: a thread’s child sessions running on the same machine stream straight from it.

Owners can enter records for others

2026-11-02

A team owner can add or reassign an app record for another member, and the row says who entered it.

On behalf: in an app’s Data tab a team owner picks the record’s author; it counts as that member’s record.
Audit: a row someone entered for another member reads “Ana for Ben”, the same on the web, desktop, iOS and Android.
Agents and imports: an agent can write for a member (owners only), and an app file’s records keep their authors when they belong to the team.
Members still write only as themselves and get a clear refusal otherwise.

Records belong to their author

2026-11-02

Only a record’s author or a team owner can edit or delete it, on every device.

Yours: every app record remembers who it belongs to; only you or a team owner can edit or delete it.
Data tab: rows you can’t change show their menu greyed out, the same on the web, desktop, iOS and Android.
Mine: an app’s “mine” and per-member views count a record for its author, also when an owner entered it for them.
Agents too: an agent or another app editing someone else’s record gets the same clear refusal.

Animations in agent cards

2026-11-02

Agents can show small animations in their cards, the same on every device.

Motion: loaders, success checks and little illustrations an agent draws for you, playing inline in its card.
Same everywhere: one engine draws every frame, so the web, desktop, iOS and Android show the identical picture.
Your theme: animations use your theme’s colours and follow light and dark mode.
Calm: they pause off-screen and in the background, and stand still when you prefer reduced motion.

Sessions move to your other machine

2026-11-02

A queued session on an offline device moves to your other machine, and a start that never began says Couldn’t start.

Moves: a queued session whose device is offline moves to its starter’s other machine, and the device picker offers that machine.
Picks up its work: a moved session pushes its branch first, so the new device continues from its last commit.
Couldn’t start: a start that never began, or hit a leftover worktree, says Couldn’t start instead of sitting idle; leftover worktrees are cleaned up, Windows included.
Resumes: resuming several interrupted sessions at once no longer fails, and a failed resume shows as failed.
Private chats: a private session’s end report reaches the person who started it.
Just now: a moment ago reads “just now”, never “in 0 seconds”.

Usage for Keep signed in logins

2026-11-01

Keep signed in Claude logins show their 5-hour and weekly usage on their device.

Usage windows: a Keep signed in login shows its 5-hour and weekly usage like a browser login; Refresh reads it again.

CI checks on the Merge pill

2026-11-01

The thread’s Merge pill shows the PR’s CI: a spinner while checks run, Checks failing when one is red.

Merge pill: a spinner while checks run, Merge PR when they pass, Checks failing when one is red; merging on red asks first.
Checks: the thread’s … menu lists every check with its status, duration and a link to its logs.
Everywhere: on the web, desktop, iOS and Android.

Work never stays on one machine

2026-11-01

Your device pushes a session’s commits and its unsaved changes as it works, so a session moved or continued on another device picks up exactly where it left off.

Commits: a session’s branch is pushed within seconds of every commit, never force-pushed over the agent’s own history.
Unsaved changes: every few minutes, and whenever a session stops, moves or its device shuts down, the uncommitted work is saved to a hidden snapshot (secret files like .env and keys stay on the machine).
Continue anywhere: a session that moves to, or resumes on, another device gets its branch and its unsaved changes back.
Leftover branches: rare now; when one is needed, the session says so and you get an Inbox notification.

Zoom into pictures

2026-11-01

Every picture viewer zooms and pans, with a small zoom pill.

Zoom: pinch, ⌘/ctrl + scroll or double-click a picture to zoom in where you point; double-click again to fit.
Pan: drag a zoomed picture, or scroll it; tall screenshots open at full width from the top.
Zoom pill: − / + / fit and a menu of zoom levels float under the picture and hide while you look.
Everywhere: chat pictures, stories, the plan page and attachments, on the web, desktop, iOS and Android; iOS Results no longer open in Quick Look.

Claude stays signed in by default

2026-11-01

Signing Claude in now keeps it signed in for a year: open the link on any device and paste the code back.

Keep signed in by default: every new Claude sign-in uses a one-year login that can’t be signed out by a token refresh. It shows no usage windows, and we remind you a month before it needs renewing.
Switch in one tap: Claude logins from before show “Switch to Keep signed in” on their device.
Browser login: still there under “Use browser login (Advanced)” in the sign-in dialog.

Dismiss a question or plan

2026-11-01

Close a question or plan card you don’t want to answer; the thread header shows what’s still waiting.

Dismiss: every question and plan card has an ✕; the agent hears that you dismissed it and carries on.
Waiting: the thread header shows each question or plan still waiting; tap one to jump to it.

Wide tables scroll

2026-11-01

A table wider than its space scrolls sideways, and its cells wrap instead of cutting off.

Scroll sideways: an app’s table with more columns than fit keeps every column readable and scrolls horizontally.
Wrapping cells: long cell text wraps onto more lines; a column can still ask for one line with an ellipsis.

Long plans scroll smoothly on desktop

2026-11-01

A thread with a very long plan card scrolls without lag in the desktop app.

Smooth scrolling: the desktop app now lays out only the part of a long plan that is on screen, so scrolling past many sections, tables and pictures stays fluid.
Same look: plans look exactly as before.

A wider chat

2026-11-01

Chats are 100 px wider on desktop and web, and the reply box lines up with them.

More room: plans and previews in a chat get 100 px more width in the desktop app and on web.
One edge: the reply box is exactly as wide as the conversation above it.

The new-chat screen looks the same everywhere

2026-11-01

Starting a chat looks the same on web, desktop, iPhone and Android.

Issue chips: issues you attach wrap like on the web, long titles end in “…”, and the ✕ always shows.
The + menu: the same rows on every platform, and Computer use only appears for a device that supports it.
iPhone: the composer is as tall as on the web, and a tap anywhere in it opens the keyboard.

Chats look the same everywhere

2026-11-01

Message times, replaced plans, selection and story titles now match on every platform.

Message times: on iOS your message’s time now sits inside the bubble, like everywhere else.
Replaced plans: a plan a newer one replaced shows as the closed Plan ready card on every platform.
Selecting chats: on a phone browser, selecting chats shows the full-width bar the apps use.
Story titles: a story’s kind badge sits above its title, which wraps to two lines instead of cutting off.

Devices as cards

2026-11-01

The Devices page is a grid of cards, with each account as an icon you can hover or tap.

Cards: every device is a card with its name, version and status, and a ⋯ menu for its update and settings.
Accounts: logins show as Claude or Codex icons; an amber dot marks one that is signed out or at its limit, and hovering or tapping it shows the email, plan, usage limits and Sign in.

Settings and lists tidied up on every platform

2026-11-01

My issues loads reliably on the web, and a few labels now read the same everywhere.

My issues: on the web, the list shows loading rows while it syncs instead of a brief “No issues”.
Settings: the leftover “When a PR merges, end its sessions” switch and the page subtitle are gone.
Same words everywhere: the back button and image viewer say Stories, the phones’ Account screen is titled Account, and iOS shows PR numbers without a thousands separator.

Desktop looks like the web app

2026-11-01

Desktop dialogs open inside the window over a dimmed backdrop, and Settings matches the web page.

Dialogs in the window: Add device, Device settings, Join a team, Getting started, export, search and every confirm open over a dimmed backdrop; a click outside or Escape closes them.
Settings: the pages use the web app’s type size, row style and switches.

Agents get the issue you hand them

2026-11-01

Start coding with an agent picked now gives it the issue’s title and description.

The whole issue: an issue you send to an agent, or forward into a running session, reaches it with its identifier, title and description, in encrypted chats too.
No prompt needed: sending just the issue wakes the agent.

Agents encrypt their messages from the start

2026-11-01

Agents started while a device was still coming online now encrypt their messages and card answers.

No more refusals: an agent started while its device was still coming online no longer gets “This chat is end-to-end encrypted” when it messages or answers a card.

Signed-out logins reach your inbox

2026-11-01

When one of your devices loses an agent login, you get one notification that opens that device’s settings.

Once per login: one inbox row and push when a login signs out; the next only after it was signed in again.
Straight to the fix: tapping it opens the device’s settings to sign in again.

Comments keep what you type while they send

2026-11-01

Text typed or files added while a comment is sending stay in the composer.

Keep typing: the comment field stays editable while a comment sends, and only what went out clears.
Leave anytime: on Android, backing out of an issue no longer cancels a comment that is still sending.

A child’s tasks in the thread

2026-11-01

The Dock of a thread shows the tasks of a running child session when the root has none.

Tasks card: when the root session has no open tasks, the thread’s Dock shows the tasks of the most recently active running child, named in the card.
Sheet: opening the card shows that child’s full task list.

Chats stay smooth and keep what you type

2026-11-01

Typing, sending and reopening a chat are faster and never lose your text.

Typing: on Android, letters no longer drop or swap, and typing and scrolling stay smooth while the agent works.
Sending: text you type while a message is sending is no longer lost, and leaving the screen no longer cancels a send or an upload. Sending and going straight back no longer freezes Android.
Reopening a chat: its task and queue cards show right away instead of after the live view connects.

2026-11-01

A Claude account can hold a one-year login that no other sign-in can sign out.

Keep signed in: the menu of a Claude account under a device starts a long-lived login; open the link and paste the code like any sign-in.
Renew: an account that already has one offers Renew long-lived login.
Trade-off: a long-lived login shows no usage of its own; the account keeps the email it last signed in with.

Agent logins stay signed in

2026-11-01

A thread moves to another signed-in account when its login signs out, and Import is gone.

No more copied logins: Import is removed; every account signs in on its own device, so one copy can no longer sign another out.
Automatic switch: a new or running thread whose login is signed out continues on another healthy account on that device.
Honest health: a login whose refresh failed shows Needs re-login right away instead of OK.

Steadier live sessions

2026-11-01

A live session keeps streaming when the direct connection to its device stalls or drops.

Direct first: your app still connects straight to the device running the session.
Encrypted fallback: when that connection stalls or drops, the session keeps streaming through our server, end-to-end encrypted, and moves back once the direct connection returns.

October 2026

Preview apps as a phone

2026-10-31

The app editor’s preview switches between Desktop and Phone and between an app’s templates.

Desktop or Phone: see the preview at full width or at a phone’s width.
Templates: an app with more than one template gets a picker next to the switch.

App data in the editor

2026-10-31

The app editor’s Data tab lists an app’s records and lets you add, edit and delete them.

Data tab: pick a kind of record to see them as a table with who changed each one and when.
Add and edit: a form built from the app’s own fields; mistakes are shown right under the form.
Phones: Data sits next to Chat and Preview.

App editor tabs

2026-10-31

The app editor gets Preview, Versions and Settings tabs beside the chat.

Tabs: the chat stays on the left; the right side switches between Preview, Versions and Settings.
Versions: every older version has Preview and Restore buttons.
Settings: name, description, records and tool grants now live in the editor. On phones they are in the … menu, grants included.
One layout: the floating chat is gone; the chat is always docked.

Your apps, as MCP tools

2026-10-31

Claude, ChatGPT or any MCP client can use your team’s apps through their tools, with the access you pick.

App tools: an app can offer tools, like listing its records or adding one. Connect an MCP client to /api/mcp/apps and your agent calls them as you, with no device online.
Consent: when a client connects, pick the team, all apps or just some, and Read only or Full. Apps that call another service ask you to connect it there.
Access: an app’s settings list its MCP tools and the accounts it uses. Owners can switch a tool off.
Revoked when it should be: leaving a team removes your app access there, a trashed app’s tools disappear, and disconnecting a service also revokes its token at the provider.

Plans get their own page

2026-10-31

A plan opens full screen with an outline and its pictures, and stories show one card per plan or result.

Plan page: open a plan from its card, a story or the inbox to read it full screen, with an outline to jump between sections, its pictures in a grid or carousel, and the questions beside it.
Calmer stories: every story is one card: a plan shows its cover and an “Open plan” button, a result shows its pictures as a carousel. Each card has a Plan, Question or Result badge.
Ring order: stories waiting for you come first, then the rest, newest first. A session’s newer result replaces its older ones.

New app opens the editor

2026-10-31

New app starts a draft and opens the editor; the agent names it.

New app: no form any more. New app opens an untitled draft in the editor with the chat ready and a few starting ideas; the agent picks the name, icon and colour.
Drafts: an app without a version shows a Draft badge. Leaving a draft you never wrote anything in removes it.
Import: importing an app file is its own button on the Apps list.

Updates install within minutes

2026-10-31

The CLI daemon and the desktop app update within 10 minutes, whatever runs, and the sessions they cut continue on the new version.

Updates land: a queued update no longer waits for sessions to close or sit idle for 2 hours. The CLI daemon restarts at the next pause between turns, at most 10 minutes later, and at once when the server requires a newer version.
Sessions continue: a session cut mid-turn by the restart picks up where it left off on the new version by itself, team agents included. Nothing waits for you to resume it.
Desktop: the desktop app downloads updates in the background and restarts by the same rule while you are not using it. A required update restarts it at once.
On by default: the CLI looks for a new version every 15 minutes, and auto-update is on unless you turn it off with exponential update --auto off.
Fixed: after a self-update, sessions the old app still held are picked up again instead of being left interrupted.

The live view stops flickering

2026-10-31

Watching an agent on another machine no longer flashes “Connection lost”, and idle chats no longer say they are starting.

Fixed: a team agent conversation running on another machine flickered “Connection lost” on desktop. A short drop now reconnects quietly on every app; “Connection lost” shows only after 5 seconds and two failed retries.
Fixed: an idle chat waiting for your answer said “The agent is starting” forever when its device had no transcript to send. It now says “No live transcript”.
Fixed: restarting the desktop app or the CLI daemon no longer deletes the transcript of an idle chat on that machine.

Answering plans works again on desktop

2026-10-31

The desktop app answers plan and question cards again.

Fixed: desktop 0.14.87 and 0.14.88 couldn’t approve, reject or answer a plan or question card; the card showed “Couldn’t answer the question” and opened again. Desktop 0.14.89 fixes it.
Fixed: images pasted into a chat reach the agent again.
Self-hosting: this release removes server support for desktop below 0.14.89. Set CLIENT_MIN_VERSION_DESKTOP to 0.14.89 before upgrading (see selfhost/.env.example).

Watching sessions connects on iOS and Android

2026-10-31

The iOS and Android apps now find the device that runs a session, so watching it live works.

Connects: the iOS and Android apps learn each teammate device’s relay address, so watching a session no longer fails with “No addressing information available”.
Self-hosting: this release removes server support for iOS below 0.14.78 and Android below 0.14.80. Set CLIENT_MIN_VERSION_* to those versions before upgrading (see selfhost/.env.example).

Watching sessions works again on every app

2026-10-31

This release ships the apps that watch sessions straight from your device; older apps must update.

Update required: watching a session now needs this release of the iOS, Android and desktop apps and the CLI. Older builds show “Couldn’t get a viewer ticket” and are asked to update.
Self-hosting: this release removes server support for iOS below 0.14.77, Android below 0.14.79, desktop below 0.14.88 and the CLI below 0.14.88. Set CLIENT_MIN_VERSION_* to those versions before upgrading (see selfhost/.env.example).

2026-10-31

The sidebar’s dots and Drafts count now look the same on web and desktop.

Same dots: the sidebar’s status dots are one size on web and desktop, and an agent that needs you shows the same yellow on both.
Drafts count: the Drafts count is the small count badge on web too.

2026-10-30

Every dot, count and + in the sidebar now sits in one column.

One column: an agent’s dot, the Chats and Inbox dots, the Drafts count, an Active row’s device and the sections’ + buttons now line up at the sidebar’s right edge, on web and desktop.

The offline copy, everywhere

2026-10-30

A finished session whose device is offline now says so the same way on every app.

Same words everywhere: a finished session whose device is offline now names that device and says the transcript lives there, on web and desktop as on iOS and Android, instead of an empty view.

Worktrees and short session ids, fixed

2026-10-30

A second install on the same machine no longer cleans up your worktrees, and the CLI accepts short session ids again.

Your worktrees stay yours: the nightly cleanup only touches worktrees its own install started. A second daemon or app with its own data folder or account no longer removes another install’s worktrees.
Short session ids: exponential sessions show, log and message accept an 8-character id prefix again, and exponential sessions --agents lists your agent conversations again.

Offline sessions reconnect on their own

2026-10-30

A session whose device was offline opens its transcript by itself once that device is back.

Reconnects by itself: when a session says its device is offline, the app keeps checking. Once the device is back online the transcript appears without reopening the session, on web, desktop, iOS and Android.

The CLI follows sessions while its daemon runs

2026-10-30

exponential sessions log --follow now streams a session from another machine even while this machine’s daemon is running.

Follow from anywhere: on a machine whose daemon is running, the CLI now asks the daemon to connect to the session’s device and streams the session’s activity through it. Before, it refused and asked you to stop the daemon.
Update the daemon: an older daemon can’t do this; exponential update brings it up to date.

Sessions stream straight from your device

2026-10-30

Watching and steering a session now goes directly between your app and the device that runs it; the steer relay no longer carries session content.

Device to device: a session’s activity, your messages, answers and Stop travel over eNet between your app and the machine running the session, on web, desktop, iOS and Android. The steer relay only keeps device presence, the server’s kill, Stop and compact commands, and voice calls.
Earlier sessions: an idle or ended session’s transcript comes straight from the device that ran it. When that device is offline the session says so.
Self-hosting: the server no longer supports the apps of the 2026-10-30 release (iOS 0.14.76, Android 0.14.78, desktop and CLI 0.14.87) for watching sessions; the next release sets the floors.

End-to-end encrypted session content

2026-10-30

Messages, cards and titles in your sessions are end-to-end encrypted on your devices, so the server stores them without being able to read them.

Encrypted on your devices: what you, your agents and your Assistant write in a session (messages, cards, answers and titles) is encrypted with that session’s key before it leaves the device, on web, desktop, iOS and Android. The server stores and syncs it but can’t read it.
Keys arrive by themselves: a new browser, phone or teammate on a shared session gets the key from one of your devices that’s online, with no approval step. Until then the row shows “Waiting for the key” and opens on its own.
Agents talk device to device: a message from one agent to another goes straight to the target device over eNet; the server keeps only an encrypted copy. Watching a running session from your phone or browser also connects straight to the device running it.
Update required: older apps can’t open encrypted content, so this release raises the minimum version on every platform.
Also: calls keep working when you switch between speaker, headphones and Bluetooth on your phone, and web apps load their records only when you open them.

Questions push to your phone

2026-10-30

When a chat you started asks you a question or proposes a plan, your phone gets a push, with the question itself even in encrypted chats.

Every chat you start: a question or plan from one of your chats now sends you a push, not only your Assistant. Teammates are not pinged; they still see that it needs input.
The question, kept private: in an encrypted chat the push carries the question encrypted, and your phone opens it with the chat’s key to show it. Without the key you see “New message in a session”.

Session rows open from a chat

2026-10-30

Tap a session’s row in a chat to open it, or answer its question right there.

Conversations: tap a session’s row to open it. A row that needs you opens its question or plan right there, so you can answer in place.
Every line goes somewhere: “Report from”, “was not picked up” and the other session lines open that session; only rows that do something show a chevron.

Stories, tidied

2026-10-30

The chats header shows only the last day’s stories, the viewer fits each picture, a chat’s Stories tab shows its stories in place, and lists show top-level chats only.

Last 24 hours: the story row above your chats holds stories from the last day only, and an agent or chat without one is not shown. Nothing new means no row.
Fits the picture: on desktop and wide web the story viewer takes the picture’s shape, landscape or portrait, within the window. Phones stay full screen.
Stories in place: a chat’s Stories tab shows each story with its description, pictures, preview or plan right there, and keeps every story.
Top-level chats only: the chat lists and the sidebar’s Active section list each chat once; sub-sessions roll up into their chat.

Agent questions open from the inbox

2026-10-30

Tapping an inbox item where your Assistant or an agent needs a decision opens the chat it is waiting in.

Decisions open from the inbox: an inbox item like “Your Assistant needs a decision” now opens your Assistant with the question waiting in its chat, on web, desktop, iOS and Android; mentions in a chat open that chat too, and so does the push.

Start coding keeps your issue

2026-10-30

Picking an agent in the Start coding composer no longer drops the issue, and the dialog has the same agent row as the Agent page.

Your issue stays attached: switching the agent, device, account, model or effort in the Start coding composer keeps the issue you started from, and a picked agent gets the issue with your message.
One composer: the Start coding dialog on web and desktop is the Agent page’s composer, with the agent row above the text field.

Calls say what’s missing

2026-10-30

A greyed-out call button now names the real cause and where to fix it, and the Assistant only runs on devices that can speak.

Calls say what’s missing: when the call button is off, its reason names the real cause and where to fix it: set up your Assistant, run it on a desktop in Settings → Assistant, or restart Exponential on a device whose voice failed to load. It no longer reads “getting its voice ready” forever.
Assistant devices: the Assistant’s Runs on picker lists only your desktops, because servers and CLI daemons can’t speak.
Desktop transcripts scroll again: scrolling up in a running session stays put; only a new row brings you back to the bottom.
Cleaner agent cards: a card an agent updates is edited in place and moves to the bottom of the chat, and cards no longer draw a card inside a card.

Stories step through every picture, and a steadier desktop

2026-10-30

Stories play picture by picture, the composer lists your prompts, pushes open on your phone and the desktop no longer crashes during computer use.

Stories, frame by frame: every picture or card in a story is its own step with its own progress bar; on phones stories fill the screen, and on desktop the side arrows step instead of closing.
One thread strip: a session’s strip shows the conversation, its issue or one session tree button with a count, then Stories.
Prompts in the composer: the composer’s + menu lists your team’s prompts, and the account rows show your usage again.
Notifications on your phone: iOS and Android open encrypted pushes on the device and show the full message.
Desktop crash fixed: the desktop app no longer crashes when an agent using computer use switches to the Exponential window.
Devices per team: the device pickers only offer machines this team may use.
Assistant settings: the Assistant page has no Instructions field any more on web, desktop, iOS and Android.
Library names: Exponential’s open libraries are now called eUI, eTalk, ePilot and eNet.

A quiet Assistant with one live status card

2026-10-30

Your Assistant keeps one status card up to date and only writes when you do or a decision needs you.

One status card: your Assistant keeps a single card with your chats, pull requests, what shipped and what needs you, and updates it in place until you write again.
No more noise: check-ins, opened pull requests and running chats no longer post messages; a check-in with nothing new is skipped.
Decisions reach you: when your Assistant needs a decision it asks with clear options and sends you a push.
Built-in prompt: the Assistant runs on Exponential’s own prompt, so its Instructions field is gone; your old instructions were posted once into its chat.
Teams stay apart: a device shared only with another team no longer runs this team’s chats or agents, and agents never see another team’s devices.

Chat cards look the same everywhere

2026-10-30

Agent replies and cards share one look on every app, and a few rough edges are gone.

One card look: agent replies and the cards a session shows you wear the same surface, corners and padding on web, desktop, iOS and Android.
Card titles: a card’s title sits above it in the chat, now on Android too.
Deleting chats on Android: deleting several chats at once always tells you how it went.
New widget: the New widget dialog picks a board as soon as your boards have loaded.

A Stories tab in every session

2026-10-29

Every story a session showed you stays in its Stories tab, next to its pull request.

Stories tab: a session’s last tab collects every question, plan and result it showed you, with screenshots, on web, desktop, iOS and Android; a dot marks a new one.
Outcomes at a glance: each story says whether you approved it, asked for changes, answered it or a newer one replaced it.
Next to the pull request: the pull request’s Changes and Stack sit on top of its stories, and a tap opens the story or picture full size.

No more Allow or Deny cards in your voice agent’s chat

2026-10-29

Your voice agent runs like every other session: nothing waits on a permission card.

Permissions bypassed everywhere: the chat with the agent picked in Settings → Voice no longer stops at an Allow or Deny card before each tool call; it runs with permissions bypassed like every other session, on web, desktop, iOS and Android.
Spoken answers: “yes”, “take two” and “reject one” are ordinary messages again, since no card waits on them.
Any agent for voice: a Codex agent can be your voice agent again.

Private Assistants, safer meetings, steadier agent chats

2026-10-29

Your Assistant and screen memory stay yours, meetings never lose a line, and agent replies keep every answer.

Your Assistant is yours: teammates no longer see, pick or assign your Assistant, and a team agent your teammates use stays a team agent with its schedules.
Screen memory stays private: only your own Assistant on your own, unshared machine can look at your screen, and the buffer on disk is readable by you alone.
Meetings: turning Meeting mode off on the desktop works again, a machine shared with any team never holds a meeting, and no transcript line is lost or sent twice when the connection drops or you quit.
Every answer kept: a message you send while the agent works no longer lets its next reply overwrite the previous answer, and story screenshots stay when a card updates.
Calls: when your voice device can’t get ready, web, iOS and Android all tell you so, and push to talk keeps working after you rebind its key.
Move to any machine: a session moves to any of your online machines; old builds update through the normal version check.
Chats on iPhone: the Agents and Chats headers match the other apps.

Agent stories, quieter agents, linked chats, calls like a phone call

2026-10-28

What agents show you lands as stories you swipe through, chats link to each other, and calls ring and look like a phone call.

Stories: drafts, questions, plans and results with screenshots land as stories on top of Chats, one ring per agent and chat. Swipe through them and answer right there; what waits on you comes first.
No more Guide tab: a pull request’s description is a short summary plus the story screenshots of each platform.
Agent chats ready on the web: your agent chats and recent chats sync in the background, so they open instantly.
One card, kept up to date: agents show results, questions and plans as a card that updates in place, and in an agent chat a newer reply replaces the earlier one until you write again.
Fewer wake-ups: an agent hears from the chats it started only when they ask, hit a limit, open a PR or finish, and its scheduled check-ins fold into one card that is skipped when nothing changed.
Linked chats: a message from another chat says where it came from (Message from, Report from, Started by); tap it to jump there and back.
No plan mode: plans are cards you answer; nothing waits on a switch.
It rings first: a call rings for 3 seconds while your voice device loads speech and the voice, then answers with Hello?; a voice that is still downloading keeps ringing until it is ready.
A real call screen: the agent’s avatar, its name, the call’s timer and what is being said, with round mute, speaker and red end buttons on web, iOS, Android and the desktop.
Floating pill: while the desktop app is minimized a small call pill stays on top; drag it anywhere, it remembers where you put it, and Esc or the tray’s End call ends the call.
Replies are always spoken: Speak replies is gone; whatever you say by voice is answered by voice, typed messages never are.
Your own push-to-talk key: press any key or combination in your Assistant’s Voice settings to bind it, like in a game; Backspace clears it.
Wake word: it now hears its phrase anywhere in what you say, and your Assistant’s Voice settings tell you why it isn’t listening.
Idle chats free your machine: a chat left alone for 30 minutes gives its agent process back and picks up where it left off with your next message; its worktree goes once all its pull requests are merged and nothing is left uncommitted.

Meeting mode

2026-10-28

Your voice agent follows a meeting you start, with everyone’s consent.

Meeting mode: start it in Settings → Voice or the tray; after you confirm that everyone agrees, your voice device transcribes you and the apps you pick (Zoom, Slack…) on separate channels and hands the transcript to your voice agent in short batches.
Nothing kept longer than needed: audio is never stored, the transcript is deleted from the server after 7 days and from your device after 30.
Pause listening: Ctrl + Alt + P pauses the meeting and screen memory at once.
Never forgotten on: a meeting stops by itself after 4 hours and tells you so, and while it listens the tray icon carries the microphone dot.

Screen memory

2026-10-28

Your voice agent can look at the last 10 minutes of your screen.

Screen memory: on your voice device, the tray’s Screen memory switch keeps the last 10 minutes of your screen (deduplicated, on this device only). Your voice agent can look at up to 4 screenshots from a moment you talk about.
Paused for private windows: password managers, private browser windows and online banking are never captured; the tray says Paused while one is focused.
Private windows stay private: a password manager or banking window behind other windows is blacked out too, and on desktops without a window list (Wayland) the switch doesn’t show.

Work screen

2026-10-28

Pick the display agents drive with computer use, and fullscreen apps stay yours.

Work screen: Device settings → Computer use has a Work screen row: Auto (every display without a fullscreen app) or one display. Agents only see and drive that display.
Fullscreen stays yours: while you are in a fullscreen app (a game, a video) on another display, agents don’t click or type; the voice overlay never opens over a fullscreen app.
Follows its monitor: the picked work screen is remembered by the monitor itself, so plugging in or reordering displays never moves agents to another screen.

Sessions that never stall, and a disk check on every device

2026-10-28

A new thread always starts its first turn, a killed or restarted run says so and resumes, the model picker works on a session that hit its limit, and devices clean up old worktrees and warn when the disk runs low.

First turns: a new thread whose first turn failed or never ran starts again by itself instead of waiting for a nudge.
Interrupted runs: a run killed by its machine (out of memory, a crash, a restart) reads interrupted and resumes; on Linux each run gets its own memory scope, so one heavy run no longer takes the others down.
Model limits: picking a model on a session that hit its limit switches it at once.
Automerge: a thread can no longer stay locked, a change arriving mid-merge is picked up, and draft PRs follow GitHub.
Disk: devices remove build output from finished worktrees, list the worktrees they kept and why, and warn when less than 10 GB is free.
Live view: a reconnecting run is never replaced by its replay, and a session without a transcript answers at once instead of spinning.

Release 2026-10-27: call your agent (beta), with the train’s fixes

2026-10-27

This release adds voice calls to your agent from the phone, the web and the IDE, the wake word and voice proposal cards, all in beta. Interrupted sessions now resume by themselves, queued sessions wait for their device, and chats can be selected and archived.

Calls (beta): call your voice device’s agent from iPhone, Android, the web or the IDE; a call on the desktop’s own speakers no longer interrupts the agent’s voice.
Wake word (beta): say the wake phrase on your voice device instead of holding push to talk; a red dot shows while the microphone listens, Mute is remembered, and a sidebar voice button stands in where no tray shows.
Spoken replies (beta): German now starts speaking as fast as English.
Proposal cards (beta): a voice agent proposes changes on a card and only acts after your yes.
Sessions: interruptions resume by themselves, queued sessions wait for their device, an idle session’s transcript opens on every device, and plan and question cards reach the team agent’s conversation and show inline on Android.
Merges: a refused merge lands in the thread with Retry, and automerge also runs when a turn or session ends or a PR opens.
Chats and Devices: select chats to mark read, archive (just for you), stop or delete them; every check is the square checkbox; Devices shows one line per machine, and team owners can remove a shared machine.
Privacy: a private chat’s text never shows up in a conversation that may not see it.
Store builds: the IDE and CLI 0.14.80 (an older 0.14.79 daemon cannot resume interrupted runs, please update), Android 0.14.72; iOS 0.14.70 is in TestFlight.

Devices: one line per machine, warnings behind one icon

2026-10-27

The Devices page lists each machine on one line with its logins beside it. Limits show when you hover a login, and anything that needs a fix sits behind one warning icon.

One line: each device shows its name, version and status, then one chip per login. Nothing folds any more.
Limits on hover: hover a login to see its 5h, week and model limits. Click or tap it for Sign in, Sign out and Remove account, with the same limits on top.
One warning icon: a login that needs signing in again, a signed-out login or an available update show behind a single icon, each with its own button.
No false “Signed out”: a coding agent you installed but never signed in to no longer marks the device as signed out. A device without any login says No account.
Offline last: offline devices sit under an Offline label at the end, dimmed.

2026-10-27

On a Linux desktop that shows no tray icons, such as GNOME without AppIndicator, the sidebar gets a microphone button while the wake word is on. It shows a red dot while the microphone listens and opens the tray’s menu, including Mute.

Where: next to the Computer button at the bottom of the sidebar, only on your voice device, only with the wake word on, and only while nothing shows the tray icon.
What it says: hover it for the phrase it listens for, or Microphone muted. The red dot is the same one the tray icon shows.
Its menu: Speak replies, Push to talk, Wake word, Mute microphone and Voice settings…, working exactly as in the tray.

Select chats, mark them read and archive them

2026-10-27

Select several chats at once to mark them read or unread, archive, stop or delete them, and keep your Chats list tidy with an Archived page of your own.

Select: on a phone, long-press a chat, or an issue, to select it straight away. Nothing moves aside: a selected chat gets a highlight and a check on its icon. On a computer tick the checkbox that shows when you hover a chat, or pick Select from its right-click menu; cmd or ctrl click adds a chat, shift click adds a range, cmd or ctrl A selects them all. Tapping a chat while selecting toggles it.
The bar: the same bar as the issue list’s selection: Mark read or Mark unread, Archive, Stop while a chat runs and Delete when you may delete every selected chat.
Archived: archiving is yours alone, your teammates keep their list. Archived chats move to the Archived row at the top of Chats, and a chat that needs you comes back on its own.
The Chats dot: an archived chat no longer lights it.

Wake word: a pause after each turn, Listening in Settings, Mute remembered

2026-10-27

After a wake turn the wake word waits a moment before it listens again, so the end of your sentence can’t start a second turn. Settings → Voice shows Listening next to Wake word on your voice device, and Mute microphone stays on after a restart.

A short pause: for a second and a half after a wake turn ends, the wake word ignores what it hears, so a trailing phrase or an echo doesn’t open another turn.
Listening in Settings: on your voice device, the Wake word row in Settings → Voice reads Listening while the microphone listens for your phrase, or Microphone muted. This helps where no tray icon shows, such as GNOME without AppIndicator.
Mute remembered: Mute microphone in the tray stays on after you restart the app on that computer.
Tray: on Linux the app notices right away when the panel showing its tray icon goes away.

A refused merge goes to the thread

2026-10-27

When a merge is refused, the thread’s session gets GitHub’s reason and takes it from there, so the Fix conflicts run is gone.

Into the thread: a refused merge (checks, conflicts, anything else) appears as Merge of PR #N refused in the thread and wakes its session with the reason and what to do; the error says Sent to the thread.
Retry everywhere: every refused merge offers Retry, and the error names what failed: Couldn’t merge the PR or Couldn’t merge the stack.
Fix conflicts is gone on web, the IDE, iPhone and Android: the session rebases and resolves conflicts itself.

Wake word on your voice device

2026-10-27

Turn on Wake word in the tray or in Settings → Voice and say your phrase (Hey and your agent’s name, unless you set your own) to talk without a shortcut. The tray icon shows a dot while the microphone listens; Mute turns it off.

Wake word: on the desktop you picked as your voice device, say the phrase from Settings → Voice (Hey and your agent’s name when you leave it empty) and what follows; the capsule opens like push to talk and the message goes to your agent when you stop talking. It runs on the speech recognition push to talk already uses, so there is no extra download.
Tray: the icon carries a dot while the microphone listens for the wake word, and Mute microphone turns it off too.
Tray fixes: a double-click on the Windows tray icon opens one window, and on Linux the tray watches for a panel only while this computer is your voice device.

Voice: your agent asks before it changes things

2026-10-27

In your voice conversation the agent now proposes every change as a card in the Dock instead of making it. Reads run at once; you answer a card by tapping it or by voice (“take two”, “reject one”, “accept all”, “two, but priority high”), and deletes, merges and messages to others are read back and need a spoken yes.

Proposal cards: when you talk to your voice agent, creating or updating an issue, commenting, adding a label or a relation, or starting a subagent shows a card with what would change and what you said. Allow runs it, Deny (or “no”) drops it, and a typed or spoken change (“yes, but priority high”) is applied in one go, for that same change only. A card waits 15 minutes; a newer card for the same issue replaces the older one.
Say yes for the big ones: deleting, merging or closing a pull request, messaging another session, running a command or editing a file is read aloud and needs an explicit yes. Team settings, people, device sign-ins and scripts are never run from a voice conversation, and only you can answer its cards.
Answer by voice: with push to talk, “take two”, “reject one”, “accept all”, “yes” or “no” answer the waiting cards instead of being sent as a message.
Only your voice agent: every other session, thread and agent conversation works exactly as before.
Update the voice device: the cards need desktop app 0.14.80 or later; an older desktop keeps running your voice conversation without asking.

Call your agent from your phone (beta)

2026-10-27

The telephone in an agent’s chat now calls from the iPhone and Android apps too: the call streams to your voice device, which listens, sends what you say and speaks every reply.

Calls from your phone: tap the telephone in an agent chat’s header. The call fills the screen with Mute and End call, and runs on your voice device, so it needs that device online.
Talk over it: speaking while a reply plays stops the voice and listens again; your phone’s echo cancelling keeps the reply out of the microphone.
When it can’t call: the telephone stays visible but dimmed; long-press it to see why (no voice device, Speak replies off, the device offline, its voice still getting ready, or no usable GPU).
Lock the screen: a call keeps running with the screen locked or another app in front; only End call ends it. A phone call coming in drops it.
Microphone: the apps ask for the microphone on your first call. On Android a notification shows while a call runs.

Call your agent from the browser (beta)

2026-10-27

The telephone in an agent’s chat on web calls it through your voice device: talk hands-free in the browser, every reply is spoken, and talking over a reply stops it.

Calls on web: the telephone in an agent chat’s header opens a call card over the chat. Your microphone streams to your voice device, which listens and speaks the replies back into the browser.
Mute and End call: the card shows what was heard, what is queued and what is said, with End call and Mute.
When it can’t call: the telephone stays visible but dimmed, and its tooltip says why (no voice device, Speak replies off, the device offline, its voice still getting ready, or no usable GPU).

Call your agent from the IDE (beta)

2026-10-27

On your voice device, the telephone in an agent’s chat starts a call: talk hands-free, every reply is spoken, and talking over a reply stops it. Calling from your phone and the browser comes next.

Calls: the telephone in an agent chat’s header, or Call in the tray, opens a call on your voice device. The microphone stays open until End call, each thing you say goes to the agent as a message, and every reply is read aloud.
Talk over it: speaking while a reply plays stops the voice and listens again. What you say while the agent is still working waits in the chat’s queue, like a typed message.
Mute: the call’s bar has Mute and End call.
When it can’t call: the telephone stays visible but dimmed, and its tooltip says why (no voice device, Speak replies off, or no usable GPU to speak with).
Devices: the voice device’s readiness now has a Speech row that says whether it can speak.

Team owners can remove a shared machine

2026-10-27

A team owner can now remove a teammate’s shared machine from the team, and when two accounts claim the same machine, the account that registered it first wins.

Remove from this team: on Devices, a team owner sees Remove on a teammate’s shared machine. It stops sharing that machine with the team, and sessions teammates started on it end.
Who holds it: if a machine is already shared with the team from another account, a team owner sees whose account shares it.
First registration wins: a machine shared from an account that registered it later is replaced when the account that registered it first shares it.
One account per machine and team: two accounts signed in on one machine can each share it, but only into different teams.

Release 2026-10-26: Talk to your agents (beta), with the train’s fixes

2026-10-26

This release ships voice to the IDE as a beta: push to talk and spoken replies in English and German, set up in Settings → Voice on every device. Calling your agent from the phone and the wake word are coming. The release review also fixed how Settings → Voice saves, and push to talk now stops listening when the IDE window loses focus.

Talk (beta): on the desktop you pick as your voice device, hold the push to talk shortcut, speak and let go; with Speak replies on, the answer is read aloud in English or German. Calling your agent from the phone and the wake word are coming.
Settings → Voice: on web, the IDE, iPhone and Android, quick changes no longer undo each other, a failed save only resets the field it was about, and typed text is kept when you leave the page.
Push to talk: when the shortcut only works inside an Exponential window, switching away now ends the hold instead of listening on.
Speak replies: a failed first download is retried on its own, and Linux finds the audio player on more setups.
Sessions: a long turn no longer shows needs input by mistake, and a machine shared into a team is listed under the right host.
Store builds: Android 0.14.71 and the IDE 0.14.79 are live; iOS 0.14.69 is in TestFlight.

Mention pills in chats, and fixes

2026-10-26

People and agents you mention in a chat show as pills on every platform; the computer-use banner shows its whole label, and the voice switches stay off after their agent is deleted.

Mention pills: an @mention in a chat message shows as a pill with the person’s or agent’s name on web, the IDE, iPhone and Android.
Computer-use banner: the banner window is exactly the size of its bar, so a long label is no longer cut off.
Voice: if your voice agent is deleted, Speak replies, Push to talk and Wake word stay off until you pick another agent; a wake phrase with control characters is refused.

Push to talk on your voice device

2026-10-26

Hold a shortcut anywhere on your voice device, speak, and let go: what you said goes to your agent as a plain message, and a small overlay shows it listening, thinking and speaking the reply.

Hold to talk: on the desktop picked as your voice device, with Push to talk on, hold the shortcut from Settings → Voice (Ctrl + Space by default) in any app, speak, and release. The words land in your chat with the voice agent; with Speak replies on, the answer is read aloud.
The overlay: a capsule at the bottom of the screen under your pointer shows Listening, Heard, Thinking and Speaking, with Stop while a reply is read. Talking over a reply stops it.
Mute: the tray gains Mute microphone; while it is on, the shortcut shows Microphone muted and the microphone never opens.
Never silent: if the shortcut can’t be held system-wide (another app has it, or the desktop has no global shortcuts), the tray item says it is unavailable, Settings → Voice says why, and it still works while an Exponential window is focused. On Wayland, KDE, GNOME 48+ and Hyprland ask you to confirm the shortcut once.
Mouse buttons: Mouse button 4 and 5 work on Linux with X11 and on Windows; macOS and Wayland don’t offer them.
Not sent: if a message can’t be sent, the overlay says so and the words wait in the agent’s chat composer.
Windows: speech recognition needs the Microsoft Visual C++ runtime; the voice device’s Microphone row offers to install it when it is missing.
First use downloads the speech recognition model (about 670 MB).

Speak replies in German and in your own voice

2026-10-26

The IDE now speaks replies in English or German with one voice that runs on your GPU, cloned from your own clip or a built-in voice; without a usable GPU, replies are shown, not spoken.

German and English: the IDE reads your agent’s replies aloud in the language you pick in Settings → Voice, with one voice for both.
Your own voice: with a Voice file and its transcript set, the voice is cloned from that clip on your voice device; without one it uses a built-in voice. The file must be a local .wav of at most 10 MB, and nothing is uploaded.
Needs a GPU: the voice runs on your desktop’s GPU (NVIDIA on Linux, Apple Silicon on macOS, a Vulkan GPU on Windows). Without a usable GPU, replies in either language are shown, not spoken; this also ends English speaking on a desktop without one, and Settings → Voice says so next to each language.
One download on first use: about 3.0 GB on Linux, 2.2 GB on macOS and 2.3 GB on Windows, checked before it is used; the Speak replies row shows the progress. The old English voice (about 350 MB) is removed.
Marked as AI: every spoken reply carries an inaudible AI-content watermark.

The IDE in your system tray

2026-10-26

The desktop you picked as your voice device now sits in the system tray: open the IDE and switch Speak replies, push to talk and the wake word from there, even with every window closed.

Tray menu: Open Exponential, Speak replies, Push to talk (with its shortcut) and Wake word (with its phrase), plus Voice settings… and Quit. Mute microphone joins once the IDE listens.
Only on your voice device: the tray shows on the desktop picked in Settings → Voice and disappears when you pick another.
Stays running: on Linux and Windows, closing the last window keeps the IDE in the tray so replies keep being spoken; clicking the tray icon or launching the IDE again brings a window back, and Quit in the tray menu ends it.
Linux: the tray uses StatusNotifierItem, shown by KDE, most other desktops and GNOME with the AppIndicator extension.

Settings → Voice: German and your own voice

2026-10-26

Settings → Voice gains a Language row (English or Deutsch) and a Voice file with its transcript, so a reply can soon be spoken in German or in a voice cloned from your own clip.

Language: pick English or Deutsch for spoken replies. German is spoken on a desktop with a GPU; without one, German replies are shown, not spoken.
Your own voice: enter the path of a short reference clip on your voice device and what it says. Nothing is uploaded, and there is no training: the German voice will clone it from that one clip.
How to make a good clip: the new guide at exponential.at/skills/voice-reference-clip/SKILL.md walks through picking, cutting and transcribing it, and the consent rule.
Coming next: the German voice and cloning arrive in the IDE in the next update; until then English keeps speaking as before.

Settings → Voice: one voice device, one agent, for you

2026-10-25

Voice moved out of Device settings into its own Settings → Voice page: pick the desktop that speaks and listens for you and the agent it talks to, once for all your devices.

One place: Settings → Voice on web, the IDE, iPhone and Android holds your voice settings once for all your devices, instead of a Voice group per device.
Voice device: pick the desktop that speaks for you; only that one reads replies aloud.
Agent: pick the agent you talk to; with no device or no agent, every switch turns off.
Coming next: push to talk, the tray and the wake word get their switches here as they ship.
Your old choice carries over: if Speak replies was on for a desktop, that desktop and agent are already set.

Speak replies: your assistant answers out loud in the IDE

2026-10-25

Pick the agent that speaks for you and switch on Speak replies in Settings → Voice: the IDE reads its replies aloud with a voice that runs on your machine.

Settings → Voice: pick your voice device (the desktop that speaks) and the agent you talk to, then switch on Speak replies; the same page on web, the IDE, iPhone and Android.
Spoken in the IDE: each final reply of that agent is read aloud on your voice device, with a Speaking banner and Stop above the composer; code blocks and links are skipped, issue numbers are said the way people say them.
Local voice: the voice (English or German) downloads once on first use, about 2.2 to 3 GB, and runs on your desktop’s GPU; nothing you hear leaves your machine.

Release 2026-10-25: Apps keep data, read the team and act as you, with the train’s fixes

2026-10-25

This release ships app records, team data sources, typed actions with owner grants, app export and import and the new phone layout to web, the IDE, Android and TestFlight, plus the fixes the release review found: a grant no longer survives a new app version from someone who is not an owner, two edits to one record keep both changes, and a chat no longer jumps to the top when its agent resumes.

Apps: a new version or a restore by a member who is not a team owner starts with nothing granted, until an owner grants again; previewing an older version in the editor runs it with nothing granted; two people editing the same record at once keep both changes; an import with a NUL character in it lists the problem instead of failing.
Chats: an agent picking up its instructions no longer moves its chat to the top of the list.
Assignees: choosing Unassigned in an older app version also clears an agent assignee.
Phones: on iPhone, New board on an empty board creates the board in the team you are looking at; on Android, a large app import no longer crashes when you switch away, and app grants arrive right after the update.
Store builds: Android 0.14.70 and the IDE 0.14.78 are live; iOS 0.14.68 is in TestFlight.

2026-10-25

Export any app as a .app.json file, with its records if you like, and import one in the New app dialog by pasting it or choosing the file; anything wrong with it is listed line by line before you import.

Export: an app’s … menu, its editor and its settings page export it as one file: its name, icon and colour, the current version and, with Include records switched on, its records.
Import: New app → Import… takes the file pasted or chosen; every problem shows under the field as the place in the file and what is wrong, and Import creates the app as version 1, noted Imported, with its records as yours.
Grants stay home: an imported app starts with nothing granted; a team owner decides on its settings page.
Everywhere: the web downloads the file, the IDE saves it, iPhone and Android share it.

Apps act as you: every Exponential operation, granted per app

2026-10-24

An app calls any Exponential operation as a typed function (exponential.issues.update, exponential.comments.create, exponential.sessions.send, …); its settings page lists what it uses and you decide which run without asking; the rest ask with the operation’s own words.

Typed actions: every MCP operation is a host function an app may call, run as you; the package lists what it uses and nothing else is reachable.
Grants: Settings → Apps → the app shows a Tools group with one switch per declared action; a granted action runs without the consent card, an ungranted one asks each time, worded for the operation (“Allow this surface to set issue status APP-5?”). Only a team owner grants, and a destructive operation (delete, merge, close, end, remove, trash) can never be granted: it always asks, for everyone.
Working hours: v5 posts a logged day to its issue as a comment through the typed action.
Platforms: the grants sync to the IDE, iOS and Android, whose hosts honour them the same way.

2026-10-24

The phone bar is now Board · Chats · Apps · Team and you can slide a finger across it; the Board tab shows your board and opens a menu of the team’s boards; every page has the same big title with search and inbox; each settings row opens its own page; search only looks in the active team and keeps up with your typing.

Bottom bar: Board · Chats · Apps · Team on iPhone, Android and the mobile web. Labels are no longer cut off, and you can slide a finger across the bar: the highlight follows it (Liquid Glass on iOS 26) and lifting picks the tab. Devices moved to a row on the Team page; Apps has its own tab.
Boards: the Board tab shows the board you are on. Tap it again on the board and the bar turns into a menu of every board in the team, with New board at the end. The board pill at the top of the board is gone.
Headers: Board, Chats, Apps, Team, Devices and Agent all have the same big title with round search and inbox buttons; the inbox shows a dot while something is unread.
Settings: each row on the Team page opens its own page instead of one long page of every section, and iPhone, Android and the mobile web show the same rows to the same people.
Search: searches the active team only, and typing no longer stutters on iPhone or Android.

Long chats open instantly, and the Chats list comes to the IDE and the web

2026-10-24

Long chats open in a fraction of a second on every platform and stay light while open; the web loads only what you look at, and the IDE and wide web get the same Chats list as phones.

Fast chats: a chat shows its newest 100 messages and opens at once, however long it is; Load earlier above them brings the next 100 and keeps your place. An open chat no longer works in the background, so long agent chats stop stuttering and Android no longer runs out of memory on them.
Web: the Chats list loads without downloading any transcript, and a chat loads only its newest messages when you open it, so the first load is much lighter.
Chats list: the IDE and the web on wide screens show the same Chats list as phones: agent bubbles, filter chips and one row per chat with its last message, time and unread count.
Jump to bottom: the jump button shows as soon as you scroll up in any chat, phones included, and takes you back to the newest message.
Working: an agent chat ends on the same Working line as a session while the agent works.

Agents act as themselves, stay in their team and take assigned issues

2026-10-24

Agents now show under their own name and mark in an issue’s activity and comments, work only inside their own team, can be assigned issues, and their chat says when its instructions changed.

Agents as themselves: what an agent does reads under its own name and mark: “Triage changed status to In Review”, its comments, the issues it files and the notifications they send.
Assign to agents: the assignee picker lists the team’s agents after its members; assigning one nudges your chat with that agent and emits the new issue.assigned event for triggers.
Instructions changed: after you edit an agent’s instructions its chat shows a banner with Start new conversation; a new conversation restarts the agent so it runs on the new instructions.
Team boundary: an agent and everything it starts work only inside the agent’s team, on a key that reaches no other team.

Apps read the team: boards, members, sessions, comments and files

2026-10-24

An app binds exp:boards, exp:members, exp:sessions, exp:comments and exp:attachments beside a richer exp:issues, the same rows on every platform; the Working hours app shows a teammate’s month and suggests your issues.

Sources: exp:issues now filters by board, status, priority, assignee (or me) and a search, sorts by list order or time; exp:boards, exp:members (with the viewer), exp:sessions, exp:comments and exp:attachments join it. One shared fixture pins the derivation on web, desktop, iOS and Android.
Options: issue, board and member rows carry value and label, so an app binds them straight into a Select or a ChipInput.
Working hours: v4 picks a teammate’s month through the member picker and suggests your assigned issues when you log a day.
Catalog: the apps catalog describes every source with its query and value, so the editor session binds them without guessing.

Apps keep their own data: records

2026-10-24

An app declares record kinds in its manifest, reads them live through exp:records and writes them without a consent card; agents fill them through the apps MCP noun.

Records: an app’s manifest declares its kinds with a small JSON schema; the server validates every write, every client syncs the rows, and the editor’s preview shows them live.
Bindings: exp:records?kind=… filters, sorts, sums and lays out a month; the new bind action re-follows a path from a button, so a month switcher is one action.
Agents: exponential_apps gained records_list, records_upsert and records_delete, so an agent or another app can fill an app’s data.
Quota: Free teams keep 1,000 records, Team plans 25,000, one record at most 16 KB; the app’s settings page shows the count.
Working hours: the demo app that replaces a spreadsheet: a month view with a switcher, hours and notes per day, built through the editor and seeded as the Apps pictures.

Release 2026-10-24: Chats on every platform, with the train’s fixes

2026-10-24

This release ships Chats, the new phone layout, agent compact and new conversation, live previews and the Apps cleanup to web, the IDE, Android and TestFlight, plus the fixes the release review found: a chat’s menu offers Delete only to who may delete it, a team switch on phones moves the board along, an agent’s rename reaches its chats, and a moved agent’s chats stay readable for the team.

Chats: the menu offers Stop and delete or Delete only to the chat’s starter or a team owner; everyone else who can steer the chat gets Stop. In the IDE a preview or tool card posted before the loaded part of the chat sits at the top instead of under the newest reply, and deleting a chat closes its child tabs too.
Phones: switching team on Android moves the Board tab to that team’s board, so a new issue files into the team you are looking at; the inbox dot counts the active team only; the agent chat’s menu shows Agent settings for owners. On iPhone, opening an issue from a push or link switches to its team, a team without boards shows an empty board instead of the previous team’s, and an inbox push opens the team it belongs to.
Agents: renaming an agent renames its chats (a chat you named yourself keeps its name); an agent moved to another device keeps its chats readable for the team; a stop on an idle chat no longer says the device missed it; a newer plan no longer replaces a waiting plan the coding engine itself asked.
Web: a brand-new chat waits for its conversation to arrive instead of flashing Untitled.
Store builds: Android 0.14.69 and the IDE 0.14.77 are live; iOS 0.14.67 is in TestFlight.

Chats: a WhatsApp-like phone app, stop and delete from the list, agents that compact and start over, and live previews in the chat

2026-10-24

Threads are now Chats everywhere. Phones get a new bottom bar, a chat list with agent bubbles, chat bubbles and a Team tab; every platform can stop or delete a chat from its row, compact an agent or start it fresh, and agents can draw live previews right into the chat.

Chats: threads are called chats on every platform. On phones the bottom bar is Board · Devices · Chats · Team, and the Chats tab lists your active team’s chats like a messenger: agents as bubbles on top (a ring when they need you or wrote something new), filter chips, and one row per chat with its last message, time and unread count.
Stop and delete: right-click a chat (long-press on phones) to Stop it or Stop and delete it; an ended chat offers Delete. The Stop button in a chat’s header now ends the chat, and a stop the device never received says so.
Agents: Compact conversation and New conversation in an agent chat’s menu, or type /compact and /new; both leave a marker in the chat.
Live previews: agents can draw an interactive preview (charts, stats, buttons) straight into the chat, and it animates in as it arrives.
Plans: a waiting plan always shows in the chat with its buttons, and a newer plan replaces the waiting one.
Phones: one active team at a time, switched on the Team tab, which also holds the settings; My issues and Drafts are chips on the board, and the inbox has its own page.
Triggers: agents can wake every 5, 10, 15, 20 or 30 minutes; hourly and shorter schedules no longer show a time zone, and the minute and hour lists scroll.

Apps lists only your team’s apps

2026-10-24

The built-in Devices app is gone: Apps, the sidebar’s Apps group and the IDE rail list only the apps your team makes.

Apps: Apps lists only your team’s apps; the built-in Devices app is gone. A team without apps sees the empty list. The Devices page stays where it was.

Every app reads threads through conversations, and actions are retired

2026-10-23

Web, the IDE, iOS and Android now load a thread’s messages through its conversation and stop syncing the retired actions, ready for the server cleanup that follows.

Threads: messages load through their conversation on every platform, so direct messages and channels can follow without another app update.
Actions: the apps no longer sync actions (prompts replaced them); an action pinned in the sidebar disappears.
Devices: moving a session to another device takes effect at once; the Moving to pin and its cancel are gone.
Session cards: the old caption line under a session’s name is gone.

Threads: the Conversation tab on every thread, filed issues stay where they are, and pickup after an update

2026-10-23

Every thread’s strip shows Conversation again, which on a one-session thread is that session’s own work; an issue a session files keeps its status until a session takes it up; a session whose device updated itself under it picks up its waiting message; and the pull request tools find an issue’s own pull request.

Conversation tab: every thread’s strip starts with Conversation. On a thread with one session it is that session’s work with its composer; the first child session turns it into the thread’s conversation as before. On web, the IDE and Android; on iPhone in the TestFlight build.
Filed issues: an issue a session files is linked to its thread but keeps its status. It moves to In Progress only when a session takes it up: a start, a forward, a link or your message into the session that holds it.
Pickup after an update: a thread whose desktop app or daemon updated itself mid-turn picks up its waiting message instead of sitting idle with it.
Pull request tools: an issue’s pull request resolves to the one opened by the session that holds the issue, so the MCP pr tools no longer refuse a choice they can make.

Release 2026-10-23: the Dock, Apps and the inline pickers on every platform, with the train’s fixes

2026-10-23

This release ships the Dock, the Apps editor, the inline pickers and the Exponential UI layout components to web, the IDE, Android and TestFlight, plus the fixes the release review found: a refused launch ends its thread, a closed Dock sheet stays closed, editor sessions stay out of issue threads, and the app host’s private-range filter covers CGNAT and the IPv6 forms that embed an IPv4.

Threads: a thread whose launch was refused ends instead of waiting idle and nudging its device every minute; a message to an ended thread still resumes the same session.
The Dock: a sheet you closed stays closed when its card comes back later (the Tasks sheet no longer reopens on the next run’s first todo); on phones the transcript keeps its room above the composer. Android’s Connection lost banner has its Reconnect button.
Apps: an app survives its creator leaving the team (ownership passes to the owners), a trashed app’s slug can be reused, and a version written from the editor session names its author. An app editor session no longer shows up as an issue thread or in the IDE’s Running list.
App host: the private-range URL filter also denies carrier-grade NAT (100.64/10) and the IPv4-compatible, NAT64 and 6to4 IPv6 forms, and the web renderers re-check a redirect’s target before reading it.
Store builds: Android 0.14.68 and the IDE 0.14.76 are live; iOS 0.14.66 is in TestFlight.

Apps: live counts and icons, six layout components, and better defaults

2026-10-23

App packages bind a count, an icon, a tone or a selection to their data, build screens from Page, Toolbar, SplitView, FieldGroup, FormActions and StatTile, and get centred control rows and the Section’s own spacing without tuning.

Live data props: a Section count, a row’s icon, chevron and selection, a chip’s tone, an image’s alt text, a slider’s range and more now take a binding, so an app’s counts and states follow its data.
Layout components: Page, Toolbar, SplitView (list and detail, one at a time on phones), FieldGroup, FormActions and StatTile join the catalog, drawn from the existing parts on every platform.
Better defaults: a horizontal Stack centres its controls unless told otherwise, a Section keeps one small gap under its band, and the built-in Devices app shows its device count in the band.
Agents: the catalog prompt names the layout components, asks for one primary button per screen and for List rows instead of Markdown bullets.

Exponential apps: build small apps with the editor session, previewed live and kept in versions

2026-10-22

A team’s Apps are declarative Exponential UI packages rendered inside every client; the editor shows your chat with the app’s own session beside a live preview, every published package is a version you can view and restore, and agents publish apps over the new exponential_apps tool.

Apps: the sidebar gains an Apps section drawn like Agents and Boards, the built-in Devices app first; the plus names a new app and opens the editor, the hover gear opens its settings page under Settings → Apps. Phones keep the Apps list behind the Threads header button.
The editor: your chat with the app’s editor session sits beside the live preview; the first message starts the session on your device, leaving the editor ends it, the next message continues it. Phones switch between Chat, Preview and Versions.
Versions: every package the session publishes is a version with a note; open Versions to preview an older one and restore it as the new head. No git involved.
MCP: the sixteenth tool, exponential_apps, lists, reads, publishes and deletes apps and hands an agent the catalog of components, bindings and host functions a package may use.
SDK: the Exponential UI package API is named for apps (AppPackage, createAppHost); the dev-only Devices template route is gone, the Devices package is the built-in app.

The Dock: one scroll, floating cards above the composer, and plans that open as a sheet

2026-10-22

A session’s transcript is the one scroll again; what waits on you (a plan, a question, the task queue, queued messages, a usage wall) floats above the composer as cards that pile like toasts, and a plan opens as a bottom sheet you can scroll, with Yes and No, keep planning in its footer; the composer is one row on every platform.

One scroll: the transcript runs from the header to the bottom edge; nothing splits the session view into panes any more, and the plan is never cut off below the window.
The Dock: a plan, a question, the suggested tasks, the task queue, the queued messages and the status banners (offline, connection lost, usage wall, compacting, rate limit) are floating cards above the composer; several pile like the toasts and fan out on hover or tap; the composer stays put. Suggested tasks open as a sheet with Start and a small menu per task.
One gray: every card, the composer and the sheets wear the same opaque card tone on every platform.
Plans open as a sheet: a tap (or a plan arriving while you watch) opens a bottom sheet with the plan, one page per question, and the decision in its footer: No, keep planning (with your feedback) or Yes (its menu starts with a fresh context).
One composer row: the + menu is the only tool; the device glyph, the model pin and Plan sit in the card and the usage ring beside Send, on web, the IDE and the phones alike.
Exponential UI: DockCard joins the catalog as a one-row card that opens its children in a bottom sheet with a pinned footer.

A thread survives an app quit, and a message to an ended thread resumes it

2026-10-22

Quitting the desktop app or losing a thread’s process no longer ends the thread: it waits, and your next message resumes the same session with its context. A thread you ended on purpose resumes the same way instead of starting a copy.

Threads survive their process: a thread’s own session goes idle when the app quits, the daemon stops or the agent crashes, exactly like an agent’s conversation; only End or the agent’s own close ends it. Sub-sessions still end with their process and report to their parent.
Resume, not copy: a message to an ended thread resumes that same session (its branch, title, issues and context) instead of starting a one-turn copy that ended after its reply, left your answer unread and showed an identically named session waiting forever.
Desktop quit: ⌘Q suspends the sessions it hosts the way the daemon already did on stop; their worktrees stay where the agent left them for the resume.

Release 2026-10-22: the new session system, agents with their own conversations, prompts instead of actions, and 15 MCP tools

2026-10-22

Every thread is one session that works itself and is woken by messages; agents are definitions that run as a conversation per member with server-fired triggers and an events stream; prompts replace actions in the / menu and Settings; the MCP surface is 15 noun tools with one runbook; devices re-claim their sessions after a restart and clean up their worktrees.

A thread is its session: the root works the task itself, no dispatcher; children are started only when the work calls for them, every child transition lands in the parent as a waking message, and a one-minute watchdog flags a session that stalls. The plan card asks one question at a time, with a stepper.
Agents: an agent is a definition (name, icon, instructions, device, model) and runs as its own conversation per member; triggers fire from the server on a schedule or on team events, and the Agents page shows the Events stream. Message an agent from the Home composer’s + menu; the reply opens in your DM with it.
Prompts replace actions: a prompt is a name, an icon and a body; it lives in the / menu of every composer and under Settings → Prompts. Inputs, picks and per-action triggers are gone (triggers belong to agents). Existing actions were converted.
15 MCP tools: one tool per noun (issues, comments, sessions, pr, …) taking an op, plus sessions_send and guide_write; one runbook under 6 KB written around the bus (end your turn, you are woken by messages). An op you lack errors instead of vanishing.
Devices: a restarted daemon or IDE re-claims every session its dead process left behind and continues a turn that was cut mid-way; a session’s worktree is removed when it ends (uncommitted work becomes a WIP commit on an exp/leftover branch); repo-less runs are confined to their scratch folder; the dispatcher checkout and the handoff package are gone.
Phones: Android and iPhone follow with the same screens (threads, agents with DMs, Events, Settings → Prompts, prompts in the / menus). The iPhone build you have keeps working until the new one is live; the Android update is required.

Release 2026-10-21: a faster iPhone app, moves that clean up after themselves, an unlink tool for pull requests, and the review fixes

2026-10-21

The iPhone app stops syncing while idle and does far less work per keystroke, a moved session’s source cleans up its worktree once the target has restored it, agents can detach a mislinked issue from a pull request, and the release review hardened computer use and the move flow.

iPhone, faster: the idle sync drumbeat is gone, lists, the session view and the editors do far less work per keystroke and per sync tick, and the Threads title sits in the sticky bar like every other tab.
Moves clean up: the source device keeps a moved session’s worktree and branch until the target reports the restore, then removes them; a move keeps its index, drops the unpacked package on any outcome and consumes owed messages once.
Unlink from a pull request: the exponential_pr_unlink tool detaches one mislinked issue from a pull request; the issue’s status stays as is and the thread keeps the issue.
Android capture lanes bundle the Exponential UI FFI, so the plan card’s Preview renders in the store and gallery shots.
Review fixes: the computer-use Esc abort is answered only by your next message, never by a turn the agent opens itself, the X11 backend keeps an Escape on a keymap without one and reads back wheel releases, the Windows hook start no longer waits forever, a week-old package no longer expires a move you just requested, a restore marker from a later move no longer deletes the first source’s recovery copy, a moved package with staged changes still restores on a device that has not updated yet, a board that is still syncing no longer flashes the “Syncing team” banner on iPhone, and a renamed status reaches the #EXP chips at once.

Computer use works in the foreground, with your input held and Esc to take it back

2026-10-19

An agent now drives the screen the way you would, in front of you: while it works your keyboard and mouse are held, a banner says so, and Esc hands them back and stops the turn. The background mode and its second pointer are gone.

Foreground only: the agent moves the real pointer and types on the real keyboard, one display at a time, the same way on Linux (X11), macOS and Windows.
Your input is held: while a session drives, your keys and clicks reach no window, and the banner at the bottom of the screen names the session.
Esc takes it back: Esc releases your input at once, stops the session’s turn and tells the agent; your next message lets it continue.
Gone: the background mode, the second pointer on X11, the agent cursor overlay and the linked driver. A Wayland session says so in the device doctor; sign in with the X11 session to use it.

Release 2026-10-19: sessions with real names, the Ask dock and plan card, moving a session between devices, and the review fixes

2026-10-19

Every session carries a real name on every device, a waiting question or plan takes the composer’s place, a running session moves to another of your devices with its worktree, quick replies sit above the composer, and the release review fixed what those changes left open on older apps.

Sessions name themselves: every session, tab and row shows a real name instead of “Session 2”, and a thread’s dispatcher groups related issues into one session, on web, IDE, iPhone and Android.
Ask dock and plan card: a waiting question or plan sits where the composer was, several stack up and open one at a time, and a plan reads as one rich card with pictures, choice questions and an inline Exponential UI surface, answered in the card on every platform.
Move a session: the Device pin in a session’s options moves a running session, with its worktree and conversation, to another of your online devices; the source keeps its worktree and branch as the recovery point until the move is fully restored.
Quick replies: short answers the agent suggests sit above the composer and send with one tap.
Threads: thread rows drop the private lock and the merged word, the Threads tab carries the live dot, the Inbox tab shows a dot while you have drafts on phones, and the session page lives inside its thread with one Stop in the header that hands queued messages back to the composer.
Issues and pull requests: follow-up work moves an issue back to In Progress and its end returns it to In Review, issue-targeted PR tools resolve to the issue’s own PR, and a Guide remove reaches the caller’s subtree.
Accounts: switching accounts keeps the model, shows itself in the session, and names accounts by email.
Review fixes: a move keeps the source’s worktree and branch until the target has restored it, a re-targeted or cancelled move never loses the uploaded package, a plan approved with a fresh context starts fresh even after the daemon restarted, a refused Stop puts the queued text back exactly once, the session transcript on iPhone shows the agent’s own plan and question cards, a plan card’s links and media open nothing, moving to a device on an older build is refused with an update note on every platform, and an agent on an older desktop build asks inline instead of posting a card it could never see answered.

Command line devices keep the shared build cache bounded

2026-10-19

Devices running only the exponential command line daemon now trim a repository’s shared Rust build cache once it grows past 20 GiB, like the desktop app already does.

Same rule as the desktop: once a repository’s shared cargo build cache passes 20 GiB, build units untouched for three days are evicted, plus examples and incremental data.
Safe while you build: a running build keeps its profile untouched, built binaries are never removed, and each repository is checked at most once an hour.

Follow-up work moves an issue back to In Progress

2026-10-18

When a session starts follow-up work on an issue in review, the issue moves back to In Progress, and returns to In Review once the work ends with its pull request still open.

Back to In Progress: a new sub-session, or a message to a working sub-session, in a thread whose pull request is open moves its In Review issues back to In Progress.
Back to In Review: once no session in the thread is still working and the pull request is still open, the issue returns to In Review on its own.
Your status wins: an issue you set by hand is never moved, and a status you change while the work runs stays where you put it.
Same switch: a team that turned off the pull request opened automation gets neither move.

Quick replies above the composer

2026-10-17

When an agent finishes a step it can offer its likely next messages as one-tap replies above the composer; tap one to send it, the others stay.

One tap instead of typing: an agent offers a few likely next messages, like “Raise the version numbers” or “Open the PR”, as small buttons right above the composer of the session or thread.
Sends at once: a tap sends that reply as your next message, even while the agent is still working; the other replies stay, so you can queue another right away.
Stays until replaced: the replies stay across turns until the agent offers new ones; the × dismisses them.
Everywhere: the same row on the web, the desktop app, iOS and Android.

Plans you can see and shape

2026-10-17

A plan now arrives as a visual card with pictures of the proposed UI, choice questions and a live preview, and you answer it in the card on every device.

Visual plans: a session in plan mode presents its plan with screenshots and design drafts inline, instead of a wall of text with a bare yes or no.
Choices, not just approval: the plan asks what it needs to know as single or multiple choice, as text options or picture tiles, with a free-text answer where it fits; Yes waits until every question is answered, No keeps planning with your note.
Live preview: an agent can draw the proposed screen itself as an Exponential UI surface inside the card; what you set in it travels back with your answer.
Rich questions anywhere: outside a plan, an agent can ask one question the same way, with pictures and several picks.
Same on every device: the card, the tiles and the answers look and work the same on web, iOS, Android and the desktop app, and a session cannot open a pull request before its plan is approved.

Move a session to another device

2026-10-17

A running session moves to another of your devices with its worktree and conversation, and continuing or stopping a session no longer loses its place.

Move to device: the Device pin in a session’s options moves it to another online device that can run its agent. It moves after its current turn, taking its worktree, unpushed commits and conversation along; logins stay on each device, and the session keeps the same account when the other device has it.
Moving…: while a move waits, the pin reads “Moving to Studio…” with the other device’s name; pick the current device again to cancel.
Continue where it ended: a message to an ended sub-session continues it next to the original, on the same branch with the same issues, instead of starting over from the thread.
Stop always frees a session: a session whose device went away no longer stays busy forever; Stop sets it idle, and its account shows in the session list.

Questions and plans take the composer’s place

2026-10-17

A waiting question or plan replaces the composer in a session and a thread alike, several stack up and open one at a time, and every plan offers the same three answers.

One place to answer: a question or plan waiting on you now sits where the composer was, in a session and in a thread alike, so a thread with one waiting card looks exactly like the session that asked.
Several at once: when sub-sessions wait on you together, their cards stack above each other with the plan’s first line and the session that asked; tap one to open it in place, answer it, or go back to the stack with the arrow.
Long plans: a plan never stretches the conversation any more; it scrolls inside its card.
The same plan answers everywhere: Yes, Yes and start with a fresh context, or No, keep planning with a note, from a thread as well as a session, on every device.

Sessions name themselves, and the dispatcher groups the work

2026-10-17

Every session has a real name, never “Session 2”, and a thread’s dispatcher groups related issues into one session.

Session names: every session, tab and row shows a real name: the one it was started with, else the name the agent gives its own conversation, else its issues (“#EXP-12 Login fails on Safari + 1”), else its action, else the first line of its request. “Session 2” is gone everywhere.
Grouped work: a thread’s dispatcher hands related or dependent issues to ONE session and independent ones to separate sessions, and names each one. A newly linked issue goes to the session already doing related work, or to a new one.
Pull requests: a session’s pull request closes exactly the issues handed to it.
Agents: a team agent that was running when its device went away starts again when the device comes back.

Threads: the live dot on the phone

2026-10-17

On the phone the running-session dot sits on Threads, not the chat launcher.

Threads dot: on Android, iOS and the mobile web the green running-session dot now sits on the Threads tab, like the sidebar on web and desktop; the chat launcher no longer wears one.

Account switching keeps your model and shows itself

2026-10-17

Switching a session to another account, by hand or by auto-rotate, keeps the model you picked, and every device shows the switch while it happens.

Model stays put: a model you pick with /model stays when the session moves to another account, by hand or by auto-rotate, instead of falling back to the one the session started on.
You see the switch: while auto-rotate checks your other accounts, the session reads “Checking other accounts…”; while it moves, its card spins with “Switching to you@example.com…”.
Emails only: the note a rotated session starts with names accounts by email, never an internal name.
No needless pushes: a usage limit the device rotates past no longer notifies you.

Threads: a header that never scrolls, one composer, and options mid-session

2026-10-17

A thread header that never scrolls, one composer, and options that change mid-session.

Thread header: nothing scrolls any more. “+” and Conversation sit on the left, Guide on the right, and issues then sessions fill the middle, shortening to identifiers and folding into “+N” when space runs out. Sub-issues fold under their parent issue and deeper sessions under their top-level session; click a folded chip to open its tree.
Link an issue: the “+” left of Conversation offers Link an issue and New issue on every device; linking posts “Link #IDENT” so the thread hands it to the right session.
The thread is its dispatcher: no extra session chip or card for it, and a sub-session’s question or plan appears in the thread’s conversation, answered right there.
One composer: the thread, a session and a new start share one composer, “Type / for commands”, with image, file, # and emoji in the box and the model, Plan and usage under it.
Options mid-session: plan mode switches at once; effort, ultracode, computer use and MCP servers apply from the next message, in the same session.
Issue status: linking an issue moves it to In progress; a pull request moves only its own session’s issues to In review and, once merged into the default branch, to Done; a parent issue waits for its linked sub-issues.

Release 2026-10-16: the transcript as trace lines, the Queue, and the review fixes

2026-10-16

A session’s work reads as one trace line per step with its output as a code block, the bottom of a session shows what is left to do and what is done, /btw works on web, Android gains Auto-rotate accounts, and the release review kept thread renames working on older apps.

Trace transcript: every step in a session is one line, “Ran bun test”, “Thought for 5s”, “Ran the Explore agent” with its duration, shimmering while it runs and red when it failed; a command’s output opens under its line as a code block with a copy button, coloured like its terminal output.
Failed tests: a command whose output is a failing test run reads as its result, “Failed: 1 of 12 tests”, instead of the command.
The Queue: the bottom of a session shows what is left to do and what is done as two folds, the running work first, with a background task’s elapsed time ticking.
Issue activity: event lines on an issue use the same trace line, with the time on the right.
Review fixes: /btw on web asks its side question as a short fork instead of sending it to the session, and a /btw fork can no longer change issues or pull requests; the thread’s model switch is off once the thread ended on iPhone; Android gains the Auto-rotate accounts toggle; parallel tool calls read as running until each one settles; a sub-session’s report lands exactly once; a shared thread is not marked unread for everyone the moment this release lands; and renaming a thread keeps working from Android 0.14.61 and the desktop 0.14.68 until they update.

Sessions talk back: reports, suggestions, live status and /btw

2026-10-15

A sub-session’s end lands as a report in its parent’s conversation, agents propose follow-ups you start with one tap, every running session shows what it is doing right now, unread threads stand out and /btw asks a side question without interrupting.

Reports: when a sub-session ends, a Report line in its parent’s conversation opens it, and the parent picks the summary up as its next turn.
Suggestions: an agent can propose follow-up tasks as one card. Start one as a sub-session, do it in the same session, file it as an issue or dismiss it, or start them all at once.
Live status: a running session’s card shows its current step under the name, and sub-sessions nest under their thread in the Threads list.
Unread: a thread with agent messages you have not read yet shows its title in bold, on every device.
/btw: ask a running claude session a side question; the answer comes from a short fork and the session keeps working.

Threads hand work to their own sessions

2026-10-15

A thread now runs a small dispatcher on the thread model (Haiku by default): it answers quick questions itself and starts a session for real work, with the same reply box and model switch as a session. Every model pick is explicit.

Threads: starting a thread or a new agent runs a dispatcher on the thread model (agents created before this release keep running on their own model). Quick questions get answered in the thread, real work starts its own session with your model, effort and plan mode, and the dispatcher reports back in a line or two.
Reply box: the thread and agent channel use the session’s reply box on every device, with the model switch, the context ring, slash commands and Stop.
Thread model: device settings gain a Thread model under Model for each agent, Haiku for Claude by default.
Models: every model picker lists Fable, Opus, Sonnet and Haiku (Codex its three models) with no Default entry. Saved CLI defaults become Fable for the model and Opus for subagents.

Older apps and older servers retired

2026-10-15

This release drops the server’s compatibility paths for app builds older than the ones in the stores and on the desktop fleet, and every app now expects a server from the same release.

Update your apps: the oldest builds this server speaks to are iPhone 0.14.59, Android 0.14.61 and the desktop app or CLI 0.14.68. Older builds should update now; the update screen follows when the floors move.
Self-hosting: upgrade the server before the apps, since new apps no longer work against an older server, and set the CLIENT_MIN_VERSION_* floors to the builds your users run (see selfhost/.env.example).

Release 2026-10-15: described options everywhere, the phone dawn, and the review fixes

2026-10-15

An agent’s question options can carry a short description on web, IDE, iPhone and Android, Home on phones puts the composer on the dawn, a walled session switches accounts again, and the release review fixed sending from Safari and thread renames on older apps.

Described options: when an agent asks a question, each option can carry a short description under its label, on every device. Older phones and desktops still see the plain labels.
Phones: Home puts the composer on the dawn at the bottom, and the floating reply box no longer folds away when you tap Send in Safari.
IDE: New agent opens the Settings page like on web, animations repaint only on their own step, a thread never carries the Inbox beside it and pictures in thread messages load.
Accounts: a session that hits its usage limit can switch to another signed-in account from its wall on every device, and switching on its own now also covers threads without a repository.
Members: adding a person without an invite and inviting them at the same time no longer fails on the invite side.
Sign-in: a personal API key the server rejects answers with a plain sign-in error instead of a server failure.
Older apps: renaming a thread by hand keeps working from Android 0.14.61 and the desktop 0.14.69 until they update.

Add a teammate without inviting them

2026-10-15

Settings → Members puts a person on the team by name and email without sending a link: assignable and mentionable right away, no seat, no mail, invited whenever you choose.

Add without inviting: next to Send invite, Members gains a button that adds the person to the team without mailing them. They can be assigned issues and mentioned at once, cost no seat and get no mail. The row reads Not invited until you use Send invite on it, and signing in or accepting that invite makes the account theirs.
Agents: the exponential_members_add tool does the same, and exponential_members_list says which members have no account yet.

Threads look the same everywhere: titles, header chips, lists and the Guide’s pictures

2026-10-14

A thread is named after its work, its header chips stand as tall as its tabs, lists drop their dividers, the Guide’s pictures open with their notes and phones get a floating reply box.

Thread titles: a thread is named after its work, like Implement EXP-12 or Run Triage, or the name the agent gave it. Threads are no longer renamed by hand.
Header chips: the issue chips in a thread’s header are the same height as Conversation and Guide, and an issue opened in a thread shows only the issue, without its own Start button or bar.
Questions: a question in a thread is the same card as in the session, so you can type your own answer there too, and a queued message has an X to take it back.
Lists: every list shows its rows without dividers, and the rail’s Active section keeps threads that wait on a merge.
Pictures and phones: a picture in the Guide opens next to its topic’s notes with arrows to the next one, and on phones the reply box floats over the conversation.

Threads v2: one list of your work, team agents, and one way to start

2026-10-13

Threads replace Reviews and the session history: every piece of work is one conversation with its sessions as cards, team agents look after a board from their own device, and everything starts from the same composer.

Threads: the rail’s Threads page lists your work as Needs you, Running and Recent. Reviews and the Agent page’s history are gone.
One conversation: a thread shows the people, the agent’s replies and one card per session. Tap a card to see the session’s raw work. Reply in the same composer you start sessions with.
Private or shared: a thread started on a device shared with the team is visible to the whole team, who can reply, answer and stop it. A thread on your own device stays yours.
Team agents: Settings → Agents adds agents like boards: a name, an icon, a color, a device, an account, a schedule and instructions. An agent waits for messages or its schedule and starts a thread for each piece of work. Agents sit in the rail above Boards.
One start: the composer, Start on an issue, an action, an agent’s schedule and a follow-up all start a session the same way, in the team you have open.
Actions are saved prompts: an action is a name, an icon, a prompt and the things it asks for. Schedules moved to team agents.
Pull requests: a thread can open several pull requests, and each one’s body is the thread’s Guide. Merging no longer ends a session.

Threads: one place for a piece of work, its issues and its sessions

2026-10-12

A thread holds the issues and sessions of one piece of work. The agent links the issues it files or picks up, the thread shows every session and link as one conversation, and lists show threads instead of single sessions.

Threads: every session starts in a thread. A session on an issue joins that issue’s thread, a resume continues its thread, and anything else opens a new one.
The agent links its work: the agent files new issues into its thread, links existing ones and detaches what does not belong. Each link shows as a row in the conversation.
One page: the tabs across the top read Conversation, each linked issue, a plus button and Guide. On phones they are the pager.
Many sessions: resumes continue the conversation, ended sessions fold to one line with Show work, and sessions one session started side by side share one card.
One PR, one Guide: a thread’s PR covers every issue in it by default, and its Guide is the PR body.
Menus: link an issue, file a new issue into the thread, start a session in it or unlink an issue from the plus button or an issue’s menu.
Lists: Running and Recent show threads with their issue and session counts, and an issue names the threads it sits in.

The Agent page is home, one issue search, Getting started as a checklist, one way to wait and fail, and sessions

2026-10-12

Every app opens on the Agent page with a greeting over the composer, # opens a real issue search with every match, Getting started is one short checklist, sessions started elsewhere no longer take over the desktop app, and loading and errors look the same everywhere.

Home: web, desktop, iOS and Android open on the Agent page. It greets you by time of day and asks what you want to build; nothing else sits under the composer. The suggestion rows are gone.
Tabs: on the web and the desktop app the close button shows on hover, and a plus button after the last tab opens a New session tab that becomes the session’s tab once it starts.
Issue search: typing # opens a search box at the cursor (a bottom sheet on phones) that takes spaces and lists every match, not six. The plus menu’s Implement issue and Run action open the same list beside the menu.
Getting started: one checklist of eight steps in the order you need them, with a Docs button. The next step opens with one sentence on why and a button to do it. It shows on an empty board and on the Agent page of a team without boards; done steps stay clickable. Action suggestions are gone.
Starting a session: after Start the composer shows the Exponential mark and where the session is starting until it lands. A session started from another device, a teammate or an agent no longer takes over the desktop app; it appears in Running with a toast to open it.
Loading and errors: skeleton rows replace loading text, buttons show a spinner while they work, and a failed action is a toast with Retry. Mistakes in a form still show under the field. The team prompt saves as you type.
Session threads: workflows, task lists and subagents share one Work card, a code-mode script shows the tools it called, and a comment the agent posted shows the real comment and opens it on the issue.
Polish: the session thread’s fades no longer tint or blur the card border, the desktop diff page scrolls as one page, and menus, popovers and buttons follow one set of motion rules.
Sessions: what used to be called a run is a session everywhere: tabs, menus, toasts and the docs.

Issue history over MCP, and renames in the activity timeline

2026-10-12

Agents can read who changed an issue’s status, assignee, labels, priority, estimate or title and when, including whether a person, an agent run or an automation did it; renames now show in the timeline.

Issue history for agents: the new exponential_issues_activity MCP tool lists an issue’s changes oldest first, each with the field, the old and new value, who made it, whether it was a person, an agent or an automation, the run behind an agent’s change and the time. since returns only what changed after a point in time.
Renames in the timeline: changing an issue’s title adds a “changed the title to” row to its activity on web, desktop, iOS and Android, folded like other quick edits.

One empty state, no refresh buttons, and a filter for the built-in tools

2026-10-11

Every empty list on web, desktop, iOS and Android says the same short thing under the same glyph, refresh buttons are gone from lists that reload on their own, and the MCP settings show the built-in Exponential tools expanded with a filter box.

One empty state: every list, page and picker with nothing in it draws the same block on every client: a glyph, a short title and, on a page, one sentence and a button. The copy is shared across web, desktop, iOS and Android.
No refresh buttons: lists that load from the server reload when you open them, when you come back to the tab and after every change; a small spinner in the list band shows a reload. Refresh stays only where the source is outside Exponential, like GitHub or the local disk. Pull to refresh on the phone issue lists is gone too: they are live.
MCP servers: the built-in Exponential tools are always listed with a filter box, the explanatory line under the band is gone, and Add server is always there for owners.
Link previews: an Exponential link pasted into Linear, Slack and similar tools shows the Exponential logo and the issue identifier instead of a blank link.

Older apps must update: the compatibility paths for pre-October builds are gone

2026-10-11

The server now requires iOS 0.14.57, Android 0.14.59 and desktop or CLI 0.14.66, and the code that kept older builds working is removed.

Older clients must update: the server now requires iOS 0.14.57, Android 0.14.59 and desktop or CLI 0.14.66. An older app shows the update screen until it is updated.
Files for runs: attaching a non-image file to a run works on every device; the “needs the device on 0.14.66 or newer” refusal is gone from web, desktop, iOS and Android.
Cleanup: the automations table and shape that mirrored action triggers for pre-October apps, the empty workflow shapes, the retired GitHub claim tables and the old exponential_sessions_results tool name are removed. Nothing changes for apps on the required versions.

2026-10-10

Every agent login is named by its email, runs only use logins added in Exponential, the device check offers to import your terminal login, and signing in as an account you already have refreshes it instead of adding it twice.

One login per email: account rows and pickers no longer carry names like “Claude Code account 2” or “Default”; a login is its email on every client.
No shared terminal login: runs, usage and rotation only use logins added in Exponential, so switching accounts in your own claude or codex CLI never changes what a run uses. A run that used the terminal login resumes on your last used account.
Import: when a device still has a terminal login, its device check offers Import next to Sign in. Import moves that login into Exponential (sign in again outside of it), on web, desktop, iOS and Android.
No duplicates: signing in as an account the device already has refreshes that account, leaves the others untouched and says so in a warning.

Fix merge conflicts from a refused merge, Reviews across teams, and a polish round

2026-10-10

A merge refused for conflicts offers the Fix merge conflicts run, Reviews names the issue of a pull request whose repository is connected in another team, stacked merges heal their base first, and rows, spacing and copy line up on every client.

Fix merge conflicts: when a merge is refused because the branch has conflicts, the Merge control opens the composer on the built-in Fix merge conflicts action with the pull request picked, on web, desktop, iOS and Android. The run rebases, resolves and merges; a pull request inside an open stack is pushed and left for Merge stack.
Reviews: a pull request linked to an issue in another team no longer lists as “not linked to an issue”, and a plain merge refused on a stack member explains that Merge stack lands it with the pull requests below it.
Stacks: Merge stack heals a landing whose bottom pull request still sits on a merged base, a pull request that failed to join its GitHub stack still opens with a warning instead of an error, and a report topic’s pull request link is matched whatever form the agent wrote it in.
Files for runs: attaching a non-image file to a run needs the device on 0.14.66 or newer; images keep working with older devices, and the composer says so.
Polish round: relative times read “5h” and “3d”, status changes read “from Backlog to In Progress”, list bands drop their counts, settings rows share one layout, and dozens of small alignment and copy fixes land on web, desktop, iOS and Android.
Android: the Work screen no longer redraws every frame while idle (battery), and pictures an agent shows inline render under the transcript call.
iOS: session text no longer overlaps and the doubled Discard button is gone.
Code mode: scripts can no longer import files from the host machine, a runaway script is stopped at its deadline, and bulk tool calls run on a bounded worker pool.
MCP: exponential_sessions_get waits up to 10 minutes for a run to go idle without the request timing out, and a chat run’s report survives the client ending the row.
Older apps: apps from before this release keep working.

Links in agent replies: sources, runs and issues

2026-10-10

Agents cite sources as links in their replies and Guides, a link to a run or issue on your instance opens inside the app, and a placeholder link opens nothing.

Sources: agents now cite documentation and references as inline links, and a link to another run opens it.
In-app links: on web, desktop, iOS and Android a link in a run’s thread, transcript or Guide that points at a run or issue on your instance opens it in the app instead of a browser tab. On iOS and Android every other web link opens in the in-app browser; on web and desktop in your browser.
Bare URLs: plain URLs in the desktop transcript and the iOS thread and Guide are now clickable, and the iOS Guide shows issue pills.

The Guide, runs as a conversation, and one Merge stack button

2026-10-09

Changes and Results become one Guide with a diff per section, a run reads turn by turn with your messages, a stacked pull request merges with one Merge stack control, and the composer, lists and menus get quieter.

Guide: an issue’s Changes and Results faces are now one Guide face on every client. Each section of the agent’s report ends in a Changes row (files and line counts) that opens just that section’s diff with a back button, files no section names land in Other changes, and Show complete diff sits at the bottom.
Runs as a conversation: the run thread reads turn by turn, with a status row per turn and your own messages in between. Teammates still see the single status row.
Merge stack: a pull request in an open stack has one Merge stack control that lands the whole chain, and hovering a member offers Merge through here. Merging a stack member on its own is refused with the list of what would land.
GitHub stacks: an agent’s pull request opened on another open pull request’s branch joins its native GitHub stack, and the base is picked for it when the agent leaves it out.
Composer: the + button opens one menu (implement an issue, run an action, add a file, effort, subagents, ultracode, MCP servers) with computer use switchable per run. Add file or image takes any file up to 50 MB beside up to four images, in a start and while steering, and the message shows it as a file link. Suggestions are quiet text rows under the box, and the Agent page shows a faint brand mark.
Lists: run rows drop their chevrons and keep the run mark aligned at every depth, Reviews rows are one line without merge buttons (stacks draw as a rail), and list headers no longer carry counts.
Navigation: a second sidebar shows only for the Inbox and the Agent page’s recent runs, stepping through them reuses one tab, and the desktop keeps each team’s tabs when you switch teams.
Drafts: a draft’s Files list no longer repeats its inline images, a picture attached with the paperclip stays a file, and the × on the New issue page is gone (leaving still asks what to do).
MCP: exponential_sessions_results is now exponential_sessions_guide; the old name keeps working.

Code mode: scripts that drive many tools at once, and a model for the screen

2026-10-08

Every coding run gets a Code mode server whose scripts call the run’s other tools in bulk and in parallel, computer-use tool calls run side by side, and a device setting picks the model the screen-driving subagents use.

Code mode: every coding run gets a codemode MCP server whose codemode_exec tool runs JavaScript that calls the run’s other MCP tools in bulk and in parallel (Exponential, team servers, computer use); only the script’s output comes back.
Computer use: a run’s tool calls now execute side by side, so a script can drive several windows at once.
Computer use model: a device setting under Computer use picks the model the run’s screen-driving subagents use; Haiku 5.5 by default for speed.

Runs open as a thread, drafts stay in step, and team actions bring their own MCP servers

2026-10-07

A run opens as a status row over its results with Show work for the transcript, a draft created or discarded on another device follows you, an action carries the team MCP servers every run connects to, Agent leads the navigation, and Codex needs no CLI install.

Runs read as a thread: on web, desktop, iOS and Android a run opens as a status row (Building on your machine, elapsed time, the last tool line) over its results in publish order, with the agent’s open question in place. Show work expands the full transcript and remembers your choice.
Drafts in step: an issue created from a draft on another tab or device lands on that issue here, and a draft discarded elsewhere closes with a note, on every client.
Team actions with MCP servers: an action lists the team MCP servers every run of it connects to. A member can share their own connection with the team (Share with team / Stop sharing in Settings, MCP servers), and the server spends it only for that action’s runs.
Navigation: Agent is the first entry on web, matching the desktop rail.
Codex: the IDE and the CLI fetch a pinned Codex build on the first sign-in (checked against its published checksum); no CLI install and no doctor step.
Desktop: right-click a run row or the transcript for its menu, and every confirm and choice prompt takes its words and button roles from the shared prompts fixture. Deleting an action asks first on every client.
Fixes: merging or updating an agent’s pull request that has no issue no longer fails with a GitHub error, and results pictures upload reliably when the file store is rate-limiting.
Linux: the desktop AppImage now needs glibc 2.39 or newer (Ubuntu 24.04 and later); the CLI binaries are unchanged.
Older apps: apps from before this release keep working.

Computer use, one dialog style, and drafts that ask before they leave

2026-10-06

Agents can drive the screen from the IDE and the CLI, every confirm prompt looks the same on web, iOS and Android, leaving a draft with content asks what to do, a run reads Working until the agent is really done, and a session that started a run can read its transcript.

Computer use: a per-device switch (off by default) lets Claude see and drive the screen on macOS, Linux and Windows from the IDE and the CLI daemon. The doctor block on every client says whether the machine is ready.
One dialog style: every confirm and choice prompt on web, iOS and Android uses the same card with the same wording, and Return never picks a destructive answer.
Drafts: the × asks before discarding a draft, and leaving a draft with content asks Create, Keep as draft or Discard, on web, desktop, iOS and Android.
Runs: a run keeps reading Working while the agent continues after a background task finishes, a live tool row shows only its headline, the run mark leads every list row, and the red needs-you dot is gone (an amber badge still marks a run waiting for you).
MCP: exponential_sessions_messages lets the session that started a run read that run’s transcript, exponential_sessions_get can wait for the run to go idle, and exponential_sessions_end is registered in every run (a person-started run calls it only when asked).
Account: unlink a sign-in method as long as another way in remains; the email code no longer counts as one.
Phones: the board picker no longer shows the other-teams dot.
Desktop: the markdown editor keeps a paragraph’s leading spaces and Tab works on images, and Claude runs show an Exponential tool’s preview (chips, inline pictures).
Older apps: apps from before this release keep working.

Agent first, and run pull requests you can read in the app

2026-10-05

Phones open on the Agent page, tabs swipe sideways, a chat or action run’s pull request opens its changes in the app, Actions and Drafts are top-level entries again, and Exponential’s MCP server draws issue, run and inbox views inside MCP clients.

Phones open on the Agent page: web, iOS and Android land on the Agent page with the tab bar kept, and the chat button is lit while you are there.
Swipe between tabs: Inbox, My Issues and Drafts page sideways like the issue tabs, and so do Actions and Suggestions and the action page on the phone web.
Run pull requests: a pull request from a chat or action run opens the run’s Changes tab on web, desktop, iOS and Android instead of GitHub. Teammates get a read-only view of the diff.
Navigation: the More menu is gone on web and desktop. Actions and Drafts (while you have any) are top-level entries, actions wear a rocket, and the desktop footer has a Computer menu with Terminal, Files and Source Control.
Desktop sidebar: the sidebar stays expanded everywhere and the app opens on Agent. Inbox, a Reviews detail and the Agent page’s recent runs open a second list inside the content card; the Reviews list there includes pull requests from agent runs, and the file tree only shows when the diff keeps enough room.
Issue and run pages: the properties stay in view under the header on every tab, the transcript fades into the composer, an arrow jumps to the newest message, the task list shows its progress, a plain × discards a draft, and Merge is a circle in the phone’s bottom bar.
MCP Apps: in MCP clients that support MCP Apps, Exponential’s server draws the issue list with issue detail, runs, the inbox and devices as interactive views. New tools: exponential_issues_show and exponential_devices_account_login. An OpenClaw plugin ships in the repository.
Safer by default: signing a machine’s agent account in through MCP needs a full-access key, and a run’s pull request diff is readable only when its repository belongs to the run’s team.

Fixes on top of the one-path wave

2026-10-04

Reporter replies reach the team, Reply to reporter switches off after each send, the GitHub connection stays signed in, phone lists span every team, and the issue title collapses into the header as you scroll.

Reporter replies: a widget reporter’s answer reaches every team member when nobody is assigned to or following the issue, and the Reply to reporter toggle switches off after each send on web and desktop, so a follow-up note stays inside the team. A comment an agent sent to the reporter reads “to reporter · via MCP”, and comments from people who left the team read “Former member” on every client.
GitHub connection: refreshing the connection no longer signs you out when two screens refresh at once, the GitHub user token stays on the server (API keys cannot read it), Continue with GitHub only works when the instance enables it, and the connect page never leaves the site after the flow.
Pull requests: an issue-less run’s pull request keeps its base branch across a close and reopen, old links to the separate review page open the issue’s Changes face, and opening an issue with an open pull request no longer asks GitHub for the diff on every visit.
Phones: Reviews, runs, actions and devices list every team you belong to, grouped by team; the Actions tab replaces the More menu; the issue title collapses into the header as you scroll and content slides under a blurred edge on iOS, Android, web and desktop.
Runs: a run shows a screenshot while it works, filed under its Results; queued merges report as queued; the Run face collapses to a status row when there is nothing live.
Joining a team: the invite flow offers the device setup step when you own no device yet, on web, iOS and Android.
Emails: report confirmation and resolution emails show the title as plain text, and the resolution subject no longer repeats it.
Android: reporter comments an earlier version failed to show appear after updating.
Older apps: apps from before this release keep working. App Store iOS and current Android builds do not show reporter comments until they update; older desktops’ email settings save again.

Review the pull request on the issue

2026-10-04

A pull request’s diff is the issue’s Changes face now, and Results reads as a numbered guide whose text is also the pull request’s description on GitHub.

One page: a Reviews row, the issue’s pull request row and the Related work rows open the issue on its Changes face, with the file tree beside it, Merge PR in the properties and GitHub in the header. The separate review screen is gone on web, desktop, iOS and Android.
Close PR: closing a pull request without merging moved into the issue’s actions menu.
Results as a guide: the summary leads, then one numbered section per change with the files it touched and its screenshots. A file opens the Changes face on that file. An open pull request without a report shows its GitHub description.
Pull request description: the agent’s report is the pull request’s description, so the two never disagree; screenshots stay in Exponential.
Phones: Merge PR is the white button on the bottom bar again, on every face.

Run status at a glance

2026-10-04

Every live run says what it is doing wherever it is named: Claude’s spark spins while it works, amber waits on you, green has an open pull request, blue is done.

Working: while the agent works, its mark is Claude’s own spark, spinning in the sidebar’s Running rows, the run lists, the tabs and the Run face. Other agents pulse their mark.
Waiting on you: an amber badge, also when the run already has a pull request open and asks again.
In review: a green badge once the agent finished and its pull request is open.
Done: a blue badge once the agent finished with no open pull request, or after the merge.
Follow-ups: a follow-up on a run in review shows it working again and returns to green when the turn ends; the issue’s status does not change.

One way to connect GitHub

2026-10-04

Connect GitHub, install the app, pick a repository: one guided page that every Start coding checklist, board form and settings section opens, listing the repositories you can push to.

One flow: Connect GitHub links your GitHub account to your Exponential account (any login works), installs the Exponential app on the accounts you choose, and lists the repositories you can push to. The team claim step, the install round-trip and the stale-access banners are gone.
Start coding: the checklist’s Connect GitHub fix opens that page over the issue; coming back ticks the row off.
Settings → Repositories: your GitHub connection with its accounts and a Configure link per account, Install on another account, and Add repository from the live list or by name.
Self-hosting: the GitHub App now needs its OAuth client id and secret, and its callback URL is the login callback; INSTALL.md walks through it.

2026-10-03

The sidebar and the tab bar show Inbox, Devices, Reviews, Agent and your boards; Actions, Drafts and the desktop’s Files and Source Control sit behind one More entry, and every client says run.

More: Actions, the Drafts pile and (on the desktop app) Files and Source Control moved behind one More entry at the end of the main navigation on web, desktop, iOS and Android. On a phone, More also opens Settings.
Inbox: the iOS and Android tab called My Work is called Inbox, like the web and the desktop app.
Settings: Storage, Import and Archived boards sit in an Advanced group at the end of the settings navigation on web and desktop. The desktop’s Sessions section is called Runs.
One word: a coding run is a run everywhere: Stop run, Resume previous run, Run ended, and the merge notes say the run ends.

One path for feedback

2026-10-03

Every widget submission is an issue, you reply to the reporter from the comment composer, and their answers come back as comments and Inbox rows. The helpdesk and its Support inbox are gone.

Widget submissions are issues: whatever a visitor sends through the widget lands as an issue on the widget’s board, with their screenshot, page context and contact attached. The widget has no modes any more.
Reply to the reporter: the comment composer on such an issue carries a Reply to reporter toggle. Switch it on and your comment is emailed to the reporter, marked “to reporter” in the thread.
Reporter answers: the reporter answers from the emailed link. Their reply shows up as a comment on the issue, marked “reporter”, and reaches you as an Inbox row and a notification. A reply on a done issue reopens it.
Helpdesk removed: the helpdesk, its Support inbox and the Support entries in the sidebar are gone. Old conversations were moved to issues on a Support board so nothing is lost.

New issue is a page

2026-10-03

New issue opens as the issue detail in draft mode on web, desktop, iOS and Android, saving a draft as you type until you press Create.

New issue page: the create dialog is gone. New issue opens a blank issue page with the same title, properties, description and files you know from the detail, on every platform.
Drafts as you type: what you write is kept as a draft a moment after you stop typing, when you pick a property and when you leave the page. Come back from Drafts and continue where you stopped.
Create: the Create button in the header files the issue and lands you on it. Discard draft in the menu throws it away.
Files on drafts: paste or attach files before the issue exists; they move onto the issue when you create it.

Safer merges for dependent pull requests

2026-10-02

Fixes on top of One kind of run: a pull request built on a merged one is never squashed into the merged branch, teams on their own default branch merge normally, and stack actions on phones stay inside the team.

Merging dependent work: a pull request based on one that just merged is first moved to the default branch and only then merged. Merging a root and its children in one go no longer squashes a child into the merged branch.
Other default branches: on a team that works on a branch like develop, a release pull request from that branch no longer makes every other pull request look stacked, and merging a run’s own pull request no longer moves the others to the wrong base.
Merge queue: a run’s merge that GitHub only queued no longer marks its issues as merged.
Stacks on phones: the Merge stack dialog, the Related work badge and a Stacked PR start only look at the issue’s own team on iOS and Android. A failed stack merge shows the reason and no longer offers Fix conflicts for the wrong pull request.
Bulk start: Start coding in the selection bar starts the run directly on web, desktop, iOS and Android.
Fix conflicts: starting it remotely for a pull request whose board has no repository is refused with a clear message.
Stacked lines: a stacked start of more than three issues continues up to the issue you picked.
iPhone: pickers, the usage sheet and the file sheet on the Work screen open on the first tap, and the transcript scrolls under the composer on the Run tab.
Desktop: the device picker shows your default device right away, and the sidebar’s resize handle sits on the edge of the main card.
Older apps: apps from before this release keep working. Their Workflows page is empty, and Stacked PR starts a plain run until the device has updated.

One kind of run

2026-10-01

Workflows are gone: a run plans and fans out its own work. Batches, stacked pull requests and the Related work badge keep working.

Runs: workflows are removed. A run splits its own work with subagents and starts further runs for the follow-ups it files, each on its own pull request.
Batches: starting several issues as one batch run with one combined pull request works as before.
Dependent work: a pull request can still be based on another one. Merge the first one first: its merge moves the ones built on it to the default branch.
Reviews: one flat list of open pull requests. The Workflows group is gone.
Blocked issues: starting a blocked issue asks Cancel, Start anyway or Stacked PR. A stacked start builds the whole line bottom-up: the lowest issue without a pull request starts first, and each run starts the next one on top of its own.
Header: the Related work badge stays (blockers, batch, stack). A batch run’s title also lists its issues.
Merging: Merge on a stacked pull request asks Merge stack or Merge this pull request, and lands the stack bottom-up.
MCP: the exponential_workflows_* tools and stackOnIssueId are gone. exponential_pr_open takes base, and exponential_pr_merge merges issueIds in the given order or a stack with mergeStack.
Older apps: older apps keep working and show an empty Workflows page.

Triggers, accounts and connections, tightened

2026-10-01

Fixes on top of today’s changes: trigger switches that no longer undo each other, older apps that keep editing their automations, and steadier account picks, retries and desktop connections.

Triggers: two quick changes to an action’s triggers no longer undo each other on web, desktop, iOS and Android, and an action that came out of the move with more than ten triggers stays editable.
Older apps: an app from before the triggers release still pauses, edits, creates and deletes automations, and its Set as default on an account answers instead of failing.
Accounts: a run started without an account skips a last used login that is signed out. A desktop app or CLI that had a default account keeps it as its last used login when it updates.
API errors: the automatic retry stops after three failed attempts, even when each attempt got a few words out first.
Desktop connection: slow requests no longer make the app rebuild its connection, apps do not all reconnect in the same second, and after wake the new connection is in place before sync restarts.
Phone tabs: on Android the keyboard closes when you change the tab, and on iOS Stop and Resume stay correct after swiping between Run and Changes, the issue page runs to the screen edge again and Properties opens on the first tap.
Desktop: the list beside an open issue or run is wider and its edge can be dragged, the run dialog of an action fits its content, and the compaction bar is smaller.
Stacks and batches: one quiet badge in the header opens Related work with what blocks the issue, what shares its pull request and its stack. Closed rows are dimmed on desktop too.

Actions have triggers

2026-10-01

Automations are now triggers on the action they run: one Actions list, and each action is a page with its prompt, its triggers and its runs.

Triggers: a schedule or an event that starts an action now lives on that action. Your automations became triggers on their action and keep firing on the same device, with the same account, model and effort.
Action page: opening an action shows its prompt, its triggers and its runs, as sections of one page on desktop and as tabs on a phone. The Automations page and tab are gone.
Actions list: a clock marks an action with a schedule, a bolt one that an event starts. The mark is dimmed while that trigger is paused.
Runs: an action lists every run of it, the triggered ones marked. It replaces Recent automated runs.
Tidy up: a team that had scheduled Tidy up now owns it as an action with the same prompt, free to edit.
MCP: exponential_actions_update takes triggers. The exponential_automations_* tools are gone.
Older apps: apps from before this release keep firing their triggers and still pause, edit and delete them as automations.

Last used account

2026-10-01

There is no default account any more: every start picks the account you last used on that device.

Last used: the composer on every client starts on the account you last started or switched a run on, per device, and a run that names no account (an automation without a pinned account, a CLI or MCP start) runs on it too.
Removed: the Default account row in Device settings and Settings > Agents, and Set as default in a device’s account menu.
Unattended runs: automations, workflows, agent-started runs and automatic account rotation never change it.

Runs recover from API errors and dead connections

2026-10-01

A run whose turn died on an API error retries by itself, a child run that switches accounts is never resumed twice, and the desktop app drops a dead server connection instead of showing cached data for minutes.

API errors: when a turn stops on an API outage, a timeout or a dropped connection, the run sends its own “continue” after 30 seconds, then 2 and 10 minutes, and says in the transcript that the retry was automatic. Three failures in a row stop the retries, and Stop cancels a pending one.
Accounts: a new run counts the runs already live on each account, so two runs started close together go to different accounts instead of sharing one usage window. A run you start on a named account stays on it. The rate-limit banner says the limit is per account on web, desktop, iOS and Android.
Child runs: a child run that its machine moves to another account tells its parent that it resumes itself and under which new id, instead of “ended without a report”. Resuming a run that is already live again under another id is refused and names that run.
Desktop connection: the desktop app and the CLI detect a dead server connection within seconds, rebuild their connection after repeated failures, on wake and on Retry, and log the cause of a failed request.

September 2026

Phone tabs follow your finger

2026-09-30

Issue, Run, Changes and Results on the phone drag like native tabs on web, iOS and Android, and the Changes tab shows the diff counts.

Dragging: the Issue, Run, Changes and Results faces of the phone’s Work screen move with your finger and settle on the neighbour, as a native pager on iOS and Android and as a slide on web. Tapping a tab animates the same way. Before, the face switched only after the swipe ended.
Changes counts: the Changes tab reads the diff’s added and removed line counts, as the desktop app does, once the run’s diff or the pull request’s files are known.
Styleguide: the face strip has its own entry, Work face tabs, so every client draws the same control.

API errors are not rate limits

2026-09-30

An API outage or dropped connection inside a run shows as a warning line in the transcript instead of a rate limit and never switches the account; the banners under the transcript sit in the reading column.

API errors: when the agent’s API times out, drops the connection or rejects a request, the run shows the error as a warning line where it happened. It no longer reads as a rate limit, no longer marks the run blocked and no longer resumes it on another account.
Banners: the rate-limit, paused, connection-lost and compaction banners under the transcript sit in the same centered column as the transcript rows on web, desktop, iPad and Android tablets.

Release train 2026-09-30

2026-09-30

Runs report on Results and notifications open them, tall screenshots and markdown attachments preview in-app, one stacking toast everywhere, yolo mode, a Tidy up action, editable pull request descriptions, and honest session tools for agents.

Results: a run’s close-out report sits beside its screenshots on the issue’s Results, visible to every member, and a notification an agent sends can open it directly. Runs publish screenshots of their visible changes by default. A tall screenshot shows a framed tile and opens a scrolling viewer; Android pinches to zoom.
Markdown attachments: .md files open in an in-app preview on the desktop app, iPhone and Android, with Download beside it.
Toasts: one stacking toast on every platform, bottom-right on a pointer and top-centre on touch, tap to expand, swipe to dismiss. Alerts that only informed became toasts; destructive actions still confirm.
Yolo mode: an owner switch under Settings › General. A pull request an agent opens merges at once, a follow-up tree merges root first once every run in it is done, and Reviews leaves the navigation unless a merge failed.
Tidy up: a built-in action for non-destructive board cleanup (duplicates, labels, relations), the one builtin an automation can run, with matching icons for stacks, batches and workflows.
Pull requests: agents update a pull request’s title or description with exponential_pr_update, and Reviews shows the description with Edit while it is open. A merge that GitHub answered with a server error after landing reads as merged, and an issue moved across boards mid-run still resolves.
Session tools: a failed remote start names its reason, a message reports whether the agent consumed it, queued messages reach the agent together, and a run you stop keeps its uncommitted work as a WIP commit on its branch.
Fixes: a signed-out default agent login no longer blocks a signed-in named profile, MCP credentials reach only the run that picked them, an invite to a still referenced placeholder binds and merges on accept, a sub-issue composed with an attachment leaves no draft behind, the desktop app’s Files and Source Control no longer flash “No repository linked” on cold start, stacked issue chips draw as outlines, and the web onboarding wizard shows who is signed in with a Sign out.

Issue, Run, Changes and Results are tabs on the phone

2026-09-30

The phone’s Work screen shows its faces as swipeable tabs in the header, with Merge beside them while the pull request is open, on web, iOS and Android.

Tabs: Issue, Run, Changes and Results sit in one segmented strip inside the header, under the title, the same control as the Inbox strip, listing only the faces the issue has. Tap one or swipe the body left or right to move between them. The bottom-right switcher circle is gone.
Runs: with several runs on an issue the strip reads Runs, and the run menu opens from it.
Merge beside the tabs: while the pull request is open, the Merge button sits next to the tabs on every face, so a run can be merged without leaving it. It left the properties card and the Changes bar.
Bars: the Issue face keeps Properties, Comment and Start coding; Changes keeps the file list; the Run face offers Start coding once a run has ended for good; Results has no bar.

2026-09-30

Settings › Account lists every way into your account: change your email with a code, link or unlink Google, Apple and OIDC logins, and manage passkeys, on web, desktop, iOS and Android.

One primary email: it starts as the address you registered with (the Google or Apple address for those sign-ups) and Change under Settings › Account swaps it for any other after a code sent to the new address. Sign-in codes, notifications and new mentions use it from then on; earlier @mentions keep the address they were written with.
Sign-in methods: Google, Apple and every OIDC provider your instance offers appear with Link or Unlink, a password row shows while one is set, and passkeys sit right below (moved back from Security, which keeps the API keys). Every method is optional, but the last way in can never be removed.
Natives: the same list on the desktop app, iPhone and Android. Linking runs through the browser as sign-in does and returns to the app; passkeys are still added from the web.
Admins: an email change never grants admin. INITIAL_ADMIN_EMAILS keeps promoting only the address an account registered and verified with.

Merging a stacked pull request asks first

2026-09-29

Merge on a pull request that belongs to a stack asks whether to merge the whole stack or this pull request only, on every client.

Stacked pull requests: the Merge button on the Changes face, the issue header and the run view asks first when the pull request is part of a stack with other open members. Merge stack lands every open pull request bottom-up; Merge this pull request lands it and the open ones below it, while the ones above stay open on the base branch. A pull request whose stack has nothing else open merges as before.
Agents: the result of exponential_pr_merge on a stack member names the pull requests it landed below and the ones it left open, and never lists an already merged one.

Release train 2026-09-29, evening

2026-09-29

Team MCP servers with one connect per member, invite links that survive the sign-in detour, chat runs named by Claude again, agent logins that sign out, and a desktop app whose Files and Source Control follow the active repository.

MCP servers: one list per team. Every member connects their own account once (Connect for OAuth, Set key for an API key) and the server keeps the credential encrypted, so every run on every machine, remote starts and automations use it; unconnected servers are skipped, never block a start. Owners add a server from a catalog or a pasted URL, the technical fields sit behind Advanced, and the per-device server lists are gone.
Invites: an invite link opened before signing in survives the detour: a cancelled or refused provider sign-in returns to the login page with the invite, a visitor who is already signed in goes straight on, and the invite accepts itself once you are back. Deleting a team also removes the invited placeholders it leaves behind.
Agent accounts: every agent login under a machine offers Sign out in its “…” menu on every client, and the machine’s own login can be removed too.
Chat runs: a chat run gets its name from Claude again.
Desktop app: Files and Source Control follow the repository you pick, the + shell opens in that repository, the edited-files card rows run edge to edge with a cleaner diff box, and Linux windows paint opaque instead of showing unblurred transparency on Wayland.

Sign agent accounts out

2026-09-29

Every agent login under a device has a Sign out entry in its menu, and the machine’s own login can be removed too.

Devices: every agent login listed under a machine offers Sign out in its “…” menu, on the web, in the desktop app and on iOS and Android. The machine’s own login (the one the CLI in your terminal uses) can now be removed as well: it is signed out there and hidden until it signs in again. Removing never touches the account itself. Update the desktop app or CLI on the machine to pick this up.

Release train 2026-09-29

2026-09-29

Start coding is always on an issue with a “Ready to code?” checklist that fixes what is missing, sub-issues and relations get their own bands, sign-up asks for your name, the CLI adds devices and sessions commands, and a new machine installs with one command.

Start coding: every issue shows Start coding on every client. When something is missing (GitHub, the board’s repository, an online machine) it opens a “Ready to code?” checklist with one fix per step, including picking the repository right there; the bulk bar, the Agent composer and Getting started use the same checklist.
Issues: a sub-issue names its parent above the title, sub-issues sit in their own band with a progress ring and a +, and every other relation folds into its own band. The stack, batch and runs badge shows on every face of a piece of work.
Sign-up: signing up with an email code asks for your name instead of guessing it from the address.
Devices: Add device shows an install command carrying a one-time token, so a new machine signs in, installs the daemon and turns on auto-update with one command. The CLI adds exponential devices and exponential sessions (list, show, log, message, kill) and starts runs on another machine with --device.
Desktop app and CLI: fetches and pushes that stall stop and clean up after themselves instead of hanging, account rotation probes each agent once per beat and keeps an account you picked, and workflow node tooltips always say what the node is.
Self-hosting: this release removes server support for iOS below 0.14.45, Android below 0.14.46 and desktop or CLI below 0.14.54. Set CLIENT_MIN_VERSION_* to those versions before upgrading (see selfhost/.env.example).

Release train 2026-09-28

2026-09-28

Plan-mode claude runs use their tools again, a run on an empty repository starts instead of hanging, the Recent runs panel has a back row, and phones wait for their issues instead of flashing an empty board.

Agent runs: a claude run in plan mode no longer falls into the auto-mode classifier that refused every tool call, because the desktop app and the CLI pin auto mode off for every run they launch (update the machine to pick it up). A run on an empty repository creates its first commit and starts instead of hanging.
Agent page: the Recent runs panel on the web and in the desktop app wears the back row every side panel does, and the history button hides while the panel is up.
Phones: after a fresh sign-in or a full resync a board shows a spinner until its issues arrive, instead of flashing “No issues yet” and the getting-started checklist, and the iPhone waits for its boards the same way.

Release train 2026-09-26, evening

2026-09-26

One merge control per pull request row, a workflow’s event log under its graph, a red dot for a run waiting on you, a refusal to start an issue twice, and a desktop app that logs and keeps its heartbeat.

Reviews: every pull request row carries exactly one control on every client: Merge for a plain pull request, Merge stack at the bottom of a stack, and a node’s pull request of a running or paused workflow says it merges through the workflow. The server refuses to merge such a node’s pull request by hand.
Workflows: a workflow whose final pull request was closed offers Open final PR on every client, the event log sits under the graph and a picked node shows only its own events, a review verdict and a skipped node write their own lines, and a review run started by hand nests under its node.
Agent runs: a run waiting on your answer wears a red dot, a workflow run on another account says which one, and a repeated failure logs once per distinct cause.
Starting a run: starting an issue or a batch that already has a live run says so instead of starting a second one, and an agent that asked for a run gets an error instead of a silent nothing. Unlinking the last blocker of a node that has not started makes it a proposal instead of a ready root.
Phones: the Run face scrolls to its newest rows again.
Desktop app: the heartbeat never stops silently, a run keeps its busy spinner while background agents work, an image seed posts one user message, a run started by an agent or a workflow lands in the sidebar instead of taking the screen, the sidebar scrollbars are slim and stay beside the rows, and the app writes a rotating log file next to its data.

Release train 2026-09-26

2026-09-26

The workflow page is rebuilt around its nodes, agent runs group under their workflow node, the blocks rail is dots with a hover graph, accounts rotate on their own, and the desktop app keeps its engine state in its own store.

Workflows: a chip strip along the top picks a node, and each node opens into Issue, Run, Changes and Results. A question the planner asks shows in a banner with an Answer for the owner, Pause and Dismiss sit in the overflow, the decisions log lists every answer, and the page keeps its face as you step through nodes. No workflow waits for a person to approve a node any more: an agent review gates it, and the planner asks its questions before a run starts.
Final pull request: a workflow’s final pull request is its own row under Reviews on every client, with Merge and Fix conflicts. A closed final pull request reopens once, and a workflow whose nodes all skipped cancels itself.
Agent runs: the running list, the recent sheet and the automations log group a workflow’s runs under their node with a status dot and a caption, review runs carry their titles, a run waiting on you wears a dot, and every run says which account it runs on. A workflow’s event log lists what the engine decided, one short line each.
Accounts: with account rotation on (the machine’s toggle, on by default), every claude launch picks the signed-in account with the most headroom, and a run that hits its limit resumes on another account on its own.
Issue lists: the blocks rail on the web and in the desktop app shows dots only, and hovering one opens the mini-graph, drawn on one geometry on every client. Phones keep the badge, and its graph draws on the same grid.
Work header: a stacked or batch run’s badge is the front issue’s chip with a count.
Editor: typing --- inserts a separator at once, and Escape closes the @, # and : menus inside a dialog.
Activity: estimate changes fold like every other field edit.
Desktop app: the workflow engine keeps its state in its own device store instead of settings.json, every writer to settings.json takes the lock, and a torn read never re-mints the device id.

Release train 2026-09-25

2026-09-25

One picker for every property on every client, the composer opens as a dialog, agent runs group by workflow and stack, workflow screens take their models from the machine, and issue lists select in bulk.

Pickers: status, assignee, labels, priority, board, issue, action, machine, account and icon all open the same picker on every client: a popover at the control on the web and the desktop app, a searchable sheet of plain rows on phones, with several picks shown as a highlight instead of a circle. Keyboard navigation of the assignee picker works from the first row, and Unassigned is searchable.
Start a run: on the web and the desktop app the composer opens as a dialog from an issue, a play button or an action, and stays open while a start is pending on the machine; a subjectless chat still opens the Agent page.
Agent runs: the running list nests a workflow’s runs under one row that opens the workflow and a stack’s runs under one row, each folded away by its chevron.
Workflows: the workflow screen drops its settings block; a new workflow takes its model pair from the runner machine’s Workflow settings (a model for leaves and subagents, a strong model for the contract, the integration, high-risk nodes and every review), a node reads its own state, and the final pull request merges from the screen. A resumed reviewer stays the node’s reviewer, is never spawned twice, and a refused verdict says what to do next.
Issue lists: rows select in bulk with a floating action bar on the board and beside an issue, and the due-date column collapses when no issue in the list has a due date. Ctrl-click opens the issue on Windows and Linux again.
Machine settings: the sheet is organised into pages, with a new Workflow settings page, and the API key section says what revoking a device’s key does: it disconnects the device’s coding runs, the device stays signed in.
Work header: the stack, batch and runs badge stands as tall as the controls beside it, the runs badge wears the workflow glyph, and the web shows it too.
Teams: the running list follows the active team, and the team switcher wears a dot when another team has one of your live runs (amber when it needs input).
Settings lists and members: every settings list on the web and in the desktop app follows one rule, the Linear import wizard is shorter and groups statuses across teams, and a roster member nobody has invited yet reads “Not invited” with a first Send invite, on every client.
Settings: shorter section copy on the web and in the desktop app.

The work header badge

2026-09-25

The stack, batch and runs badge in the work header stands as tall as the controls beside it, the runs badge wears the workflow glyph, and the web shows it too.

One height: the badge that says what a piece of work is part of (a stacked pull request, a batch, the runs around this one) now stands at the face toggle’s height beside Stop, Resume and Merge, on the web and in the desktop app, instead of a small chip next to tall controls.
Runs badge: on the Run face of a run that started or was started by other runs, the badge wears the workflow glyph instead of the robot, and the web shows it where only the desktop app did.
Styleguide: the badge and its popover have their own entry, with the glyph per relation and the rung it stands at.

2026-09-25

The issue context menu opens from every list, the sidebar and issue chips, no longer closes on its own, takes the estimate, and every web menu is tighter.

Everywhere: a right-click (or a long-press on a phone) opens the issue menu on a board row, the sidebar list beside an issue, a reviews row and any issue chip, with the same items in the same order.
Stays open: the menu no longer fires the item under the cursor when the right button is released a few pixels into it, which is what made it open and close in one go.
Estimate: the menu sets the estimate on the team’s scale, beside status, assignee, priority, labels and due date.
Menu density: menus on the web at desktop widths use tighter rows, matching the desktop app’s rhythm at the web’s text size; phones keep their touch-sized rows. The values are shared design tokens, shown in the styleguide with the issue context menu as its own entry.

Release train 2026-09-24

2026-09-24

The usage popover shows what fills a run’s context, owners add a team prompt to every run, machines update their agent CLIs remotely, and fixes for invited members and the Linear import.

Context window: the usage popover shows a segmented bar of what fills a run’s context, with a legend per segment (base, tools, playbook, team prompt, project instructions, task) on every client, and the account switch says why a switch is refused right where the control is.
Team prompt: owners write a prompt in Settings, General that every run on every member’s machine carries in its system prompt, on the web and in the desktop app.
Machines: the machine settings update the Claude and Codex CLIs remotely and show each login’s version, on the web and in the desktop app.
Sidebar: one look for the sidebar sections on the web and the desktop app, with the What’s new card floating above the footer.
Workflows: the node strip reuses the work face toggle, and the MCP workflows update takes the runner machine so an agent can bind it.
Invited members: an invite can no longer seat another team’s invited member or move their address, an existing member who opens a colleague’s invite link is not merged into it, invited members count once against the seats, signing in with Google, Apple or an identity provider claims the invite, and the invite page welcomes the person instead of calling the link used.
Linear import: cancelling holds against a finishing discovery, attachments stream with a size cap and a timeout, bundle attachments are checked against private addresses, duplicates keep their target, and finished imports drop their snapshot after a week.

Import from Linear

2026-09-23

Bring a Linear workspace into a team from Settings, with its issues, comments, images, labels, statuses, relations and estimates, keeping identifiers and dates.

Import from Linear: a new owner-only Settings section connects to Linear with a personal API key, previews what it found, lets you map teams to boards, statuses onto yours, labels and members, dry-runs the plan and then imports. Issues keep their identifiers, timestamps, priorities, assignees and comments; inline images are rehosted; activity history is optional.
Relations come along: sub-issues, blocking, duplicate and related links are recreated between imported issues.
Members before they sign in: an email invite puts the person on the team at once, with their name, so issues and comments can be theirs before they ever sign in; when they do, everything carries over. The Linear import invites a workspace’s members straight from its member mapping, and the Members settings show who has not joined yet, with a way to resend the invite.
Archived issues: an option puts a source’s archived issues on a separate board per team, archived once the import is through, or leaves them out.
Estimates: a team setting picks an estimate scale (exponential, fibonacci, linear or t-shirt sizes), off by default. With one on, issues take an estimate from their properties row on every client, over the API and the agent tools; a Linear import brings its estimates and switches the matching scale on.
Settings: a new Issues section holds the estimate scale and the pull request automation, with Labels and Statuses as its sub-pages, on the web and in the desktop app alike.
Resumable and repeatable: an import that stops resumes where it left off, and running it again adds nothing twice.
Bundles: the same importer accepts a provider-neutral bundle over the API, so other trackers can follow without a new code path.

Release train 2026-09-23

2026-09-23

Automations pick an account, the issue list shows its blocking arrows as a rail, and a round of fixes for the desktop app and the CLI.

Automations: the editor picks an account on the bound machine, with its brand mark and email, instead of an agent alone, on every client. A machine switch re-seeds the pick from the new machine.
Blocking arrows: on wide screens the issue list draws its blocks relations as a rail at the right edge, with a dot per node at rest, the arrows on hover or keyboard focus, and the mini graph on click. Phones keep the badge.
Tree lines: nested issues draw a tighter corner and one unbroken vertical where a later sibling follows, on every client.
Desktop and CLI: a workflow node keeps its identity across an account switch or a resume, the remote sign-in dialog takes the code from the browser again, and the Agent entry no longer duplicates the Running section’s dot.
MCP: merging a plain pull request based on your default branch no longer reports it as a stacked merge.

Release train 2026-09-22

2026-09-22

One account picker with live limits, a calmer issue activity, MCP servers per machine, and workflows that are always reviewed by an agent.

Accounts: the composer has one account picker across Claude and Codex with each login’s limits inline, a default account per machine, and every login is named by its email, signed out ones included.
Activity: an issue’s activity folds quick back and forth edits into their net change, and Show all brings every event back.
Runs: tool calls to Exponential show the issues, runs and pull requests they touched as chips with a preview, resumed runs sit behind one run menu, the GitHub button lives on Changes, and phones show the changed line counts.
Search: open work ranks above done work, the same way on every client and over MCP.
MCP servers per machine: a machine can carry its own MCP servers, picked up from your Claude and Codex config in the desktop app or the CLI, and they ride every run there. Entries that carry a secret are never imported.
MCP tools: agents can list an issue’s attachments, upload large files through a signed link, and compact their own session.
Workflows: every node is reviewed by an agent before it lands, the review gate setting is gone, and a pull request merged outside the workflow lands where its code actually is.
Fixes: the link field in the create issue dialog takes focus again, uploaded files no longer show zero bytes, markdown attachments preview in the app, and the comment edit button has its icon back.

Release train 2026-09-21

2026-09-21

A clearer workflow graph with live-run markers, a model per workflow phase, and a workflow that no longer stalls on a merge made outside of it.

Workflow graph: nodes are circles in their state’s ring, edges gather into one bus between the waves, a node whose run is live wears that run’s own dot, and a Running now strip opens each live run in one tap on every client.
A model per phase: a workflow runs its contract, integration and high risk nodes on their own models; new workflows start on the shipped split, and an edit from a phone or an older app keeps the picks.
Workflows that keep moving: a node whose pull request was merged outside the workflow lands instead of blocking it, also while its run is still open, a failed start is retried once and then waits for you, and git network calls run under a deadline. Node budgets and the paused node state are gone.
Self-hosting: the published image sends its security headers by default, without pinning your sibling subdomains to https and with room for your identity provider’s avatars.
Android: the Drafts tab shows again on Inbox and My Issues, also on devices that had already lost it.

Release train 2026-09-19

2026-09-19

Workflows ship on every client, the phone tab bar keeps its Agents and New issue buttons, and a round of fixes from the release review.

Workflows: plan a set of backlog issues as one dependency graph, let a device run them in parallel with a merge train and a review gate, and follow it from the web, the desktop app, iOS and Android.
Phones: the tab bar shows the Agents and New issue buttons on every tab, the Agent page keeps past runs behind a history button, and the board switcher lists teams and boards only.
Review fixes: a workflow dependent can no longer be merged into your default branch behind the final pull request, a node’s approval is bound to the reviewer run and the commit it reviewed, the metrics beat is recorded again, a skipped node’s issue no longer moves to done with the final pull request, and a stacked start refuses a blocking cycle that runs through a closed issue.
Cleanup: batch runs are named from their stored issue list on every client (older runs were backfilled), the staleness sweep only deletes runs whose machine is gone, and retired external-agent run records are dropped when the desktop app or CLI loads them.

Workflows review themselves, grow while they run, and keep to a budget

2026-09-19

An agent review gate backed by real checks, follow-up issues that join a running workflow, per-node budgets and a metrics section.

Agent review: with the Agent review gate every pull request of a workflow is reviewed by a separate run that never sees the author’s reasoning. It reads the issue and the diff, runs the tests, and says what is wrong and where. An approval counts only when the checks it ran passed; otherwise it is advice and you still approve. High risk nodes get an adversarial reviewer on a different model. After three rounds without agreement the node waits for you, and the contract always does.
Workflows that grow: a follow-up issue a run files and links behind its own work joins the running workflow by itself. One that would change what existing nodes wait for shows up dashed as a proposal you admit or dismiss.
Budgets: give a node a limit in minutes or tokens. A run that goes over is paused, you get a notification, and Retry picks it up again.
Metrics: every started workflow shows how deep its critical path is for its size, how many merge-ins a contract change caused, how often runs escalated and how many of those were duplicates, the minutes it waited for you, and how many defects the checks found compared to the agent review.

Workflows start dependents early and keep them in step

2026-09-19

Dependent runs start as soon as their blockers publish a contract, upstream changes are merged in automatically, and colliding siblings are put in order.

Start on contract: with the default start mode a node pushes its contract first (types, stubs and tests) and announces it; everything that depends on it starts right away instead of waiting for the whole pull request. On PR open and When landed stay available as the careful settings.
Branches shaped like the graph: a node with one open blocker builds on that blocker’s branch, a node with several builds on a merge of them that the engine prepares, so every pull request shows only its own work.
Upstream moved: when a blocker pushes again, its dependents are told between turns to merge the change in, with a short note of what changed. Nothing is ever rebased or force-pushed, and a real conflict has exactly one owner.
Collisions become order: when two parallel nodes touch the same code, the later one merges the other in first and the graph shows a dashed edge between them.
Edges tell you more: dashed means a dependent started early, red means upstream moved and the dependent is catching up, green means landed.
Landing: pull requests still land strictly in dependency order, and a dependent whose last blocker landed moves its pull request onto the workflow branch by itself.
Asking upstream: a run can ask the run it builds on to change what it handed over; a disagreement about an interface always comes to you.

Workflows run: parallel coding runs with a merge train

2026-09-19

Start a planned workflow and your device runs its issues in parallel, lands reviewed pull requests in order and opens one final pull request with the whole diff.

Start a workflow: a draft with a runner device and no loop can be started. The device’s engine, not an agent, starts every unblocked issue as its own coding run (up to your max parallel), and starts the next ones as their blockers land. Pause, resume and cancel are on the workflow; cancelling ends its runs and deletes its one branch, and nothing reached your default branch.
Merge train: pull requests land into the workflow’s own branch in order. The contract always waits for a person, and with a review gate every node does: open the node and choose Approve and land. A pull request that no longer merges is sent back to its run to merge the branch in, never rebased and never force-pushed.
Final pull request: once everything landed, one pull request from the workflow’s branch to your default branch carries the whole diff, lists every node and names a few at random to audit in full. Your issues move to done when that pull request merges, not before.
When a run needs you: a node that waits for an answer or hit a rate limit turns amber, the only amber state, and resumes on its own after a reset. A run’s question must come with a proposal you can answer with yes or no, the same question is asked once per workflow, and every decision is kept and given to the runs that start later.
Stuck nodes: a node whose run ended without a pull request is retried once, then marked failed with Retry and Skip.

Workflows: plan a set of issues as one parallel run

2026-09-19

Select backlog issues, create a workflow, and see them as a dependency graph your agent can plan; plus a subagent model option for every Claude run.

Workflows: a new Workflows entry (on phones: a button on the Agent page) lists your team’s workflows in Running, Draft and Done. A workflow is a set of backlog issues of one repository drawn as a graph: what blocks what runs left to right in waves, a parent with its sub-issues is one stacked card, and a loop shows in red with the issues named.
Create workflow: the Start coding button of a selection is now a menu: Start as batch, Start as stack, or Create workflow.
Plan: the Plan button lets your agent shape a draft. It files one contract issue everything builds against, keeps your issues as parallel leaves, adds an integration issue at the end, and marks risk and the files each issue will touch.
How it runs: each draft keeps its runner device, agent, model, effort, account, how many runs may go at once, the review gate and when dependents start. Running a workflow arrives with the next update.
Subagent model: every Claude run can now pick the model its subagents use, next to Model and Effort, and the choice is remembered per device.

Sub-issues and blockers show in every issue list

2026-09-19

Sub-issues nest under their parent, a badge counts what blocks an issue and opens the dependency graph, a blocked start shows the whole chain, and a run that hits a rate limit notifies you.

Sub-issues in lists: on every client a sub-issue sits under its parent on a connector line, in the board list, My Issues and the list beside an open issue. The parent decides the group and the position, so a finished sub-issue stays with its open parent.
Blockers at a glance: a row that is blocked, or that blocks other open work, carries one small badge with the counts. Opening it draws the dependency graph: what has to land first on the left, what waits on the right, a cycle in red. The badge on an issue’s header shows the same graph.
No more cycles: linking issues as blocking or as parent and sub-issue is refused when it would close a loop of any length, and the message spells the loop out.
Blocked starts: starting a blocked issue shows the whole chain instead of the direct blockers only, a batch asks too when something outside it is in the way, and when a stacked PR is not possible the button stays visible and says why. Resuming a run never asks.
Rate limit alerts: when any of your coding runs hits a rate limit you get a push and an inbox row that opens the run. Turn it off under notification settings, Blocked runs.

2026-09-19

Live runs sit in a Running section of the sidebar with their agent’s mark, the Agent page is a clean composer with Recent behind a history button, nested lists draw a connector, and a compacting run no longer swallows a queued message.

Running in the sidebar: on the web and the desktop app your live runs list under the boards in a Running section, each with the Claude or Codex mark, a yellow badge when the agent needs input, the issue number and title, and the host device’s icon on the right (hover it for the name); the compact rail shows only the marks. A live run no longer opens a top tab: it highlights in the sidebar, an issue tab you already had stays and highlights with it, and a run that ends by merging its PR closes its tab.
A clean Agent page: the composer stands alone; the history button in the top left slides in the Recent runs as a plain list. On phones the same button sits top right in the header and opens a Recent sheet; Recent is never folded anywhere anymore.
Nested lists: child runs and stacked pull requests hang off their parent on a connector line on every client, in the sidebar, the Agent page, Reviews and the run’s stack overlay.
Plan cards: a plan the agent wrote to a file shows in full on every client again instead of just “Ready to code?”.
Account switch: after switching a run’s account the agent picks its work back up on its own, and iOS and Android stay on the run instead of dropping to the list.
Compaction: a message sent while the agent compacts its context is delivered once the compaction ends, even when the end never announces itself.
Usage: a login’s usage refreshes once a window has reset, at least every six hours, and a refresh after a reset fetches fresh numbers instead of the pinned reading.
Edits stick: leaving an issue right after typing its title (desktop) or description (web) and coming straight back shows what you typed, never the old text.
Phones: the chat and New issue split button shows on every tab, and Android names a stacked run’s issues from the same data the stack is built from.

No Pinned group in the phone board switcher

2026-09-19

The board switcher on iOS and Android lists teams and boards only; pins stay a sidebar feature on the web and the desktop app.

Board switcher: the Pinned group at the top of the switcher sheet is gone on iOS and Android. A pin belongs to a sidebar, and the phone has none: pins are made and opened on the web and the desktop app, where the sidebar shows them.

Release train 2026-09-18

2026-09-18

Device icons, the run’s task list, one picker everywhere, and a round of fixes from the release review.

Device icons: every machine can carry its own icon, and the board and action picker grows to 96 icons.
The run’s task list: the strip under a run leads with the agent’s own task list, a background lane keeps its tab while it runs, and calls to Exponential group as “Read 3 issues” instead of a generic tool run.
One picker: every picker on the web opens the same searchable menu, and the keyboard works in every one of them again, including the status, priority, effort, model and device menus and the phone’s issue search.
Runs: several runs on one issue fold behind a caret on the Runs tab, an empty task list clears instead of sticking, and a turn that changed no file no longer shows an empty edits card.
Phones: the Work screen’s menu sits on the Issue face only, Stop and Resume are plain bar buttons, the face switcher counts the run’s changed files and tucks into the composer, and a batch run’s issues open in a sheet.
Devices: machines fold to one row each, usage windows say when they reset, and a login can be removed from a machine.
Under the hood: the transcript no longer re-parses every patch per frame on the desktop, iOS and Android, a stray invisible character can no longer leak from the desktop editor into a description, and typing with an IME no longer sends a message mid-composition.

Device icons and 36 more board icons

2026-09-18

Give each machine its own icon, from a desktop, server or laptop to the Apple, Windows and Linux marks, and pick from 96 icons for boards and actions.

Device icons: the device settings carry an icon picker next to the name, on web, desktop, iOS and Android. Choose a monitor, a server, a laptop or the Apple, Windows or Linux mark; the pick shows on the devices list and in every device picker, for you and for teammates who see a shared server.
Defaults stay: a machine you never touched keeps what it had, the monitor for a desktop app and the server for a CLI daemon.
More icons: the board and action icon picker grows from 60 to 96 icons, with music, camera, gift, store, truck, map, mountain, flame, crown, brain, fingerprint, wallet, smartphone and more.

One picker, one search field, one date picker

2026-09-18

Every picker on the web now looks and behaves the same, search fields carry a glyph and a clear button, and the styleguide sorts into Views, Components and Style.

One picker: assignee, board, labels, actions, branches, MCP servers, automation filters and the batch issue picker share a single searchable picker. A picked row shows a trailing check; in a multi-select every row carries the same filled or empty circle the iOS and Android sheets draw, and “Unassign” or “None” is a real row instead of a hidden placeholder value. The issue row’s right-click submenus and the bulk bar draw the same rows: the bulk bar now marks what the whole selection already has, and a label on only some of the selected issues shows a circled minus. The status and priority menus, the settings rows (delivery, timezone, transport, the automation schedule), the device, model, repository and account words under the composer, the issue search and the GitHub repository list are the same picker too, so the status you have is checked in its menu on the desktop as well.
Search fields: the Reviews file filter, the emoji search and the issue search sheet are one field with the search glyph inside it and a clear button that appears once you type, the same field iOS and Android already had.
Due dates: the three date pickers on the issue page, the editor chips and the phone properties tray are one calendar popover, and a date never shifts by a day west of Greenwich anymore.
Autocomplete: the @, #, : and / menus under the composers share one keyboard model: arrows wrap, Enter or Tab picks, Cmd or Ctrl plus Enter still sends. The menu that follows the caret inside the description editor is the same surface as the composers’ now.
Styleguide: a top bar switches between Views (the screenshots), Components (the live controls, grouped by kind) and Style (colours, shape, type, motion and the icon registry). Each component names which app surfaces still draw it by hand. The description editor’s formatting rail and its link field are the same ghost buttons and text field as everywhere else. The composer card, the phone work bar, the work header, the context ring, the agent picker, the brand marks, the emoji picker, the lightbox and the results tiles now live in the shared component package with the rest, so the styleguide renders each one live, and the emoji picker’s cells and empty line are the same button and empty state as everywhere else. The small shapes followed: count badges, the fold headers in a run’s conversation, the dashed “describe one” nudge on the actions page, the floating circles in the phone bars, the compact sidebar rows, posted images and the “Show more” links are one component each now, so they look and behave identically wherever they turn up.
Desktop: the IDE draws the same set. Text fields wear the field’s 12px corner instead of the row’s 10. The diff pane’s file filter, the emoji, issue and branch searches, the repository lookup and the search dialog are one search field with the glyph inside and a clear circle that appears once you type. The label and board pickers and the MCP server picker are one searchable picker with the same marks as the web and the phones: a trailing check for a single pick, the filled or empty circle for a multi. The run conversation’s tool groups, Exponential calls, subagent lanes and workflow agents fold on one header that brightens under the pointer; “Show more” and the edited-files footer are one text button; the rail’s Drafts entry carries its count in the same small capsule the web shows. The @, # and : menus in the editors and the composer, and the / menu over the run composer, are one menu now, and it opens above the caret when the window runs out of room below. A run that is working ripples its green dot like the web does; the loading bars on Drafts, Reviews and a support ticket, the bulk-select boxes in the issue list and the rail, and the checklist boxes in a description are the same shapes as on the web.

Release train 2026-09-17

2026-09-17

Every diff reads the same, tabs keep what you typed, issue search is one engine on every client, and the Devices page holds your logins and usage.

One diff design: a review, a run’s changes and the transcript draw the same file card on all four clients, a run’s edits collect into one card in the conversation, and the file list beside a diff is a folder tree with counts and a filter.
Tabs keep their state: on the web and the desktop app a half-typed comment, an open reply box and the scroll position come back when you return to a work tab, and a chat run carries the title the agent gave it.
One issue search: every picker, the # autocomplete and the search sheet rank issues the same way on web, desktop, iOS and Android, with the top row preselected and Enter or Tab to pick. The desktop search sheet finds issues only now; files stay in the Files rail.
Accounts and usage: the context ring opens one usage view that names the account a run spends, the Devices page lists each machine’s logins with their usage in place, and idle runs no longer pin a stale rate-limit reading.
Runs that are still there stay: the crash sweep no longer deletes a run whose transcript still exists on its device, and the issue page keeps a run’s diff after the merge.
Merge and conflicts: a merge refused by a real conflict turns the Merge PR button into Fix conflicts wherever you clicked it, and the Merge PR pill sits on the small phone rung too.
Desktop app: Back returns where you came from, the sidebar list no longer re-derives every row per frame, the terminal copies and pastes, and long chips and diff headers no longer overlap.
Web: every page has a title, and the composers share one attachment thumbnail and one floating-bar chrome.

Tabs keep their state, chats get their names

2026-09-17

Switching work tabs no longer drops a half-typed comment, a live run’s tab no longer cuts its label off, and a chat run is named after what the agent called it.

Tabs keep what you typed: on the web and the desktop app, a comment or reply you started, the reply box you opened and how far you had scrolled come back when you return to the tab. Closing the tab forgets them.
Room on the right: a live run’s tab has no close button, so its label now gets the same padding on both sides instead of touching the edge, on the web and the desktop app alike.
Chats named by the agent: a chat run shows the title Claude Code or codex gave the conversation instead of “Chat”, in every session list, tab and review row on the web, the desktop app, iOS and Android. Renaming it in the agent renames it here.

One diff design, everywhere

2026-09-17

Every diff in Exponential is now built from the same file card, the files a run edits appear in the transcript itself, and the file list beside a diff is a tree.

One file card: a review, a run’s changes and a transcript all draw the same card now, with the same header, the same counts and the same way to open the lines it hides. Cards start open, so a diff reads top to bottom without a click.
Edits in the transcript: the files a run touches in a row are collected into one “N files edited” card in the conversation, with the file it is writing right now open and the rest a tap away. No jumping to another screen to see what changed.
A file tree: the list beside a diff is a tree of folders now, with the counts per folder, a filter, and long folder chains folded into one line. On a review it sits in the sidebar, where every other page keeps its context.
Reviews polish: a review’s header says which issue it is, how big the diff is and what the pull request’s state is, with reject, Merge PR and the GitHub link beside it. Batch rows in the review queue no longer lose their first column. On phones the floating bottom bar is now the same on web, iOS and Android: one geometry, no drop shadow, and Merge PR is one white pill centred between the circles, on a review and on a run’s changes alike.

Accounts and usage

2026-09-17

One usage view on every client that names the account a run is on, shows that account’s numbers, keeps them current, and lists each device’s logins in place.

One usage overlay: the context ring opens the same view on web, desktop, iOS and Android: the run’s own account at the top with its three rate-limit windows, the context window below, and every other account on that machine as a compact row with a switch button beside it instead of across it.
The right account: the overlay names the login the run actually spends, so a run started on a second account no longer wears the default account’s name or its re-login badge.
Numbers that move: an idle run no longer pins its last rate-limit reading, a window that has reset re-reads within a heartbeat, opening the overlay asks the machine for a fresh read, and an account nobody ran for days refreshes its own token to report instead of showing days-old numbers.
Devices list their logins: the Devices page lists each machine’s accounts under the machine, with the same compact usage line and one menu per login, in place of the separate Accounts section, its tabs and its chips.

Fix conflicts, on every Merge button

2026-09-16

A merge refused by a real conflict now turns the Merge PR button into Fix conflicts wherever you clicked it, instead of only showing an error.

The swap works everywhere: on the web the issue header, the run header, the Changes faces and the review page all showed an error notification on a conflict and kept the plain Merge PR button. They now swap it for Fix conflicts with a Retry merge beside it, like the Reviews list always did.
Desktop app: a batch or chat run’s header and its Changes bar make the same swap, and a merge refused for any other reason now shows its message under the button instead of only in the log.
iOS: merging a stack from the overlay on the Work screen reports a refusal instead of silently doing nothing.

Release train 2026-09-16

2026-09-16

The phone gets one Work screen, every diff reads the same, pull requests can be stacked and merged as a chain, and a run can publish its results.

The phone Work screen: an issue, its coding run, the changes and the results are faces of one screen on iOS, Android and the mobile web, switched from a bar at the bottom, with Stop or Resume in the top-right corner.
One diff view: every diff reads the same on all four clients now, with one palette and one set of line numbers, unchanged lines you can open around a change, and renamed, copied and binary files named instead of shown empty.
Stacked pull requests: an issue blocked by another can be started on top of it, the review queue nests the chain and offers Merge stack on the bottom of it, a badge says which stack or batch a piece of work belongs to, and every run list nests a run under the one that started it.
Results from a run: a run that publishes screenshots gains a Results face beside Issue, Run and Changes, grouped by topic with one labelled tile per platform.
Batch runs by name: a run covering several issues now reads EXP-874 +2 beside the first issue’s title instead of “Batch run”, in every session list and in its own header.
Drafts: an issue you start and do not finish is kept as a draft, attachments included, and reopens where you left it.
Session history stays on your machine: finished runs keep their transcripts for as long as the desktop app’s new Sessions setting says, and an issue with several runs of yours gets a picker to switch between them.
Under the hood: the web app, the styleguide and the marketing demos now share one component library, so cards, menus and glyphs read the same everywhere, and a Claude login refreshes itself in the background instead of expiring mid-run.

Batch runs say what they are working on

2026-09-16

A run covering several issues is now named after them instead of reading “Batch run”, so two batches can be told apart at a glance.

Named by its issues: a batch run’s row reads EXP-874 +2 beside the first issue’s title, in every session list and in the run’s own header, on the web, the desktop app, iOS and Android.
Right from the start: the issues a batch covers are recorded when it launches, so the name is correct while it is still coding, not only once its pull request is open. Older batch runs take their name from the issues on their pull request.

Results, right on the run

2026-09-16

A coding run can now publish screenshots of what it built, grouped by topic and labelled per platform, as a Results face beside Issue, Run and Changes on every client.

A fourth face: when a run has published pictures, the header toggle gains Results next to Issue, Run and Changes, on the web, the desktop app, iOS and Android.
Grouped by topic: pictures sit under the topic the agent filed them in, one row of equal-height tiles with a label under each, so an iOS, Android and web shot of the same screen read side by side. Tap one to see it full size.
The agent publishes them: a run asks Exponential for an upload link, uploads the screenshot with one command, and can replace or remove a picture later. The playbook every run gets now asks for a screenshot of UI work before it finishes.

Stacked pull requests

2026-09-16

An issue blocked by another can now be started on top of it: one pull request based on the other, merged together, with the stack visible everywhere the work is.

Start on top of a blocker: starting an issue that something else blocks now asks whether to start anyway or open a stacked pull request. A stacked run cuts its branch from the blocker’s branch, so its diff shows only its own work, and it builds the blocker first if nobody has.
Merge the whole stack: the review queue nests a stacked pull request under the one it is based on, says which one that is, and offers Merge stack on the bottom of the chain. Merging a stacked pull request through Exponential works again on GitHub, where it used to be refused outright.
A badge for related work: an issue, its run and its changes carry one small badge saying whether they are part of a stack or of a batch pull request. Hover it (or tap it on a phone) to see the blockers, the issues sharing the pull request, and the runs a run started.
Every run list nests: a run started by another run now sits under it in every list, with a twisty to fold the whole branch away, on the web, the desktop app, iOS and Android.
Questions reach you: a run several levels deep can hand a question to the person instead of to the run above it. It lands in your inbox and on the run you are watching.

One diff view

2026-09-15

Every diff in Exponential now reads the same, on the web, the desktop app, iOS and Android: the same colours, the same line numbers, the same way to open the unchanged lines around a change.

The same diff everywhere: a pull request’s files, a run’s changes and the edit cards in a transcript all render through one diff view now, with one shared palette and one set of line numbers.
Unchanged lines on request: the gap above and between changes says how many lines it hides, and opens them where you want to read around an edit.
Renames, copies and binaries: a renamed or copied file names where it came from, and a binary file says so instead of showing an empty body.
Cut output is marked: when a run’s tool output or diff is too long to send whole, the transcript says how many lines were dropped rather than ending mid line.

The issue and its run, one screen on your phone

2026-09-15

iOS, Android and the mobile web get the desktop’s unified issue and session view: one header, Issue, Run and Changes as faces of one screen, and a floating bar that switches between them.

One screen, three faces: an issue, its coding run and the run’s changes are one screen now. The header never jumps, and the bottom-right circle switches between the faces; with several places to go it opens a menu above itself, with several runs of yours one row per run.
Stop and Resume up top: while you look at the run, Stop (or Resume once it ended) sits in the top-right corner, where the old Watch button and the usage menu used to be.
The composer matches the desktop: the run’s reply box shows the plan-mode word, the attach button, the model picker and a small usage ring that opens the usage sheet.
Changes as a page: the run’s diff, or the issue’s open pull request, is a full page with the GitHub link and Merge PR in the bar, instead of a floating bar over the transcript.
Simpler session lists: the Agent page’s rows no longer carry Merge and open-issue buttons on any client; tapping a row opens the run.

Session history that stays

2026-09-15

Finished runs stay on your machine as long as you like, and an issue with several runs lets you switch between them.

Kept on your machine: transcripts and resume records of finished runs are no longer deleted after 60 and 10 days. They live only on the machine that ran them, never on our servers.
Sessions setting: the desktop app’s new Settings → Sessions page picks how long that history is kept: unlimited by default, or 1 year, 90 days or 30 days.
Switching runs: when an issue has more than one run of yours, its Run toggle reads Runs and the run’s page gets a picker that opens any of them, the live one included.
Recent: the Agent page’s Past band is now called Recent and shows your 20 latest runs.

One header for an issue and its run

2026-09-14

An issue and its coding run now share one header, the diff opens full page, run lists look the same everywhere, and typing in the desktop app is faster.

One work header: the Issue and Run faces of a tab share the same title block and header, and the issue’s properties sit in a tray beside the run.
Full-page diff: a run’s changes open as their own face in the tab instead of a side pane.
A lighter composer: the steer composer is one row with an inline send, the context meter sits in it and opens usage and account switching, and the model the run uses is shown and switchable there.
Runs grouped by agent: live run tabs group under their agent, a live run’s tab stays open until the run ends, and a run whose machine went offline can be closed.
The same run rows everywhere: running and past runs read the same in the Agent list, on the Agent page and under Automations, with Merge and Open issue right on the row.
Faster typing on desktop: the issue picker, the description editor and the sidebar no longer redo work on every keystroke.
Phones: an ended run can be resumed from the run page, and a run links back to its issue.

2026-09-13

Opening an issue from a list folds the sidebar into an icon rail instead of replacing it, an issue and its coding run share one tab, and every run you have going always has a tab, on the desktop app and the web.

The rail stays: opening an issue, a run or Settings from a list slides that list in beside an icon rail, so Inbox, Agent, your boards and pinned items stay one click away. Back slides the other way.
One tab per piece of work: an issue and its coding run are one tab with an Issue and Run switch in the header, and a run without an issue gets a tab of its own. The web now has tabs too.
Runs always have a tab: every run you have going gets a tab at the front of the strip, with a spinner while the agent works, amber when it waits on you and green once its PR is open. Close one and it stays closed until the run needs you again.
Pinned items open in place: a pinned issue, run or action opens full width without swapping the sidebar.
The list opens every time: on the desktop app, the first issue you open after launch or after switching teams now opens beside its board list.
The same sidebar on both: the team switcher stays at the top on the web too, the back row is the same size on both, Agent shows how many runs are going, and the web team menu gains Join team.

Messages that wait their turn, Stop that reaches the machine, and one session header

2026-09-13

A message sent while the agent is working waits in a Queued bar until the turn ends, Stop from the web and the phone now interrupts the run, the desktop session header and usage sheet match the web, the sidebar issue list gets bulk edits, and a run that switched accounts no longer stays marked rate limited.

Queued messages: send while the agent is still working or compacting and the message waits in a Queued bar above the composer, on web, desktop, iOS and Android. Its × removes it from the queue, an empty draft takes the text back, and Stop drops the queue with the turn. The message shows in the transcript the moment the agent takes it.
Stop reaches the machine: Stop pressed on the web or the phone now interrupts the running turn on the machine. Every client had been sending it; the relay was dropping it.
One session header: the desktop session header lost its Back button, centers the run’s identity like the web, carries a quieter Plan chip and the web’s usage and open-issue icons, and the issue band is the real issue header with Open issue in the Watch slot.
One usage sheet: the usage overlay has the same structure on web and desktop: the active account once, Context, the windows, the other accounts, and one footer note.
A sidebar header that stays put: the team switcher, Search and New issue sit fixed above the sliding pane, pinned rows unpin on hover, and the sidebar issue list gets batch selection with a bulk bar, the row context menu and inline status.
Switching accounts clears the wall: a run ended by an account switch no longer keeps Rate limited on its row for good, and a resumed run no longer re-arms a rate limit from its replayed transcript.

A quieter interface: ghost buttons, pickers that show what they pick, and settings that flatten out

2026-09-12

Secondary buttons lose their circles, agent and device pickers carry icons, the Agent page holds the running and past runs, board settings get a page each, API keys became Security, and issue filters are gone.

Circles mean the main action: only the one action a surface is for keeps a round button: start a run, send, New issue, Search, add. Everything secondary is a plain glyph that fills on hover, including the … menus, close, folder and file toggles, chevrons, remove and refresh. Back is that same quiet button in the same place on every screen, and a back row in a list or in settings is the whole row.
Pickers that show what they pick: the agent picker is one control everywhere, showing the Claude Code or Codex mark on the button and both the mark and the name in its menu. Device pickers lead with a laptop or a server icon, and every menu whose value carries an icon now shows that icon on its options too.
The Agent page is the composer: the runs that are going sit in a band above the prompt, past runs are folded behind a count you can open, and with nothing running the prompt sits in the middle of the page instead of at the top.
Device settings hold settings: the dialog is the device name, your default device, team sharing and the per-agent defaults, and it opens at the size of its content. Signing in and choosing which account the device uses moved onto the account chips, where the account is.
Add, switch and remove an account: Add account sits in the Accounts header next to Add device, and an account chip offers exactly what applies to it: Sign in when it is signed out, Set as default, or Remove account. Removing clears that login from that one device; the account itself is untouched.
Security: the API keys settings page is now Security and holds your API keys and your passkeys, which moved off the Account page. Old links land there on their own.
A settings page per board: team settings list your boards one by one, the way the desktop app already did. Each board is its own page, with New board under the list and Archived boards after it.
Changes you can size and scope: the diff pane drags wider and remembers its width, and opening a file or an edit from the transcript scopes it to that turn, with one click back to the whole branch.
Status headers in the sidebar: the board and My issues lists in the sidebar group under the same status bands as the full list: the status glyph, its name, a count, and a click to fold.
Automated runs together: opening a finished automated run shows the other automated runs beside it, and Back returns to Automations.
Issue filters are gone: the filter bar left the board and the inbox on web, desktop, iOS and Android. Search covers what it was mostly used for, and grouping, sorting and the status bands stay.
External agents are gone: the desktop app and the CLI no longer run an arbitrary ACP binary. Claude Code and Codex are the agents; a recorded run that used an external one cannot be resumed, so start a new run instead.

2026-09-12

Continue with email now creates your account on Exponential Cloud, pin buttons are gone from iOS, Android and the phone-width web app, Android’s Accounts and Devices pages match the other clients, and a retired agent never shows up again.

Sign up with email: on Exponential Cloud, Continue with email creates an account for a new address the moment you enter the code. Until today a new address silently got no mail, because only Google and Apple could create accounts.
No pin buttons where there is no sidebar: iOS, Android and the phone-width web app no longer offer Pin on issues, sessions and actions. Pins made on the desktop or the wide web app still show in the board switcher’s Pinned group.
Accounts and Devices on Android: the Accounts page keeps only quiet machine chips (an online dot, a check on the active login). Signing in, re-login and “use this account here” moved to the machine row under Devices, as on web, desktop and iOS. On iOS a machine chip now offers the right repair: re-login for an expired login, use this account here for one the machine is not using.
Retired agents stay gone: a machine still on an older build that reports the removed pi agent no longer produces a row, a tab or a picker entry anywhere. The server strips it from every heartbeat and the stored device data was cleaned up.

Continue with email, or with a passkey

2026-09-12

The login screen is one list of Continue buttons: Apple, Google, email with a one-time code instead of a password, and passkeys, on web, desktop, iOS and Android.

One screen, one verb: signing in and creating an account are the same tap. Every option reads Continue with Apple, Continue with Google, Continue with email or Login with passkey, and an unknown email simply becomes a new account.
A code instead of a password: Continue with email mails a 6-digit code that works once and expires after ten minutes. Type it where you started, on any client. Instances without a mail transport keep the password form behind the same button.
Passkeys: add one under Settings, Account, Passkeys, then sign in with Face ID, Touch ID, Windows Hello or a security key. iOS and Android run the ceremony on the device; the desktop app hands off to your browser and returns on its own.
Self-hosted: codes need SMTP or SES; passkeys need an https instance address. Both can be switched off with AUTH_EMAIL_OTP_ENABLED and AUTH_PASSKEY_ENABLED.

Working… that clears, accounts that tell the truth, and switching mid-run

2026-09-12

The Working indicator follows the agent’s real turn, Exponential tool calls render as cards, account health comes from a live probe, a Claude run can switch accounts when it hits a limit, and the UI wave lands on all four clients.

Working… ends when the agent does: the session footer, the Stop button and every session list now follow a real end-of-turn signal from the engine instead of the connection state, on web, desktop, iOS and Android. A rate-limited or compacting run no longer says Working, and a replayed transcript starts idle.
Exponential tool cards: when the agent calls Exponential, the transcript shows the Exponential mark with a plain caption (Creating issue, Opened pull request) and, once done, a preview of the result: the issue pill, the PR link or a result count.
Subagents by name: subagent chips carry the task the agent gave them, their rows summarize the tools they used, and a read-only Plan chip shows while the run is still in plan mode.
Sentences no longer split: a subagent’s tool call no longer cuts the main narration mid-word.
Accounts you can trust: an account’s health comes from a real usage probe, so a dead login reads Needs re-login instead of Signed in. Accounts is the decision page (per-agent tabs, live usage, health); Devices is where you sign in, re-login or pick which signed-in account a machine uses. Codex accounts stay signed in on their own, and switching a codex account never signs it out elsewhere.
Switch account mid-run: a Claude run that hits its limit can continue on another account from the usage sheet or the rate-limit notice. It carries on as a new run linked to the old one; the first message after a switch is a little slower.
The machine you clicked: a machine’s play button opens the composer with that machine selected, and the composer says why when a machine cannot take the run.
Sessions that remember where you came from: Back from a session returns to the issue, board or inbox it was opened from, resume and remote start jump straight into the run, sub-sessions nest under their parent, and an issue band inside the session opens the issue.
Mobile parity: Stop in the session header, a Watch pill instead of the Coding now card, suggestion chips on a new chat, pin buttons on iOS, pin on Android action rows, a Pinned section on the phone web sidebar, and flat rows under filled group headers on every list.
Desktop polish: an icon-only send button, a device settings dialog that fits, Usage as a round button next to Switch account, action icons in the automation picker, and dragging the window no longer selects text in a session.
Leaner agent context: issue lists returned to agents default to open work with short descriptions, and batch runs are told to share exploration instead of repeating it.
pi retired: the pi agent is gone. Any ACP binary still runs through the external agent option, with two caveats: pi does not speak ACP natively, so it is not a drop-in there, and an external agent runs without the MCP bridge, plan mode, usage and account reporting, the slash-command catalog and remote start.

Pins, machines shared with several teams, and video that plays inline

2026-09-11

Pin issues, sessions and actions to the sidebar, share a build server with every team that needs it, watch a clip right inside a description or comment, and connect a second GitHub organisation.

Pinned: pin an issue, a session or an action from its menu and it sits in a Pinned group at the top of the sidebar on web, desktop, iOS and Android. Pins are yours alone and follow you across devices.
A machine shared with several teams: a build server’s device settings now show one switch per team instead of a single picker, so one runner can serve every team you belong to. Withdrawing a share still ends that team’s runs on it and pauses its automations.
Video and audio inline: drop a clip into a description or a comment and it plays in place, with a poster, a duration chip and a lightbox, on every client. Uploads are normalised on your device (H.264 MP4, 720p on mobile); older apps show the same clip as a plain link.
Connect another GitHub account: team settings list every connected GitHub account with a Configure link and offer Connect another account separately from Refresh access, so a second organisation can be installed even when you already control one. An organisation waiting on the App’s approval is named on the claim page with an approve link.
Accounts on mobile: the iOS and Android Devices pages carry the Accounts section (one row per agent account, machines as chips, a check on the active login) that web and desktop got last release.
Live-session dot on Agent: the green or amber running-session dot moved from Devices to the Agent entry on every client; on the phone it rides the chat launcher, which is now reachable from every tab. The mobile composer always names the machine it will start on.
A quieter session list: past runs read “ · ” instead of repeating the agent and the ending reason, and ended runs no longer take a rail row.
Composer polish: an icon-only submit, subject chips with their own close button, tables in the chat feed that scroll sideways without stealing the wheel, dark-scheme time pickers, and boards on mobile merge chat and new issue into one capsule. Remote agent login now targets a specific account profile, and you can add a machine to an account from the web.
Rate-limit wall that expires: a run that keeps working after its reset time no longer wears a stale “Rate limited” banner; the wall clears on the next allowed call or once the reset passes.
Faster Actions and Automations in the IDE: hovering those rows no longer re-derives every session on each frame; the Automations render went from 744 µs to 180 µs on a large team.
Resume after a merge: resuming a chat run whose worktree was reclaimed after its PR landed re-creates the worktree from the recorded branch instead of refusing.

One composer for chat, coding and actions

2026-09-11

The Agent page composer starts everything: pick issues or an action, type instructions, attach images, choose the machine and agent. The Start coding dialog is gone on every platform.

One place to start anything: the Agent page composer is the launcher on web, desktop, iOS and Android. Pick issues with # or an action with the play button, or type to chat. The three-tab Start coding dialog and the Create action form are gone.
Every play button lands here: Start coding on an issue, the bulk bar, an action’s Run, a machine’s play button and Fix merge conflicts all open the composer with the right things preselected.
Instructions with a start: whatever you type beside the picked issues or action reaches the run as additional instructions. For a chat it is the prompt, for Create action it is the request.
Images on a start: attach up to four images to the composer. The machine downloads them before the first turn, the same way steering images work.
Actions keep only picks: text fields on actions are retired. An action declares repository, board, pull request or icon inputs; the free text comes from the composer. Existing text fields were removed from your actions, and each one’s hint became the action’s composer hint.
Composer hint per action: an action can say what to type (Scope, Focus, a version). It shows as the field’s placeholder once the action is picked, editable with the action and via MCP.
Options where you need them: machine, agent, model and plan mode sit under the composer; effort, ultracode, MCP servers and the account are one click away.
Answer inside the card: a pending plan or question is answered in its own card. Free-text and reject rows open an inline field, the composer steps aside until the card is done, and an answered ask step reopens until you submit.
Agent messages: an agent can notify your team over MCP with the new notifications_send tool. It lands as a push and an Inbox row for every member; a notification preference blocks other members’ agents while your own always get through.

Rate limited means rate limited, and a queued update that arrives

2026-09-10

A usage warning no longer marks a run blocked, the wall names its window, and a queued CLI update ends idle sessions instead of waiting forever, with Update now on the Devices page.

Warnings are not walls: Claude’s “approaching your limit” notice no longer marks the run “Rate limited” or tells the run that started it to wait. A run is blocked only when the agent itself refused a call.
The wall names its window: a blocked run’s window and reset time now describe the same thing (the 5-hour session window, the weekly one or a model’s), on the badge, in the session tools and in the message a parent run receives (“rate limited (weekly window) until …”).
Queued updates arrive: a CLI daemon with an update queued no longer waits for an attended chat that never closes. Sessions idle for 2 hours are ended and the daemon restarts on the new version.
What holds an update: the Devices page lists the live sessions a queued update is waiting on, who started them and when, and the Update button’s tooltip says how the machine will get there.
Update now: a machine whose daemon supports it offers Update now next to a queued update. It ends every live session on that machine (repo-backed runs can be resumed from their session page) and restarts on the new version.
Switch account on another machine: clicking Switch account in a remote machine’s device settings crashed the desktop app on the machine you were sitting at. The switch now queues on the remote machine as intended.

Sessions beside their list, one session header, and lists the Linear way

2026-09-10

Sessions open next to the list you came from with a back you can mouse, the header is the same on every device, hover is visible again, Usage lives under Devices, and lists are flat rows under group bands.

Sessions beside their list: a coding session opens as a screen of its own next to the list you came from (the Inbox stays when you click a running session from it, a board stays when you watch a run from one of its issues), and the Agent page lists every running and past run beside the chat prompt, on the desktop app and on the web. The web’s bottom dock band is gone; running sessions sit in the sidebar instead.
Back and forward with the mouse: the desktop app’s history has a forward stack, and the mouse’s back and forward buttons walk it everywhere, next to Alt+Left and Alt+Right.
One session header: back, the run’s identity, Usage, Resume and ONE Stop, identical whether you sit on the machine that runs the agent or watch it from another. The “Back to issue” row and the small kill icon are gone; the issue’s property tray shows Start coding, or Watch for your own live run.
Honest sidebar rows: a session row leads with its state dot, names the machine it runs on, nests the runs it started under it, and spins only while the agent is actually working.
Readable plan options: the highlighted option on a plan card is white on blue again; the composer’s attach button is the image glyph every other composer wears; “Latest changes” is “Changes”.
Hover you can see: the desktop app’s context menus and list rows had an invisible hover; the whole glass ladder got one notch lighter on every client.
Usage under Devices: the Usage page folded into the Devices page as its Accounts section. Each account lists the machines that hold it; a check marks the machine where it is the active login, and clicking a chip signs in or switches the account there.
Lists the Linear way: group headers are filled bands and rows are flat, gapless lines under them, on Devices, Actions, Automations, Reviews, Inbox and Support; the Inbox and Support tabs are the segmented capsule; Filter is a small icon button; settings sections are grouped cards whose rows save themselves.
Quieter rate-limit banner: a warning while the agent keeps working is no longer announced as “rate limited”; the banner shows for a real wall, with a countdown to the reset.
Usage that moves with Claude too: a running Claude session now feeds its session and weekly windows into this machine’s usage numbers on every turn, the way a Codex session already did, so the bar moves while you work instead of waiting for the next poll. The account’s other windows keep their last polled numbers rather than disappearing.

A run that hits its rate limit says so

2026-09-09

A rate-limited run is marked everywhere instead of going quiet, mobile gets mentions and inline diffs, and the IDE gets a Usage page and MCP servers.

Rate limited, not stuck: when an agent runs out of usage mid-run, the session is marked “Rate limited” with the time it resets, on web, desktop, iOS and Android. The run stays live and steerable; it simply cannot make a call until then. Until now it just went quiet and looked healthy.
Agents tell their orchestrator: a run started by another run reports its wall to the run that started it, once, instead of leaving it waiting on a session that reads fine.
A start that would go nowhere is refused: starting on a machine whose agent is already out of usage now says so and names when it resets, so you can pick another machine or agent.
Mentions in the mobile composer: the steer field on iOS and Android takes @ for teammates, # for issues and : for emoji, the same three the comment box already had.
Edits inline on mobile: an edit’s diff renders under its row in the iOS and Android transcripts, folded away until you tap it and capped so a big rewrite stays scrollable.
Usage in the IDE: the desktop app has the Usage page too, reached from Devices, with every machine and account grouped by agent and a Refresh that respects the provider’s limits.
MCP servers in the IDE: a Settings page listing the team’s servers with this machine’s readiness, so you can sign in, paste a redirect URL or set a value without leaving the app, and pick servers per run from the Start coding dialog and chat.
Bars for a second account: a machine holding more than one Claude or Codex login now reports usage for each of them, not just the default one.

Your own MCP servers in every run, and more than one agent account per machine

2026-09-09

Add a team’s MCP servers once, sign in from the browser on any of your machines, pick them per run; agents get accounts and a usage page.

MCP servers: Settings has a new MCP servers page. Add a remote server or a local command with the header or variable names it needs; the values never leave your machines. Pick servers per run in the Start coding dialog and on the chat page.
Sign in from anywhere: an OAuth server shows a readiness chip per machine. Click Sign in on the machine you want, consent in the browser you are already in, and that machine finishes the sign-in itself. The exponential mcp command signs in locally or takes a pasted redirect URL.
Sign in, one click: a start that fails because an agent is signed out now offers Sign in right there, on the toast and on the machine list, instead of sending you to a terminal.
Agent accounts: a machine can hold more than one Claude or Codex login, and a run picks the account it uses.
Usage page: every machine and account you own, grouped by agent with its rate-limit windows, with a Refresh that respects the provider’s limits.

A session page you can read, and a rail you can find it in

2026-09-09

Tool groups say what happened, edits show their diff inline, plan approval reads top to bottom, and every live run sits in the desktop rail.

Tool groups that say what happened: a collapsed run of tool calls reads “Ran 4 commands · edited 2 files · 1 failed” instead of “12 tool calls”, with failures last, on web, desktop, iOS and Android.
Edits inline: an edit’s diff renders under its row in the web transcript, capped so a big rewrite stays scrollable; failed calls tint the row.
Plan approval, top to bottom: the primary choice is “Yes”, the fresh-context choice comes second and “No, keep planning” sits last with a line saying your next message goes back to planning. Options are numbered buttons; keys 1 to 9 and Enter pick them, and typing in the composer answers the card. The extra text field inside the card is gone.
One composer: the mention-capable field from issues is the session field too, the send glyph is the same everywhere, and it turns into Stop while the agent is working. The plan-mode pill left the composer; the Plan switch stays on the chat page, model and effort are picked at start.
Subagent tabs on desktop: a subagent gets its own tab above the transcript, like the other clients, and the collapsed row opens it.
Rate limits in the transcript: a claude session that hits its limit shows one banner with the reset time instead of a run of identical messages.
The desktop rail: sessions and terminals fill the window on their own, every live run is a rail row under Sessions with an amber dot when it needs you, Agent opens chat, and the machine’s Files and Source Control sit under a This device heading. Watch slides the run in over the issue instead of leaving the page.
Transcripts stay loadable: after a device has replayed a finished run, scrolling to the top still fetches earlier pages from that device instead of stalling.
Session ids survive /clear: a claude session that clears its context keeps its page, its tab and its resume record.

The whole transcript, and steering that stops wedging

2026-09-08

Sessions keep every event instead of the last 2000, scroll back through a long run, and a dropped subagent no longer leaves the agent stuck on “Working…”.

The whole transcript: a session keeps every event it produced instead of the newest 2000, on web, desktop, iOS and Android. Each client renders a window of it and pulls the rest in as you scroll to the top, so a long run stays as smooth as a short one.
Load earlier: past what your client already holds, the transcript is fetched a page at a time from the machine that ran the session.
No more stuck on Working: a claude session whose background subagent stopped reporting back used to hold every later turn open forever. Tasks now only hold back their own turn, and one that goes quiet is retired instead of wedging the run.
Subagents finish once: a subagent that completed no longer appears twice, and a subagent that never reported back stops spinning.
Images in the transcript: an image you send an agent renders in the transcript instead of an “Image unavailable” placeholder.
Interrupt markers: cancelling a tool call no longer prints “[Request interrupted by user]” as though you had typed it.

Sessions that stay on your machine

2026-09-08

Transcripts live on the device that ran them, plan mode always builds, and the chat page is one prompt box with your defaults underneath.

Transcripts on your machine: every session’s transcript is written to the device that runs it, never to the server. Past runs in Devices, Chat and Automations open on their own page; when that machine is online the transcript is fetched from it on demand, and when it is offline the page says so.
Plan mode always builds: a claude session started in plan mode no longer stops to ask for tool permissions, and leaving plan mode into Build works. The composer keeps one Plan switch; model and effort are chosen once, in the start dialog.
Chat page: the Chat page is a single prompt box with machine, agent, model, effort and plan as small pickers underneath, prefilled from your defaults.
Subagent conversations: a subagent’s prompt no longer lands in the main transcript, and its own view shows its full conversation, not only its tool calls.
Whole messages: agent prose no longer splits mid-sentence into separate rows.
Remote agent sign-in: paste the code from an agent’s login link into the machine’s settings on web, desktop or mobile to finish signing that agent in from anywhere.
Quiet runs say so: a session whose agent has stopped reporting progress shows it, instead of looking alive while nothing happens.
Desktop changes list: the session page’s changes sit under the transcript as a collapsible per-file list with Merge, like the web.
Terminal-mode coding retired: every coding session runs on the session page. The Start in terminal switch and the terminal-tab fallback are gone; plain terminal tabs and agent sign-in tabs stay. Where a picker used to say a start would open in a terminal, it now says the agent is not ready on that machine and blocks the start until you run the doctor there.

Issue previews and tidier relations

2026-09-07

Hover an issue reference for a preview card, add sub-issues inline, and find Merge PR next to Start coding.

Issue preview cards: hovering a #EXP-12 pill in a description, comment, timeline, relation row or steering feed on web and desktop opens a card with the issue’s identifier, assignee, title, status, priority and labels. On iOS and Android the chips in the steering feed open the issue on tap.
Relations as headings: relations sit below the description under Sub-issues, Parent, Blocked by, Blocks, Duplicate of, Duplicated by and Related, and disappear when there are none.
Add sub-issues inline: an Add sub-issues row opens an inline composer; the new issue is created with its parent relation in one step, and the MCP create tool takes a parentId too.
One issue menu: Copy link, Add relation, Unmark duplicate and Delete live in a single round menu on the issue page and in the issue list’s context menu.
Merge PR next to Start coding: on an issue with an open pull request the Merge button sits in the properties card beside Start coding.
Session pages: a coding session opens on its own page from the bottom strip, and Chat starts an agent without an issue or a repository. Read the entries below for the full story.

Steering that keeps its transcript

2026-09-07

Your chat with an agent survives long subagent runs, remote pickers say which agents start in a terminal, and pi plans on the session page.

Transcript survives subagents: rejoining a session after a subagent made thousands of tool calls no longer shows an empty transcript. Subagent tool rows are dropped first, each subagent keeps its last 50, and the collapsed subagent card still says how many calls it made.
Terminal hint in remote pickers: when a machine can run an agent but not drive it on the session page, the agent picker on web, desktop, iOS and Android says it starts in a terminal tab instead of falling back silently.
Live command output: an agent that runs its commands through the session page streams output as it happens, shows the real exit code, and gets a Stop button on the running command.
pi plan mode on the session page: a pi run started in plan mode now opens as a session tab like claude’s, with a Plan and Default mode switch and the plan approval card.
Codex usage from the live session: the usage sheet reads Codex rate limits from the running session, so the desktop no longer starts a second app-server to ask.
Faster tool checks: the pi check remembers its verdict per installed build and honours a hand-configured pi path; run the CLI doctor to re-check in full.

Session pages and chat

2026-09-06

A coding session opens on its own page from the bottom strip, and a Chat button talks to your agent without an issue or a repository.

Sessions on their own page: the bottom bar on the web is now only the strip of your running sessions. Click one and the steering view fills the page; the resizable panel and its fullscreen switch are gone.
Chat: the strip ends in a Chat button. On the web it opens the Chat page: your newest running chat, or a start card that picks a machine and an agent, plus your past chats with Resume. In the desktop app the terminal dock’s strip has the same button, and the chat opens as a session tab (or a terminal tab when you start agents in the terminal).
Chat without a repository: a chat started from the web Chat page or the desktop dock no longer needs a repository. Without one it runs in a scratch folder with only the Exponential tools, so nothing is cloned or branched; pick a repository in the start-coding dialog to work on code as before.

Threaded comments

2026-09-05

Reply under a comment on web, desktop, iOS and Android, and see when an agent posted a comment over MCP.

Replies: every comment card ends with a Leave a reply row. On web and desktop the reply composer opens right there; on iOS and Android the docked composer switches to Replying to, with an x to go back to a plain comment. Replies sit under their comment with a smaller avatar, edit and delete like any comment, and threads stay one level deep.
Replies for agents: the MCP comments tool takes a parentId, and listed comments carry it.
Via MCP: a comment an agent posted over MCP says so in its header on every client, so it never reads as its key owner’s words.
Desktop dock as a bubble: the terminal and steering dock can collapse into a floating bubble instead of the bottom strip; switch from the dock header, and the choice sticks per device.

Issue relations and a design refresh

2026-09-05

Link issues as parent, sub-issue, blocking, blocked by, duplicate or related, and get a cutout layout, bigger comment images and a quieter activity feed on every client.

Issue relations: add a relation from the new card under an issue’s properties on web and desktop, or from the properties sheet on iOS and Android. Typing #EXP-12 in a description or comment links the two issues as related on its own, and marking a duplicate now shows up there too.
Relations for agents: the MCP tools can add and remove relations, and an issue’s relations come back with it.
Cutout layout: the content area is a rounded card floating on a darker ground on web and in the desktop app, so both read the same.
Desktop sidebar: the rail is always open and mirrors the web: team switcher, search and new issue at the top, What’s new and Getting started at the bottom, and the account menu holds What’s new, About and Sign out.
Desktop terminal dock: the open dock carries its own header with the window and collapse controls, sits on an opaque card, and the app text is one size bigger.
Bigger comment images: pictures attached to a comment show at full width on web, desktop, iOS and Android, and open the viewer on tap.
A quieter activity feed: events read as one muted line with a time, comments sit in a single card, and selected chips are no longer white.
Subscribe button retired: you follow an issue automatically when you create it, comment, get assigned or are mentioned, so the button is gone from every client.

Merge from action and chat runs

2026-09-04

A pull request opened by an action or chat run now belongs to that run: merge it from the session on every client, and find it under Agent runs in Reviews.

Merge is back on action runs: an action or chat run that opened a pull request shows the Merge button again, in the desktop Latest changes bar, on the web and mobile Devices rows and in every steering view. Merging closes the run unless the team keeps sessions on merge.
Reviews lists agent runs: pull requests opened by a run without an issue appear in their own Agent runs group on web, desktop, iOS and Android, with the action name, branch and PR number, and count toward the Reviews badge.
Agents know their PR: the session tools report the run’s pull request, so an agent can tell its own PR from any other when it merges.

A guided first run on every platform

2026-09-04

Creating a team now walks through the first board, inviting teammates and setting up devices, in the same order on web, desktop, iOS and Android.

Same steps everywhere: name the team, create the first board, invite teammates, set up devices; the four steps and their wording match on every client.
Invite right after the board: mint an invite link as soon as the team exists and copy or share it; the phones offer it only while the team has free seats.
Devices in the wizard: download the desktop app, copy the server install command and sign your coding agents in on the machines that show up; skipped steps stay on the getting-started checklist.
Mobile team settings: owners can now create invite links from the Members section on iOS and Android.

Polish on every client

2026-09-04

Mentions render as pills on iOS, review diffs scroll on phones, desktop dialogs share one chrome, and merges can leave sessions running.

Merge without closing: a new team setting under Statuses decides whether merging a pull request ends the live coding sessions on it; agents can also pass endSessions per merge.
Mobile: comment @mentions render as member pills on iOS, review diffs scroll sideways under a compact per-file header, empty boards show an icon with a hint, and the settings, action and start-coding sheets follow each platform’s idioms.
Desktop: every dialog shares the same input focus ring, traffic lights and danger-zone chrome; the search palette grows with its results; support inbox rows show the ticket subject.
Web: the mobile issue sheet lists properties as rows with a proper header, the storage table shows uploader and date as it widens, and the widget editor preview no longer clips.
One settings look: team, account and machine settings drop the boxes inside boxes for one grouped glass list, with a single section header style and round icon buttons for every row action, on web, the desktop app and iOS.
Android: search results show their group counts.

Slash commands and compaction in steering

2026-09-03

Type “/” in any steering chat to run the agent’s built-in commands, and watch compaction happen instead of guessing.

Slash commands: typing / in a steering chat offers /compact and /clear. They run on claude, codex and pi, on web, iOS, Android and the desktop viewer.
Compaction is visible: while the agent folds its context the chat shows a “Compacting context” bar, and a marker line stays in the transcript once it finishes. No more silent minutes.
Fresh conversation, with a warning: /clear asks for confirmation first, because it discards everything the agent knows so far. Files in the worktree are kept.
Compact from the phone: the session menu on mobile has a “Compact context” entry.

Tables

2026-09-03

Markdown tables render as real tables on every client, and the web and desktop editors add, move and delete rows and columns from hover controls.

Tables everywhere: a GFM table in a description, comment or agent message renders as a grid on web, desktop, iOS and Android instead of raw pipes, and survives an edit on every client.
Editing on web and desktop: hover a table for plus buttons on its right and bottom edges, and for handles above a column or beside a row that open a menu to insert, move or delete it.
Mobile: tap any cell to edit its text. To remove a table, long-press a cell on iOS or Android, or use the keyboard bar’s Delete table on the mobile web; row and column changes stay on web and desktop.

A branch per board

2026-09-03

Each board can pick the branch its coding sessions start from, and the board form’s repository picker is a plain select with the branch right under it.

A branch per board: board settings and the create-board form gain a Branch field, so one repository can back a board working on main and another on a release branch. Coding sessions branch from it, pull requests target it, and conflict fixes rebase onto it. Unset, a board keeps following the repository’s default.
One repository select: the board form’s repository picker is a single dropdown with a “No repository” choice, your connected repositories and a connect action, on every client. A single connected repository no longer looks selected when it is not.
Less text in the board form: the explanatory copy is gone; one line says where coding sessions start.
Agent tools: board create, update and set-repository accept a default branch.

Clean slate

2026-09-02

Every steering card can now be answered by id on every client, and the last compatibility code for older builds is gone.

Cards always carry an id: the desktop stamps a stable id on every steering card, including plan approvals that used to arrive without one, so web and mobile answer by id everywhere and the old keystroke fallback is retired.
Widget config: the legacy launcher position field is retired; every stored widget config carries the launcher shape.
Agent sessions: a pull-request opened without a session header no longer guesses which running batch run to park.
Housekeeping: the accepted-but-inert CLI --skip-permissions flag is removed, and the relay ticket drops an unused label claim.

Steer from anywhere

2026-09-02

The desktop app steers sessions on any of your devices, every steering chat takes images, agents can ask their parent run, and Reviews and nav badges got one design.

Steering on the desktop: the IDE gains a steering viewer, your live sessions on other devices (the CLI daemon included) show as chips next to the terminal tabs, and Start coding picks a device the way web and mobile do.
Images in every steering chat: attach, paste or drop images into chat, action and batch runs; steered images stay out of the issue’s Files.
Agents that start agents: a run started by another run can ask its parent a question and reports its close-out into the parent’s chat; a new session message tool steers any live run.
Offline devices refuse starts: a remote start to a sleeping machine is refused right away instead of silently queued, and a run whose device never checked in is flagged.
Reviews redesigned: one row design on every client, a full-page Reviews screen on the desktop, per-file diff cards, and Fix merge conflicts in place of Merge when a merge hits a conflict.
Dots, not counts: nav badges are dots everywhere with one order: Inbox, Support, Devices, Actions, Automations, Reviews.
One agent picker: agent, model, effort, plan mode, account and usage in one card, device edits autosave, and the mobile apps get the full action editor.
Plans shown whole: steering plans are no longer cut off at 16KB or shown twice, and a truncated plan says so.
Sharper agent tools: strict inputs, attachments of every type via signed download links, issue identifiers accepted everywhere, paginated lists. Hard renames: descriptionText is now description and bodyText is body.
Terminal + starts a steerable session: the desktop dock’s agent items now run as real sessions with their own worktree and steering.
Remote agent sign-in: works with current Claude Code again and never opens a browser on the remote machine.
Older clients must update: the server now requires iOS 0.14.20, Android 0.14.23 and desktop or CLI 0.14.28.

August 2026

One Backlog and a cleaner look

2026-08-30

Todo and Backlog are now one list, sheets and menus share one uniform look, and the editor keeps your blank lines on every platform.

One Backlog: the Todo status is retired; everything that sat in Todo now lives in Backlog, and custom statuses gain a white color option.
Uniform sheets and menus: dialogs, sheets and menus share one look across web, iOS and Android.
Blank lines stick: the editor preserves intentional blank lines identically on every platform.
Usage per session: usage shows the limits of the agent actually running your session.
Sharper agent issue tools: agents can now filter issue lists by label, custom status, category and dates.

Agents always skip permissions

2026-08-30

Every coding run now starts with the agent’s permission prompts bypassed, and the setting is gone.

Bypassed by default: claude launches with --dangerously-skip-permissions and codex with --dangerously-bypass-approvals-and-sandbox on every run. Plan mode stays the only starting-mode choice.
One toggle less: the “Skip permissions” switch is gone from the start-coding dialogs, action runs and device settings on web, desktop, iOS and Android, and from the CLI, where --skip-permissions is accepted and does nothing.
Saved defaults: stored per-machine launch defaults are migrated for you and the retired setting is dropped.

2026-08-30

Bottom sheets on iOS, Android and the mobile web now share one design, sheets stack on iOS, New issue is a page on every phone, and the “…” menu on iOS opens reliably.

One sheet: every bottom sheet has a drag handle, a left-aligned title, the same dark surface and no Cancel or close button. Swipe down or tap outside to dismiss. The main action (Create, Save, Start coding) is one full-width button at the bottom.
Same height everywhere: small sheets such as New board, New label and Add repository size to their content on both platforms, while Start coding, New action, Automation and Device settings fill the screen.
Sheets stack on iOS: opening Labels or Status from the Properties sheet now slides in on top of it, and closing it takes you back to Properties, the way Android already worked.
New issue is a page: on iOS and the mobile web the editor opens as a full page with a back arrow and a Create button at the top, matching Android.
Menus: every Delete, Remove and Kill entry is red with a red icon and no divider, menu icons are the same size on every client, and Move to board uses the same icon everywhere. The “…” button on an iOS issue no longer drops taps or slides in from the bottom.
Mobile web: confirmations show as a small centered alert, and the issue header folds Share, Subscribe, Move to board and Delete into one “…” menu.

A calmer steering view

2026-08-30

Steering now names the issue it is working on, usage moved into a Usage sheet and into each agent’s own tab, and the terminal tabs in the desktop app sit at the bottom.

The header names the run: on phones and tablets the session header now shows the issue identifier and title, with “Live”, “Needs your input” or “Paused” as a small line underneath.
A “…” menu: usage and Kill session moved behind it. Usage opens a sheet with every limit the agent reports, grouped into Current session and Weekly limits, so it matches what the agent’s own app shows you.
Latest changes floats: the changes and Merge bar now sits over the bottom of the conversation instead of taking a slice of it, and the newest message still scrolls clear of it.
Usage per agent: a machine’s settings no longer keep a separate Agents section. Each agent’s tab shows the account it is signed in as, its Login or Switch account button and its limits.
Terminal tabs at the bottom: the desktop app’s terminal tabs now sit along the bottom edge and expand upwards, with an “Open in new window” button and the same Latest changes and Merge bar.
Latest changes is the whole branch: it used to show only what the agent had not committed yet, so it emptied out the moment it committed. It now shows everything the branch changes.

Devices, Actions and Automations split up

2026-08-30

The Agents surface becomes three: Devices for your machines, Actions for what you run, Automations for what runs itself.

Three entries: the sidebar and the desktop rail list Devices, Actions and Automations separately instead of folding them into one Agents page. Agents is now Devices, and it keeps the live-session dot.
On phones: Devices and Actions are their own tabs on iOS, Android and the mobile web, and Search moved out of the bottom bar into the board header next to Filter.
Suggestions live in Getting started: on a desktop viewport the ready-made action ideas moved into Getting started as a “Suggested actions” tab, reachable from the lightbulb next to New action and New automation. Their buttons now say Use.
Fix merge conflicts is not a card: the builtin is hidden from the actions list. It still starts from Reviews and over the agent tools.
Runs report a summary: a finished run’s self-reported Done, Blocked or No changes outcome is gone on every client; the agent’s written summary is what a run leaves behind, rendered as markdown, and a live row simply says Running.
One list of finished runs: the Automations tab’s “Recent automated runs” is now the only place finished runs are listed.

Honest offline handling

2026-08-29

Every client now tells you when it cannot reach the server instead of showing a raw network error, the desktop catches up faster after a sleep, and “Fix conflicts” only appears when there really are conflicts.

Offline banner: the web app and Android now show the same “showing cached data” banner iOS and the desktop already had, with a Retry button. Your boards keep working from what is already synced.
Plain language: a failed action used to surface whatever the browser or the OS said, things like “Failed to fetch” or “Unable to resolve host”. Every client now says “You’re offline. Check your connection and try again.” instead.
Faster catch up after sleep: the desktop app notices when the machine has been asleep and restarts its sync straight away, with a small spinner next to your account while it catches up, so you can tell stale data from live data.
Fix conflicts when it helps: the recovery run is now offered only for a real merge conflict. A stale base branch, a branch protection rule or a dropped connection no longer hand you a button that cannot fix them.
Screenshot after a delay: the feedback widget’s capture button gains an Off, 3s and 5s hold with a countdown, so a reporter can open a menu or a popup and still catch it in the shot.
More agent tools: agents reach the rest of the product over MCP now that tools are looked up on demand: custom statuses, coding sessions (list, start, kill), your machines, automations, and helpdesk threads on teams that have the helpdesk turned on.

Agent usage and accounts on every machine

2026-08-28

Every client now shows which account each agent CLI is signed in with and how much of its rate limits you have used, and you can start a sign-in on any of your machines from anywhere.

Usage at a glance: a live coding session shows a small bar for the agent running it, filled to the window closest to its limit, amber past 75 percent and red past 95. It says when the window resets, and dims itself with an “as of” note when the numbers are older than a quarter of an hour.
Every window: expand the bar to see all of an agent’s limits at once, the five hour session, the week, per model and credits, and pin the one you care about. The choice is remembered on that device.
Accounts per machine: a machine’s settings now list its agent CLIs with the account each one is signed in as and the plan behind it. Nothing about a credential ever leaves the machine.
Login from anywhere: start a sign-in or an account switch for Claude Code or Codex on any of your machines from the web app, iOS, Android or the desktop, and the link and code come back to you as soon as the machine has them.

Agents report back without closing

2026-08-28

A run you started now stays open after the agent reports its summary and outcome, so you can keep the conversation going. Automated runs still close on their own.

Keep talking after the report: a run you started from an issue, a batch, an action or a chat now records its summary and outcome and stays live, so you can answer, ask for more or steer it further without resuming.
Automations still close: runs started by a schedule or a trigger end when they report, exactly as before.
Recent runs keep the report: the web app, iOS and Android list a finished run’s summary even after its tab is closed on the desktop.

Inline images in the terminal

2026-08-28

Full-screen terminal programs that draw with images now render in the right place, stay sharp, and no longer grow the app’s memory while they run.

Placed where you put them: an image drawn by a full-screen program used to land below the visible area once that program had scrolled its own output, showing a black pane instead. Images now anchor to the row they were placed on.
Steady memory: programs that push a fresh image every frame release the old one, so a long-running one no longer grows the app’s texture memory without bound.
Correctly scaled: the terminal now tells programs the pixel size of a character cell, which is what image-aware tools read to scale their output. Without it they drew unscaled.

Older app builds retire

2026-08-28

The compatibility paths kept for pre-August builds are gone. Update the desktop app, the CLI and the Android app when prompted; iOS keeps working on the current App Store build.

Update prompts: the desktop app, the exponential CLI and the Android app now require this release, and each one tells you when it needs updating. iOS keeps working on the current App Store build.
Cleanup: the legacy image upload route, the relay’s removed-terminal frames and the device-list poll are retired. Machines have come from the synced registry for a while, so nothing changes in how you pick one.

Resume issue sessions exactly

2026-08-28

Resume now works on finished issue and batch sessions too, and it reopens the agent’s own transcript instead of whatever ran in that folder last.

Resume an issue session: the Resume button on a finished session now covers issue and batch runs, not just actions and chats, on the machine that ran them. It relaunches the exact conversation the agent had, rather than the folder’s latest one.
Start coding knows what it resumes: the desktop Start-coding dialog’s “Resume previous session” now reads the session record itself and names the agent it continues.

Agents close out their own runs

2026-08-27

Action, chat and automated runs now end with the agent’s own summary and an outcome you can read on any client, and you can pick a finished run back up where it stopped.

A run reports back: when an agent finishes it writes a short summary and one of three outcomes, Done, Blocked or No changes. Runs lists show the outcome at a glance; tap or click a run to read the full summary.
Resume: a finished run can be relaunched on the machine that ran it, from the desktop app, the web app, iOS and Android. It picks up in the same workspace with the agent’s own history.
Every run in its own workspace: action and chat runs on the desktop now get a dedicated branch and worktree instead of working in the main clone, and clean ones are tidied up when the run ends.
Chore pull requests: agents can open and merge a pull request that belongs to no issue, so housekeeping work stops landing straight on the default branch. Merging your own pull request no longer ends your session.
Leaner agent context: the tools an agent carries by default shrank to the handful a coding run actually needs, and the rest are looked up on demand.

Inline images in the desktop terminal

2026-08-27

The IDE terminal now renders sixel, kitty and iTerm2 inline images in place, so previews from tools like chafa, img2sixel and kitten icat show up right in the grid.

Inline images: sixel, kitty graphics protocol and iTerm2 inline images render inside the terminal grid, scroll with the scrollback, survive a switch into and out of full-screen programs, and clear with the screen.
Pixel-aware replies: programs that ask the terminal for its pixel size now get real cell metrics, so image tools size their output correctly instead of guessing.
Terminal core: the emulator moved from alacritty_terminal to rio-vt, the VT core behind the Rio terminal, which is what brings the graphics support. Key handling, mouse reporting, selection and live steering behave exactly as before.

Steadier live sessions

2026-08-27

Live coding sessions on web, iOS and Android now ride out network changes and app switches, the CLI daemon heals itself when it falls behind, and the feedback widget can hide its launcher on demand.

Sessions that stay up: the web, iOS and Android session views reconnect on their own after a network change, a backgrounded app or a dropped socket, with capped, jittered retries instead of a spinner that never ends.
No stranded sessions: a desktop that is told it is too old still ends its coding sessions cleanly instead of leaving them marked as running, and the CLI daemon updates itself immediately when it hits that gate (exponential update now restarts a running daemon too).
Widget: a new setLauncherHidden() call hides the launcher while your own UI covers its corner, the edge tab is slimmer, and the docs cover the whole runtime API.
Polish: a calmer Actions list on every client, refreshed product demos in the docs, and the desktop notifications that shipped alongside (see the entry below).

Desktop notifications

2026-08-27

The desktop app now raises real system notifications when something lands in your inbox, on macOS, Windows and Linux, self-hosted included.

Real notifications: assignments, comments, mentions, status changes, PR activity and support replies show up in your system’s notification center the moment they happen. Clicking one opens the issue, the team’s Support inbox, or your Inbox.
Quiet when it should be: nothing fires for the history that syncs at first sign-in, what arrived while the app was closed shows up once as a single bundle, a burst of related events collapses into one notification, and an issue you are already looking at stays silent.
Your rules apply: the per-type switches in Account, Notifications decide what may notify at all, and a new “Desktop notifications” toggle above them turns it off for one machine.
Works self-hosted: this is the first push-like channel that needs no cloud service, since it rides the same sync the inbox uses.

Browse a session’s worktree in the desktop app

2026-08-26

The Files tree can now switch from the trunk to any coding session’s worktree, and the last compatibility shims for older builds are gone.

Worktree switcher: the Files tree carries a branch dropdown listing the trunk and every coding session’s worktree; picking one re-roots the tree, its git status and the file viewer.
Rail icons: a selected tool entry keeps its white icon; the board color now lives on the selection marker only.
Start coding dialog: the tallest picker state no longer shows a sliver of a scrollbar.
Cleanup: the compatibility paths kept for pre-August app builds and older self-hosted servers are retired. Update the desktop app and CLI when prompted; the store apps keep working.

Start a chat from the Agents tab

2026-08-25

On phones the Agents tab now carries a chat button in the corner, so a quick question to an agent is one tap away.

One tap: the round button sits where the new-issue button does on a board, and opens the launcher straight on its Chat tab.
Everywhere on mobile: iOS, Android and the web app on a phone all get it.
Same chat as always: pick a machine, pick a repository, type what you want, and the session opens as soon as your machine takes it.

Pick a default machine

2026-08-24

Mark one of your machines as the default and every Start coding dialog preselects it instead of whichever one happens to sort first.

One toggle: open a machine’s settings from Agents and flip “Default device”. A star marks it in the machines list, and only one of your machines can hold it, so turning it on somewhere else moves it.
Prefilled everywhere: starting a coding session, running an action and binding an automation all preselect your default whenever it can take the job. Anything else you pick still wins, and an offline default quietly steps aside for a machine that is online.
Everywhere you work: the toggle and the prefill are on web, the desktop app, iOS and Android, and the choice follows your account across all of them.
Shared machines: a teammate’s shared server can still run your sessions, but only machines you own can be your default.

Live sessions stay connected

2026-08-24

Coding sessions keep streaming in the background while you move around the app, and a steering draft survives reconnects on web, iOS and Android.

No more reconnect loops: opening a session again shows the feed instantly; the connection now lives outside the session view, so collapsing the panel or navigating away no longer drops it.
Drafts are safe: text typed into the steering box survives attaching an image, connection blips, navigation and rotation. The box also stays visible while reconnecting; only Send waits for the live stream.
Quiet recovery: when the relay drops a viewer that briefly stalled (like while a file picker is open), the session reconnects silently instead of showing “Disconnected”.
Web composer: images can now be dragged onto the steering box, and attaching twice in a row no longer loses the first image.

No more notifications about your own pull requests

2026-08-23

Opening or merging a pull request on GitHub itself is now credited to your account here, so you stop hearing about your own work.

GitHub actions get a name: a pull request opened or merged on github.com used to arrive as “a pull request was opened”, with nobody excluded, so it reached the very person who had just done it. Your GitHub account is now linked when you connect GitHub in team settings, and those events are credited to you and skipped for you.
Your agent’s work counts as yours: filing an issue mid-session and having your agent implement it no longer notifies you about the resulting pull request, even when nothing can name who opened it.
Shared machines: the owner of a machine hosting someone else’s coding session no longer gets notified about that session’s pull requests.
No more doubles: a pull request event can no longer produce two inbox rows when the two paths that report it disagree about who acted.

Calmer issue lists on a phone

2026-08-23

The tinted, pinned status bands on mobile issue lists are gone, and the mobile web list now looks like the native apps.

Plain headers: the status-tinted band the iOS and Android lists picked up last week reads as heavy on a phone. The header is an ordinary row again, on the app background, and it scrolls with its group instead of sticking under the navigation bar.
Mobile web matches the apps: below the desktop breakpoint the issue list is the natives’ stack of rounded glass cards in a 16px gutter, with the identifier, label color dots, the assignee avatar on multi-member teams and a chevron. Desktop and the desktop IDE keep their pinned tinted headers and table rows.

Mobile lists, create and menus polished

2026-08-22

Status-grouped issue lists, a faster create flow and glassy native menus land on iOS and Android, plus a simpler emoji picker everywhere.

Status headers: issue lists on iOS and Android now group under tinted status headers, matching the web.
Create sheet: creating an issue on mobile opens the new issue immediately, and “create more” keeps the sheet ready for the next one.
Select menus: pickers and context menus on mobile move to the shared glass components for a more native feel.
Emoji picker: a simpler picker that inserts plain emoji; the separate skin-tone preference is gone.
Fixes: the Android markdown editor no longer jumps while typing, Android steering images render again, and remote plan approval and steering questions are reliable with the newest Claude Code.

A calmer, glassier look

2026-08-22

The indigo accent is gone: selections, badges and buttons now use the white glass language on web, desktop, iOS and Android.

One selection language: the selected agent tab, checked rows and pickers now use the same white glass fill on every platform instead of an indigo one on mobile.
White accents: unread dots, count badges, send buttons and the New Issue button switch from indigo to the near-white primary.
Merged stays blue: merged pull requests now use the same status blue everywhere; before, iOS and Android tinted them indigo.
iOS controls: toggles and pickers drop the system tint for the white scheme.
Details: text selection, focus rings, links, diff hunk headers and the desktop’s drag and slider accents follow suit.

iOS @, # and : menus are back

2026-08-22

Typing @, # or : in an iOS issue description opens its picker again instead of doing nothing.

The candidate menu now rides above the keyboard on every iOS editor. It used to hang off the end of the description, which put it behind the keyboard for anything longer than a couple of lines, so typing # looked like it did nothing at all.
Editing a comment far down a long thread had the same problem, and is fixed with it.

iOS session feed fixes

2026-08-21

Long coding session feeds no longer freeze the iOS app, the “Jump to bottom” pill hides reliably, and issue lists sit flush under the bar on iOS 26.

Session freeze: following a long activity feed could lock the app in a layout loop until iOS closed it; the feed now follows growth without re-entering layout.
Jump to bottom: the pill now reads the real end of the feed, so it no longer lingers after you scroll back down, and the feed re-pins once a scroll settles.
Issue lists on iOS 26: the light band between the navigation bar and the first status header is gone.

Leaner issue dialog, steadier sessions

2026-08-21

The new issue dialog drops its clutter, the editor gets a static insert bar, and coding sessions on iOS no longer crash on long histories.

New issue dialog: the create dialog on web and desktop loses the icon and “create more” chrome; the attachment rail only appears once you add a file.
Insert bar: emoji, image and file buttons sit in a fixed bar under the editor instead of the floating selection rail, so the rail no longer swallows clicks.
Icon pickers: board forms open the icon grid from a compact swatch next to the name field.
Agent questions on mobile: multi-step questions show which step you are on and what you already answered, on iOS and Android.
iOS: reopening a coding session with a long activity history no longer crashes.

Automations are their own thing

2026-08-21

Automations moved out of the action editor into their own list, so one action can run on several schedules or events.

New automation button: the Automations tab has its own form. Pick an action, a schedule or an event, the machine it runs on, and optionally pin the agent, model and effort.
Many per action: an action can now carry as many automations as you like, each with its own trigger and device. Action cards show how many target them.
Cleaner action editor: creating or editing an action no longer asks about triggers.
Suggestions: cards say whether a suggestion sets up just an action or an action plus its automation, and the create dialog prefills the trigger.

Issue links on mobile

2026-08-21

Typing # on iOS opens a proper issue menu with status, identifier and title, and Android shows the status too.

iOS issue links: typing # in a comment or description now opens a vertical menu under your text, the same one as @mentions and emoji, instead of a cramped horizontal strip that never appeared in the comment composer.
Status everywhere: issue suggestions on iOS and Android lead with the issue’s status glyph, matching web and desktop, and show up to eight matches.

Mobile polish and compact icon pickers

2026-08-21

Android gets glass inputs and buttons, issue lists pin their status headers cleanly, and icons are picked from a compact swatch on every app.

Android look: one glass text field and glass buttons replace the Material outlines across login, onboarding, issues, filters, search, support and settings.
Issue lists: status headers stick while scrolling on iOS and Android without a stray band under the navigation bar.
Icon pickers: board forms, action editors and the widget launcher show the current icon as a swatch that opens the grid, with a real “No icon” state for optional action inputs.
Actions: the same layout on every app, with section counts and a labeled New action button.
iOS labels: editing or deleting a label from Team settings no longer fails.

Mobile editor fixes

2026-08-20

iOS keeps your bold and italic marks through heading changes, and Android link editing and the issue bottom bar behave.

iOS editor: changing a heading or tapping Clear formatting no longer wipes bold, italic and code marks in the paragraph, Clear formatting applies only to the selected text, and heading changes cover every paragraph in the selection.
Android links: editing a link with the caret inside it now updates the whole link instead of corrupting it, and clearing the URL field removes the link.
Android issue view: the floating bottom bar returns after dismissing the keyboard with the back gesture.

2026-08-20

Format issue text from a rail on every app, style the feedback widget button, and watch server health on a new admin Performance page.

Formatting rail: the issue description and comment editors on web, desktop, iOS and Android grew a formatting rail: headings, bold, lists, links, code and more, applied to your selection without typing markdown.
Widget launcher styles: the feedback widget button is now configurable per widget: floating button or edge tab, corner or edge position, a picked icon, and separate desktop and mobile choices, with a live preview in widget settings.
Admin Performance page: global admins get a live view of request latencies, Electric shape traffic, database table sizes, notification email flow and relay health.
Android editor: pressing Enter at the end of the description now reliably adds a new line, and the review screen’s merge conflict notice was rebuilt to match the app.
Remote approvals: permission prompts an agent raises for dangerous commands now reach the remote steering view even in skip-permissions sessions, so you can approve or deny from your phone.

Desktop hotfix: opening an issue

2026-08-19

Desktop 0.14.17 fixes a crash that closed the app whenever an issue was opened.

Desktop crash fix: opening an issue in the desktop app no longer closes it. The comment composer’s emoji button (from the previous release) tripped an internal render check on every issue view; 0.14.17 repairs it, and the desktop app updates itself.

Files on comments, paused sessions, getting started

2026-08-19

Attach images and files to comments, see a coding session as paused while its machine is offline, and a getting-started checklist that finishes itself.

Files on comments: the comment composer now uploads images and files on send, on web, desktop and Android. They render under the comment as image previews and file chips, can be added or removed in edit mode, and stay out of the issue Files rail.
Paused sessions: a coding session whose machine goes offline now reads as paused with the device name, on the Agents rows, the dock, the issue and the session view, instead of an endless starting spinner. The view reconnects by itself when the machine comes back.
Getting started: the checklist in the sidebar and the desktop rail mirrors the same ten steps everywhere, adds a Create an action step for owners, and hides itself once everything is done. No dismiss button to hunt for.
Batch merge: the merge button on a batch session now targets only its own branch’s pull request, never a teammate’s, after the session’s own PR closed unmerged.
Mobile web: the team pages on a phone use the same layout as the native apps, and the avatar menu lost its duplicate Account entry.

Emoji, everywhere you write

2026-08-19

An emoji picker in the description editor and the comment composer on web, desktop, iOS and Android, plus :shortcode autocomplete.

Emoji picker: a smiley button in the description toolbar and next to the attach button in the comment composer opens a searchable picker on all four apps, with your recent picks first.
:shortcode autocomplete: type a colon and two letters, like :tad, and pick from the suggestions; typing :tada: in full turns into the emoji straight away, the same way mentions and issue references complete.
Skin tones: choose a skin tone once in the picker and every hand and person emoji follows it, on that device.
Plain unicode: emoji are stored as ordinary characters in the markdown, so an emoji added on one app renders the same on every other and in email.

Your repos, shared with the team

2026-08-19

Every member connects their own GitHub repos and shares them with the team, and stale GitHub accounts finally show a Disconnect button.

Per-user repo sharing: any member can now connect GitHub and add repositories, not just owners. You see and connect the repos your own GitHub account can access; connecting one shares it with the team so everyone can code on it.
Shared by: repository rows now show who shared them. The sharer and team owners manage a repo (remove it, pin its default branch); everyone else codes on it.
Disconnect stale accounts: a linked GitHub account that no reconnect can refresh now shows a visible Disconnect button for owners instead of warning forever.
Reconnect self-heals: reconnecting GitHub as an owner also cleans up orphaned account links left behind by old versions, so the reconnect warning actually goes away.

Actions run themselves

2026-08-18

Give an action a schedule or an issue-event trigger and a device of yours runs it, plus a tabbed Actions surface with suggestions.

Schedules: run an action every day, week, or month at a time you pick. The run happens on a device you choose, in its local time, and a run missed while the machine was off fires once when it comes back.
Event triggers: start an action when issues change, on creation, status moves, assignee or priority changes, label adds, or pull request opens and merges, with optional board, label, priority, and status filters. Changes that arrive together batch into one run.
Runs stay local: your desktop app or the exponential daemon watches its own sync and starts the run itself. There is no server-side runner, and automated runs carry an Automated badge everywhere.
A tabbed Actions surface: Actions, Automations, and Suggestions tabs on all four apps. The Automations tab shows every trigger, its device, the next run, and recent automated runs.
Suggestions: eight ready-made action ideas, from a daily standup digest to a label janitor. One tap prefills the action creator.
Multi-line inputs: actions can now declare textarea inputs, and the action editor’s description grew into one.

Everything moves

2026-08-17

Panels slide, lists reorder, and tabs travel, on all four apps and in one shared timing.

Panels slide: the coding panel on web and the terminal dock in the desktop IDE now open and close with a slide instead of jumping the page. The IDE’s left rail expands and collapses the same way, and dragging either one to resize still tracks your pointer exactly.
Lists that reorder: changing an issue’s status or a filter now moves rows to where they landed on iOS and Android, instead of having them appear somewhere else.
Navigation with direction: the bottom tab bar’s selection travels between tabs, and the first-run setup steps slide forward and back on both phones.
One shared timing: every app now animates on the same three durations and curves, so the same action feels the same everywhere.
Respects your settings: turning on Reduce Motion (iOS), Remove animations (Android) or the browser’s reduced-motion preference now switches these off. Android had no such handling before.

Git history in the desktop IDE

2026-08-17

See your repo’s commit graph in Source Control, and push safely when trunk has moved on.

Commit graph: Source Control in the desktop IDE now shows the repo’s history as a lane graph, including remote branches, with paging for deep histories.
Push through a diverged trunk: commit and push now walks you through a guided rebase when your trunk is both ahead of and behind the remote, instead of failing with a raw git error.
Fixes: the board settings color picker no longer clips at the dialog edge, and steering a session with image attachments can no longer stall the live connection to your phone.

Selectable text in the desktop IDE

2026-08-16

Select and copy read-only text anywhere in the desktop app, riding a major rendering engine upgrade.

Select and copy: issue descriptions, comments, and file previews in the desktop IDE are now selectable, with sweeps that run across several comments at once. Copying a selected description yields its markdown source, ready to paste anywhere markdown goes.
Rendering engine upgrade: the desktop app moved to the newest UI framework release, bringing correct orientation for photos straight off a phone, IME composition fixes for CJK input, smoother scrolling, and a fix for a class of text layout glitches at very wide windows.

Steering images and archivable boards

2026-08-16

Attach screenshots to a live coding session, archive boards you are done with, and steer the newest agent CLIs reliably again.

Images in steering: the session composer now takes up to four images per message via the new attach button (or paste, on web). The machine running the session hands them to the agent as local files, so it sees exactly what you see, and they render inline in the session feed on every app.
Archive boards: owners can archive a board from its settings on web and desktop. An archived board and its whole history disappear from every app until you unarchive it, and nothing is deleted.
Steering fixes: permission prompts from the newest Claude Code versions are answerable again from your phone, including questions that take a typed reply.
Offline banner in the IDE: the desktop app now says when it can’t reach the server and is showing cached data, with a one-tap retry.
Leaner web composer: the Esc button is gone; killing the session remains available from the session header.

Stability wave: 40+ fixes across every app

2026-08-15

A deep code review turned into a wave of correctness, performance, and security fixes on web, desktop, iOS, and Android.

Merging wraps up the session: merging a PR now ends its live coding session on every path (webhook, poller, or the Merge button), so machines stop working on branches that already landed.
Faster lists: big boards render instantly on web (virtualized) and much cheaper on desktop; steering a session no longer replays its whole history frame by frame.
Editor fixes: bracket-heavy lines no longer freeze the desktop editor, nested numbered lists keep their numbering on Android, and image alt text with brackets parses correctly.
Sync and auth hardening: attachment storage recovers after a hiccup instead of sticking until restart, login rate limiting is on in production, and a batch of rare account/session edge cases are closed.

Agent bug reports and richer feedback details

2026-08-14

Coding agents can file Exponential bug reports straight from a session, and feedback metadata now shows on every platform.

Report bugs from a session: agents connected over MCP get a report tool that files bugs about Exponential directly to us, credited to you so you get the resolution email. Issues filed this way carry an Agent origin chip.
Feedback details everywhere: the reporter, page, and device details on widget-filed issues now show in the desktop IDE and as an expandable card on mobile, not just on web.

Better PR notifications

2026-08-13

PR notifications now credit the person who started the work, plus fixes across desktop and mobile.

PR notifications attributed: when an agent opens or merges a PR, the notification now names the person who asked for it, skips notifying them about their own action, and no longer double-fires.
IDE: deleting an issue now closes its open tabs cleanly instead of leaving a dead “not found” tab.
Mobile: the assignee picker and @-mentions only offer current team members.
Device settings: machine settings edited from web or mobile now reach the machine in about a second instead of on the next heartbeat.

Device settings, remote worktrees, and resume from anywhere

2026-08-12

Every machine gets a proper settings view on all four apps: rename, share, edit its agent defaults even while it is offline, manage its worktrees remotely, and resume sessions from web and mobile.

Device settings view: the Edit entry on a machine opens a full settings dialog (bottom sheet on mobile) with its name, team sharing, agent defaults, and worktrees in one place.
Defaults editable from anywhere: a machine’s per-agent model, effort, and permission defaults now live on the server; edit them from web or your phone even while the machine is offline and it converges when it comes back.
Remote worktree cleanup: see every worktree a machine holds, remove one, or prune everything already merged; commands queued against an offline machine run on its return.
Resume from web and mobile: starting coding on an issue that already has a worktree offers “Resume previous session” outside the desktop app too.
Live machine list: machines now sync in realtime instead of polling, with online status derived from their heartbeats.

Tidy worktrees and a reworked Actions view

2026-08-11

The desktop IDE now cleans up landed worktrees and stale branches automatically, and its Actions surface matches the web agents page.

Worktree auto-clean: landed session worktrees and their branches are pruned automatically once git confirms the work is in the default branch; anything with uncommitted or unpushed work always survives.
Actions as cards: the desktop Actions surface is now the web agents page 1:1, with a card grid, owner edit dialog, and Run on every card.
Safer file previews: binary files no longer freeze the viewer; the placeholder offers opening the file in its default app or revealing it in your file manager.
Smarter PR notifications: pull request activity from your own agent no longer pings you, and webhook events are attributed to the session owner.

Plan mode for pi

2026-08-10

pi sessions can now start in plan mode: the agent investigates read-only, proposes a plan, and waits for your approval before touching code.

Plan-first pi runs: the launcher injects a plan-mode extension that blocks edits until you approve the plan pi presents in its terminal dialog.
Approve from anywhere: the plan shows up as the familiar plan card in the session view, answerable from web, iOS, and Android.
Per-agent default: pi gets its own Plan mode toggle under Settings, Agents on the desktop, on by default like Claude’s.
Pin a default branch: repository settings on web and desktop can pin the branch coding sessions branch from and PRs target, overriding GitHub’s default everywhere.

Approve agent permissions from anywhere

2026-08-09

Permission and approval prompts are now answerable from web, iOS, and Android instead of pausing the session until you reach the machine.

Claude permission prompts: sessions started without permission bypass surface the “Do you want to proceed?” dialog as an answerable card in the steer view, with the dialog’s real options.
Codex approvals: command, edit, and network-access approval modals are answerable remotely the same way.
Steer with words instead: sending a message while a prompt is up dismisses it safely and delivers your text as the “tell the agent what to do differently” feedback.
Settings slide into the sidebar: team settings now open as a slide-in navigation in the sidebar on web and desktop instead of a separate page rail.

Start coding with your machine’s own defaults

2026-08-08

The remote Start coding dialog now pre-fills the model, effort, plan mode, and permission settings you configured on the machine you pick.

Machine defaults everywhere: pick a desktop or server in the Start coding dialog on web, iOS, or Android and it loads that machine’s saved per-agent defaults, including plan mode and permission bypass.
Per agent: switching the agent tab re-seeds model, effort, and toggles from the selected machine’s settings for that agent.
Live: change a default in the desktop app’s agent settings and remote dialogs pick it up right away.

Statuses read the same everywhere

2026-08-08

Issue lists now group statuses in the order your settings page lays them out, on web, desktop, iOS, and Android.

One status order: issue lists group by status in the same order the statuses settings page shows, starting with the unstarted statuses instead of the started ones.
Everywhere at once: lists, status pickers, and the settings page all read the same top to bottom, on all four apps.

2026-08-07

Share a server machine with your team for remote coding sessions, sign the agent CLI in from anywhere when a session asks for it, and give the feedback widget your own theme and labels.

Share a machine with your team: mark a server device as shared and teammates can start coding sessions on it, each run owned and steered by whoever started it.
Remote sign-in: when the agent CLI on a remote machine needs a login, the sign-in link surfaces in the live session feed so you can authorize without walking over.
Widget themes and labels: the feedback widget takes light, dark, or auto themes with custom colors, and reporters can tag their feedback with labels you pick.
Create actions anywhere: a New action button on the Agents page starts the creator run that writes the action for you.
Consistent move confirms: moving an issue to another board asks the same way from the list menu and the detail sidebar.

One settings page, API keys, and a skill for your agents

2026-08-07

Team and account settings merge into one page with a settings button next to your name, personal API keys get a self-service section, and agents can read SKILL.md and set custom statuses over MCP.

One settings page: account, notifications, and API keys now live in a Personal group inside the settings page, on web and desktop, and the web settings button moved to the sidebar bottom next to your name.
Personal API keys: create and revoke expu_ keys under Settings, for MCP clients, scripts, and non-interactive CLI logins via EXP_TOKEN.
Custom statuses over MCP: agents can list a team’s statuses and set them precisely with statusId when updating issues.
SKILL.md for agents: exponential.at/SKILL.md gives any coding agent the full picture of the product, the MCP server, the CLI, and the feedback widget.
CLI sign-in: password login is gone; use the device code flow, or an API key via EXP_TOKEN for scripts.

Rename boards, attach pictures to feedback

2026-08-05

Boards can be renamed in place, the feedback widget accepts picture attachments, and machines with an outdated daemon get a one-click update button.

Rename boards: a gear on the sidebar board row opens board settings, so owners can rename a board without leaving the list, on web and desktop.
Pictures in feedback: the feedback widget now takes up to three picture attachments alongside the screenshot, and large submissions no longer fail with an opaque network error.
Update your machines: the machines list shows an Update button for devices running an outdated daemon, and it triggers the self-update remotely.
Issue page polish: the assignee name no longer gets cut off mid-word, long label names ellipsize in the sidebar, and status pickers list statuses in their settings order.

Issue links become chips

2026-08-05

Issue references render as live status chips, the issue page gets a cleaner header with a sticky toolbar, and dropped files land right where you drop them.

Issue link chips: #ABC-123 references in descriptions and comments now render as chips showing the linked issue’s status, on web and desktop.
Cleaner issue page: the title and formatting toolbar stay pinned while you scroll, and the desktop app folds the old right sidebar into a compact header.
Drop files in place: files dragged into the editor insert at the drop position, and images can be dragged to reorder them.
Activity feed: a “created the issue” row now leads the timeline.
Desktop: the About page’s licence notices no longer freeze the app while opening.

The desktop app finds your tools on Windows

2026-08-05

Windows now picks up a freshly installed git or Claude without a restart, background git calls no longer flash console windows, and sign-in shows the right methods immediately.

Windows tool detection: Check tools now sees a just-installed git or Claude without restarting the app, and the native Claude installer’s claude.exe is found reliably.
No more console flashes: background git and probe commands on Windows run hidden instead of flashing terminal windows.
Sign-in without the flash: the desktop login no longer shows a password form briefly before the real sign-in methods load.
Search dialog: the desktop search dialog is dismissable by clicking outside and keeps a sensible height on long result lists.

Mobile stays signed in

2026-08-04

The iOS app no longer loses your session on restart, the mobile multi-select bar floats above the bottom menu, and the welcome screen signs you in directly.

Staying signed in: the iOS app could lose its session on every restart. The cause is fixed and the release pipeline now verifies every build before upload.
Floating multi-select: selecting issues on iOS and Android no longer pushes the list down; the action bar floats above the bottom menu.
Direct sign-in: the mobile welcome screen shows Continue with Apple and Google immediately, with self-hosted servers one tap away.
Share sheet polish: sharing into the app while signed out no longer shows two Cancel buttons.

Run coding agents on your own servers

2026-08-03

The new exponential CLI turns any Linux or macOS machine into a registered agent runner: install with one command, sign in with a device code, and start sessions on it from the web.

The exponential CLI: a headless companion to the desktop app. Install it with one command, sign in with a device code from any browser, and run coding sessions and actions from your terminal with the same three agents.
Registered machines: every client now shows all of your machines, desktops and servers alike, with live online state, a last-seen time when offline, and each machine’s version. Rename or remove them from the overflow menu.
Add server: a copyable one-liner installs the CLI on a server and registers it to your account; the daemon picks up remote starts exactly like the desktop app, including live steering and activity.
Stays current: the CLI offers automatic updates on first run, restarts itself on new releases only while idle, and each server row has an Update button that triggers an update remotely.

Email digests keep to your schedule

2026-08-01

Notification emails now wait for your chosen digest hour, comment editing is author-only everywhere, and the Agents surface shows just your own sessions.

Digest timing fixed: notification emails no longer go out minutes after a notification arrives; the daily digest waits for your chosen hour and bundles everything still unread.
Author-only comments: editing and deleting a comment is now reserved for its author on every client.
Your agents only: the Agents list, tab dots, and counts show only your own coding sessions; the coding-now badge on issues still covers the whole team.
Mobile polish: switching boards refreshes instantly, action icon inputs use the curated icon picker, comment rows lost their stray padding, and the Android app is a smaller download.

Mobile apps recover from a signed-out session

2026-08-01

If your session is removed on the server, iOS and Android now return you to the login screen instead of getting stuck on an error.

Session recovery: when the server no longer recognizes your session (for example after an account was removed), the mobile apps now sign that account out locally and land on the login screen, matching the desktop app.
Onboarding escape hatch: the first-run wizard’s error cards gained a Sign out button, so a connection stuck on an error is never a dead end.

Smoother GitHub connect and steadier steering

2026-08-01

Connecting GitHub from mobile now continues straight to the install page, remote steering question cards stopped jumping, and copy got a polish everywhere.

GitHub connect on mobile: if the GitHub app isn’t installed yet, connecting from iOS or Android onboarding and settings now continues straight to the install page instead of stopping on an error.
Steadier steering: question cards from remotely steered coding sessions no longer jump or go missing when the terminal picker overflows the pane.
Polish: crisper avatar initials on mobile and clearer wording across all apps, the widget, and the marketing site.

July 2026

About screens with open-source acknowledgements

2026-07-31

Every app now has an About surface: version, source and license links, and the full third-party license notices bundled with that build.

About everywhere: the desktop IDE (Settings → About), iOS and Android (Settings → General → About) and the web app (user menu → About) now show what you’re running, with links to the source code and the Apache-2.0 license.
Third-party licenses: each build ships and displays the complete license notices for the open-source components it bundles; on the web they’re also downloadable at /NOTICES.txt.
Version at a glance: desktop and mobile show their build version right on the About row.

Watch and steer Codex and Pi sessions

2026-07-31

Codex and Pi coding sessions now stream a live activity feed (prompts, tool calls, questions, diffs) and take steering messages from web and mobile, just like Claude.

Codex sessions go live: watching a Codex session from web or mobile now shows the agent’s narration, tool calls, your prompts, and worktree diffs as they happen, instead of an empty feed. Codex questions appear as cards in the feed; answer them by replying in chat. Approval prompts are still answered in the desktop terminal.
Pi sessions too: Pi sessions report the same live activity, and steering messages are delivered through Pi’s own message queue. Sent mid-run they arrive at the next tool boundary; sent while idle they start a new turn.
Needs-input badges everywhere: Codex and Pi sessions now flip the “Needs input” badge when they finish a turn or wait on a question, so you can tell from any device when the agent is parked.

Pick exactly what GitHub connects, and when email arrives

2026-07-31

The GitHub claim page now links and unlinks installations in one save, email digests arrive at your preferred hour in your timezone, and the desktop IDE got sturdier session and repo management.

GitHub claims, refined: connecting GitHub now shows every installation you control and saves links and unlinks together in one step; the desktop app hands you straight back when you finish in the browser.
Digest hour: the unread-notification email digest now sends at your preferred hour in your own timezone. The desktop app picks up your system timezone automatically; adjust both in notification settings.
Desktop IDE: “Merge and close” ends the session before merging, so Fix conflicts is available immediately if the merge fails; local repositories and worktrees are manageable from Settings, with live coding sessions protected from accidental removal.
First-party analytics on the cloud: app.exponential.at now measures its signup funnel with cookieless first-party counters; self-hosted instances record nothing. Details on the privacy page.

A guided start in the desktop IDE

2026-07-30

The desktop app now walks first-run users from team to board to a working toolchain, with a setup doctor that says exactly what’s missing.

First-run wizard: a fresh desktop install now guides you through creating or joining a team, setting up your first board (with optional GitHub repository connect), and getting your coding tools ready, so you never land in an empty window.
Setup doctor: Settings → Tools gained a doctor panel that probes git and every coding agent (Claude, Codex, Pi), with per-tool install hints and inline path overrides. The onboarding tools step uses the same panel, and existing installs see it once after updating.
Honest start-coding buttons: with no agent installed, Start-coding affordances are disabled with an explanation instead of failing later, and the device stays out of remote-start pickers until an agent is available.
Clone failures surface: a failed repository clone now shows its error and a Retry button in Source Control, and retries automatically once git is installed.

GitHub connections that fix themselves

2026-07-30

Stale GitHub links now heal on reconnect, fresh installs stop losing their repos, and adding a repository got an explicit Add button with visible errors.

Stale links heal themselves: a leftover connection to a GitHub account you don’t control (and the eternal “Reconnect GitHub” warning it caused) is now cleaned up automatically the next time you reconnect, and the warning names the affected account. The account list, with its disconnect button, stays visible while the warning shows.
Fresh installs keep their repos: connecting a brand-new GitHub installation could race GitHub’s own bookkeeping and come back with zero repositories until a manual reconnect. The connect flow now rides that out.
A real Add button: the Add-repository dialog selects on click and connects via an explicit Add repository button; failures show inside the dialog instead of vanishing with it, and the double-scrolling is gone.
Suspended installations say so: all four apps now distinguish a GitHub-side App suspension (fix it on GitHub) from a stale connection (reconnect), instead of nudging the wrong fix or, on desktop, showing a bogus “repository limit reached” upsell.
Mobile connect works signed-in-natively: connecting GitHub from iOS/Android no longer requires a separate web login in the in-app browser, and every connect outcome hands you back to the app.

Self-hosted by default, no more special boards

2026-07-30

Fresh instances start truly empty (no seeded teams, boards, or widgets), and self-hosted mode no longer needs a flag.

Self-hosted is the default: the SELF_HOSTED flag is gone; every plan limit is off unless the deployment explicitly opts into cloud mode. Existing self-host setups keep working without changes.
No seeded content: the boot-time feedback team, board, and widget bootstrap has been removed entirely. What you create is all there is.
Protected boards are gone: every board behaves the same now. Owners can delete any board, and its repository can always be changed.

GitHub connections locked to owners

2026-07-30

Connecting GitHub now requires owning the installation. Collaborator access on someone else’s repos can no longer claim their account for your team.

Ownership-verified connections: connecting GitHub to a team now proves you control the installation. Personal installations must belong to the GitHub account you authorize, and organization installations require an active org membership. Being a collaborator on someone else’s repository no longer surfaces their account or repositories in your team.
A way out of every dead end: if the account you authorized has no installation of its own, the connect flow now explains exactly what happened and offers a one-click Install on GitHub button that takes you to GitHub’s account and repository selection.
One-time approval for organizations: the GitHub App now asks for read-only organization-members access (used solely to verify your membership); org installations need to approve the updated permissions once.

Merges unstuck

2026-07-30

Cloud PR merges could fail with a database error. That’s fixed, and finished subagent tabs now tidy up after themselves.

“Merge and close” works again: a skipped schema migration made every PR merge on the cloud fail with a database error (and left the session’s terminal open). The migration now applies correctly, and a new guard test keeps migration ordering honest so this class of bug can’t sneak back in.
Subagent tabs clean up: completed subagents (like quick explore runs) no longer linger in the desktop session view after they finish.
A fresh coat of paint for the homepage movie: the exponential.at hero video now matches the app’s glassy design, pixel for pixel.

Sessions survive the merge

2026-07-29

Merging a PR no longer kills the coding session. Close it when you’re done, with the new “Merge and close” button.

Merge without losing the session: merging an agent’s PR used to end its coding session immediately. Now the session parks in a new Merged state and stays fully alive: keep steering it, ask follow-up questions, or let it finish cleanup.
“Merge and close”: every live session row (web, desktop, iOS, Android) gets an explicit button that merges the PR and tears the session down in one step, for when you really are done.
All other merge buttons are now merge-only and leave the session running.

Watch subagents work, live

2026-07-29

Agent sessions show every subagent as its own tab on web, desktop, iOS, and Android.

Subagent tabs: when your coding agent fans out into subagents, the live session view gives each one its own tab with a readable name and its tool activity, instead of a flood of anonymous “agent” cards. Works on all four clients.
Queued follow-ups show up: messages you send while the agent is busy now appear in the session feed instead of vanishing until the agent picks them up.
A steadier “Needs input” badge: the desktop no longer flags a session as waiting while a background subagent is still working, and the badge retries until it lands.
Live images in the IDE: images in issue descriptions render the moment their upload finishes, including ones pasted from another device.
Actions remember their repository: running a saved action pre-fills its bound repo in the run dialog on every client.

Exponential is now open source

2026-07-29

The whole repo moved to Apache-2.0. Self-hosting is free for everyone, with optional Enterprise Support.

Apache-2.0, fully open source: the Exponential Small Team License is gone. Read it, change it, and self-host it in production for free, at any company size.
No more headcount math: the 10-person limit and the mandatory commercial license are deleted. Nothing changes for cloud plans.
Enterprise Support is now an optional add-on: self-hosters who want an SLA, priority support, deployment help, or custom development can get a support contract at the same published prices.
One honest caveat remains: self-hosted instances can’t push notifications to the store mobile apps (they’re built against our Firebase project). Web and desktop are fully featured either way.

Self-host with one docker compose

2026-07-29

A pinnable self-host image with an agent-followable install guide, a customer billing portal, and a faster desktop IDE.

Self-hosting is now a docker pull: the cloud and self-host builds are the same published image, pinned by version, with a minimal compose file and an INSTALL.md your coding agent can follow end to end. Free for companies under 10 people.
Manage billing yourself: team owners can open a customer portal from team settings → Billing to view invoices and update payment details.
Answering agent questions from your phone is reliable now: plan approvals and question picks from iOS/Android land on the desktop with a visible confirmation, and retry automatically instead of silently vanishing.
Desktop IDE polish: git history on big repos scrolls smoothly, a merged PR pulls master onto every IDE immediately, a parked trunk (detached head, local commits, dirt) now says so instead of going silently stale, and the repositories settings page looks the same on every platform.
Attach any file straight from the editor toolbar on web and desktop.

New pricing: bring two friends

2026-07-28

The free plan now has 3 seats, and the paid tiers collapsed into one Team plan with everything included.

Free is a team now: every free team gets 3 seats instead of 1, with the same 250 MB of attachment storage and a feedback widget. Real-time collaboration is the point of Exponential; now you can try it without paying.
One paid plan: Pro and Business merged into a single Team plan at €15/seat/mo, or €12/seat/mo billed yearly. Everything is included: 10 GB attachment storage, unlimited feedback widgets, the helpdesk & support inbox, and priority support. Existing complimentary tiers carry over automatically.
Self-hosting stays free under 10 people, and commercial self-host licensing now has published pricing instead of “email us”.
Enterprise needs (SSO, SLA, DPA, self-host contracts) live behind one Talk-to-us line instead of a fourth plan card.

One way to attach, on every screen

2026-07-28

Mobile stops asking whether a file is an image, and the issue page loses its clutter.

One attach button on iOS and Android: attachments arrived with their own paperclip next to the description’s image button, so adding something to an issue meant guessing which of two gestures to use, and picking an image through the paperclip dead-ended in an error. The description toolbar’s button now offers Files or Photo library and sorts the pick itself: an image goes into the description, anything else becomes an attachment. The paperclip is gone.
New issues take files too: attaching a file while composing a new issue now holds it as a draft and uploads it the moment the issue is created, exactly like draft images already worked.
No more empty Files block: an issue with nothing attached shows nothing at all instead of a permanent “No files attached” row. Failed uploads still show up so you can retry them.
A calmer issue page: the rule above Activity now spans the full pane on web and desktop, the linked PR row runs the full width instead of hugging its text, and the mobile issue menu is a single … that holds Share, notifications and Move to board, with words instead of an ambiguous bell.
Status settings say less: the issue-statuses pane dropped the explanatory paragraphs the rows already made obvious, the two cards no longer sit flush against each other, and the PR-automation pickers line up.

Statuses that match how you work

2026-07-28

Build your own issue statuses per team, and decide what opening or merging a PR does to them.

Custom issue statuses: a team can now add its own statuses next to the seven built-in ones. Each new status picks a category (Backlog, Unstarted, Started, Completed, Cancelled), a name and a color; up to four Started statuses get their own progress-clock icons. Built-ins stay put (they can be reordered inside their category but never renamed or deleted), and every app groups, sorts and filters by your statuses identically. Manage them in team settings on web or in the IDE.
Deleting a status always asks where its issues go: one consistent dialog on web and desktop, with the real count of affected issues (including issues on boards in the trash, which your apps never see).
PR automation is yours to configure: opening a PR moved issues to In Review and merging completed them. Now each team picks which status a PR open or merge sets, or turns either off entirely. The defaults are unchanged, so nothing moves unless you change it.
Merge failures you can actually read: a merge that hits a conflict now says so inline on web, iOS and Android, right where you tapped, with a Fix conflicts button beside it instead of a message hidden behind the navigation bar.
Issue chips in the mobile editors: typing #EXP-42 in a description on iOS or Android now renders as a chip with the issue’s title, and the # suggestion list stays where it belongs and can be dismissed.
Consistent icons everywhere: the settings pages in the web app and the IDE now draw from one shared icon set, so the same section no longer wears two different glyphs.
Desktop IDE: terminal tabs of a coding session show the issue’s status, identifier and live title, and reveal a Merge PR button on hover; the tab strip now runs to the right edge and only collapses into “+N” when a tab genuinely does not fit.

Attach any file

2026-07-27

Issues now take PDFs, videos and other files, plus seamless steering and a rounder IDE.

Attach more than screenshots: issues and comments now take any file up to 50MB. PDFs, videos, audio, logs, archives. A new Files section on the issue collects them, and team owners get a Storage pane in settings that shows what is using space and can sweep images nothing references anymore.
Steering without ceremony: the “Remote steering” banner and its Take over button are gone. A live coding session is now visible and steerable only from the account that started it; teammates see the synced status badge instead. Update your apps. Builds from before this release degrade to a read-only view of their own sessions until updated.
Issue chips show their title: a #EXP-42 mention now renders the issue’s title alongside the identifier in every editor and comment, and typing => or -> turns into a real arrow.
Safari menus fixed: dropdown submenus (like Delete issue → Confirm delete) were invisible in Safari.
Desktop IDE polish: tab chips show issue identifiers with smarter overflow, your account avatar shows up in the rail, dialogs feel native on every platform, and a conflicted issue offers its Fix conflicts button right on the detail page.

Current the moment you open it

2026-07-27

Opening the app used to show ten-second-old data. All three apps now sync over one connection instead of fifteen.

No more ten-second wait: opening iOS, Android or the desktop app showed you the state from before you closed it, and only caught up around ten seconds later. Each of the fifteen synced tables was opening its own connection, so every launch fired fifteen simultaneous DNS lookups and TLS handshakes at once. Enough of them failed that the retries were the delay. All three apps now put every table on a single HTTP/2 connection.
A VPN or a waking radio costs a second: a connection that is not usable yet used to be treated like a server error, parking sync on a backoff of up to thirty seconds long after the network had come back. Those failures now retry immediately, and Android additionally wakes sync when a VPN finishes connecting.
“Syncing…” tells the truth: on Android the indicator used to disappear on a fifteen-second timer whether or not anything had synced, and pull-to-refresh always spun for a full five seconds. Both now finish as soon as the server confirms you are up to date.
Smaller downloads: sync responses are compressed for clients that support it, which mostly shows up the first time a device populates its cache.

Your plan belongs to the team

2026-07-27

Deleting an account no longer cancels a shared team’s paid plan, and you can cancel a subscription in-app.

A shared team keeps its plan: deleting the account of whoever bought the subscription used to cancel it immediately, dropping the team to Free mid-period with no warning. A subscription belongs to the team now: it keeps running and the remaining owners keep managing it. Only a team that is deleted along with its last member takes its plan with it.
Cancel (and un-cancel) in the app: team settings → Billing gets a Cancel plan button that ends the subscription at the end of the paid period, shows the date it lapses, and lets you resume before then.
Delete a team, cancel first: deleting a team with a live subscription is refused with a message pointing at Billing, instead of quietly leaving a subscription behind that nothing could reach.
Nothing breaks when someone leaves: images they uploaded into your issues stay where they are instead of turning into broken embeds, and mentions of their email address are replaced with a neutral handle.

One icon set, everywhere

2026-07-26

Every icon is now the same on web, iOS, Android and desktop, and actions get an icon of their own.

The same icons on every device: search, inbox, reviews, agents, support and settings used to be drawn from a different icon library on each platform, so the same thing looked different depending on where you opened it. All four apps now render one shared set. Android changes the most.
Board icons you can actually pick: the picker grew from 16 icons to 60, with a search field, and every one of them draws the same glyph on every device. On the desktop app 11 of the old 16 were quietly substituted with the nearest available shape (a bug was a dot, a wrench was a pencil, and “terminal” drew the same icon as “code”). They are all correct now.
Actions have icons: give an action its own glyph so a long list stays scannable. The “Create action” flow asks for one up front, and you can change it later from the action’s editor.

Settings that fit, tabs that remember

2026-07-26

The desktop IDE gets a real settings section, tabs that remember where you opened them from, and a Linux window that stops shrinking.

Settings, restructured: every board gets its own settings page with web parity (name, icon, color, repository, an honest 48-hour move-to-trash), the coding pane splits into Tools and Agents, and a read-only Plan & Billing card shows seats, storage and widget usage at a glance.
Pick your terminal shell: a new setting chooses which shell the embedded terminal spawns; leave it blank for the platform default.
Tabs remember where they came from: clicking a tab re-selects the sidebar entry (and board) it was opened from, issue tabs carry the issue title instead of just the identifier, and chips that no longer fit collapse into a “+N” menu.
Calmer dialogs: the new-issue dialog opens compact and grows with what you type, the caret stays visible while typing or pasting, and the Start-coding dialog’s Cancel/Start bar stays pinned instead of scrolling out of reach. Status, priority, assignee, label and due-date pickers are shared with the sidebar now, so the dialog’s label picker finally has search.
Linux windows behave: the main window no longer shrinks 24px on every launch on X11, and all four corners are genuinely round instead of hiding square notches behind the arc.
Real glass: the desktop blurs what sits behind it on macOS and KDE Wayland, and the bulk-select bar floats over the list instead of shoving every row down.

Sessions that survive a closed lid

2026-07-26

A sleeping laptop no longer kills a running coding session, desktop dialogs are real windows, and the IDE’s left rail can show its labels.

Your coding session survives sleep: a laptop that slept (or a network that stalled) for more than 90 seconds used to make the desktop tear down the terminal and kill the agent the moment it woke. The connection dropping is now treated as what it is (a dropped connection), and the session reconnects instead.
Dialogs are real windows: new issue, start coding, search, create board/team, image preview and every confirm now open as native windows, a sheet on macOS and a proper owner-modal window on Windows and Linux, each with working Escape, Enter and close button.
A rail that can speak: the desktop’s left rail expands to show labels next to the icons, and remembers the choice. Settings take over the tool column as their own screen instead of a cramped panel.
Select text like text: dragging in an issue description selects from the click that entered the editor, double-click picks a word, triple-click a line, and clicking beside a block puts the caret where you aimed.
Readable terminal colors: terminal output painted in ANSI black was effectively invisible on the dark background; it now sits well above the contrast floor.
Sharper badges on iOS: count badges and the selected agent chip use the stronger indigo, so their white text clears the accessibility contrast floor.

Glass, second coat

2026-07-26

Menus read clearly over busy content, actions get a screen of their own in the desktop IDE, and you can finally type in the space around an image.

Legible menus: dropdowns, context menus and popovers are far less see-through, so a menu opened over a dense issue list stays easy to read. Highlighted rows use the same glass wash as the rest of the app.
Actions have a detail screen: open an action in the desktop IDE to read its full prompt, see its repository and inputs, and edit or run it from one place instead of a cramped list row.
Tabs moved into the titlebar: the desktop IDE reclaims a row of vertical space, and terminal tabs scroll instead of pushing the controls off screen.
Type around images: click or arrow into the space above, below or between images in an issue description and just start typing.
Small fixes: keyboard-shortcut hints in tooltips are readable again, and the mobile editor toolbar no longer grows a scrollbar in Safari.

A new coat of glass

2026-07-25

Web and desktop now match the mobile apps’ glass look: a dark gradient backdrop, frosted panels, rounder corners, indigo accents, and the desktop draws its own window chrome.

Glass everywhere: popovers, dialogs and sheets float as frosted panels over a fixed dark gradient, on web and in the desktop IDE.
Rounder, calmer chrome: corners follow the mobile radius ladder, small buttons and sidebar items are capsules, and the sidebar melts into the backdrop with an indigo-tinted active state.
Denser lists, softer lines: issue rows keep their density but get hairline dividers, a glass hover wash, and blurred sticky group headers.
One indigo: the accent color is now a shared design token across web, desktop, iOS and Android.
Desktop window chrome: the IDE draws its own titlebar with embedded window controls on macOS, Windows and Linux, with rounded corners and a proper shadow on Linux.

Answering the agent, properly

2026-07-25

Questions from a coding session now arrive as a real stepper (one at a time, with descriptions, multi-select and a submit step), and answering locks the card instead of guessing keystrokes.

A real question stepper: a run that asks you several things now shows one question at a time with “2 of 3” progress, per-option explanations, multi-select toggles, and a final review step with a “Submit answers” button. Answered questions collapse behind what you picked.
Answers land where you meant them: an answer is sent as an answer, not as raw keypresses, and the agent confirms it. Tapping an option locks the card instantly, so one tap can never spill over into the next question.
Plans always read as plans: a plan waiting for approval is rendered as formatted text every time, and it stays waiting until you actually answer it. Sending a message mid-plan no longer makes the approval buttons disappear.
See what the subagents did: work an agent hands to a subagent groups under its own expandable row, and permission prompts show up as their own line in the feed.
A feed that survives reconnects: reconnecting no longer blanks the session view; the desktop republishes the full history and the feed only clears when it is genuinely replaced.

Merge conflicts fixed for you, widgets that ask for less

2026-07-25

A one-click action rebases and merges a conflicted pull request, actions sync live everywhere, and the feedback widget can collect a name and your own custom fields.

“Fix merge conflicts”: a built-in action that takes a conflicted pull request, rebases it onto your default branch, resolves the conflicts, pushes, and merges it, completing every issue on that PR. Start it from the desktop Reviews list or from any client’s launch dialog.
Merge from the sidebar: an open pull request can now be merged straight from the issue sidebar on web and desktop. Merging ends the issue’s live coding session instead of leaving a terminal running.
Actions sync live: your team’s actions now arrive on every client the moment they change, and running one no longer asks each device to trust it first.
Widgets can ask for a name: the feedback widget can collect a reporter’s name without demanding an email, define up to eight custom fields of your own, and be driven entirely from your own UI with the new submit() API.
Roomier dialogs: the action editor, widget settings, launch and issue dialogs use the width of your screen instead of stretching into tall towers.

One dialog for starting anything

2026-07-25

Issues and actions now start from the same dialog on every client, actions can ask for inputs, and mobile sync catches up the moment you open the app.

One launch dialog: “Start coding” and “Run action” merged into a single dialog with Issues and Actions tabs, sharing the same device, agent, model, effort and toggle options. Actions finally get the full option set instead of running on defaults.
Actions can ask for inputs: an action can declare text, repository and board inputs, and the dialog prompts for them before the run starts. Values are resolved and checked against your team on the server.
Actions moved into Agents: the separate Actions page is gone; your actions now live alongside your desktops on the Agents page, with a built-in “Create action” card that writes a new action for you.
Faster mobile sync: iOS and Android now catch up immediately when you open the app, regain a connection, or receive a push, instead of waiting out a stale poll. Opening an issue from a notification no longer strands you on a blank loading screen.

2026-07-25

The desktop description editor gains the same formatting toolbar as the web, and text and images finally lay out properly.

Formatting toolbar: headings, bold, italic, strikethrough, code, links, quotes, bullet, numbered and task lists, clear formatting and insert image, all sitting above the description exactly as on the web. Press a button with nothing selected and the next thing you type comes out formatted.
Links stay links: putting the cursor inside a link no longer turns it back into raw markdown; edit its address from the toolbar instead.
Readable descriptions: text is sized to match the rest of the app, and wrapped paragraphs no longer overlap the ones below them.
Image controls on the image: a “…” menu at the picture’s corner and a drag handle on each of its edges, instead of controls stranded at the far side of the column. Dragging back to full width clears the custom size again.

A real editor for issue descriptions on desktop

2026-07-24

The desktop app now edits descriptions as formatted text. Headings, lists, tables and images render as you type, instead of raw markdown.

WYSIWYG descriptions: the desktop editor shows your formatting live while you type, with headings, bold and italics, bullet, numbered and task lists, quotes, code blocks, links, tables, and inline images.
Images inline: paste a screenshot straight into a description and it uploads in the background; drag its corner to resize, or right-click to open, download, copy or delete it.
@ and # as you type: mentioning a teammate or linking another issue offers suggestions from the first character, and both render as pills you can click.
Your text stays your text: descriptions written on web, iPhone or Android now survive a desktop open untouched, down to the byte.

No more duplicate labels, dialogs that fit your phone

2026-07-24

Duplicate label names are blocked (existing ones merged), dialogs go full-screen on mobile, and the desktop IDE gets link copying and a full-width diff view.

One label per name: creating a label whose name already exists in the team (regardless of casing) is now rejected with a clear message on every client, and pre-existing duplicates were merged automatically.
Dialogs on mobile: every web dialog now opens as a full-screen page on small screens, and the Start-coding dialog got a two-column layout that finally fits without double scrollbars.
Desktop IDE polish: copy a link to any issue from its header, start coding straight from the properties sidebar, and see inline images in descriptions just like on the web.
Full-width diffs: the desktop Source Control view drops the per-file column so commit diffs get the whole pane.

Actions: reusable AI commands for your team

2026-07-24

Define reusable AI prompts (code review, backlog grooming, changelog drafts) and run them on your desktop from any device.

Actions: every team gets a library of reusable AI prompts. Create one from a template or let Claude write it from a one-line description, then run it with one click from web, desktop, iOS, or Android. It executes live on your own computer, and you can watch and steer it like any coding session.
Templates included: a code review that files issues, backlog labeling and prioritization, and changelog drafting.
Safe by design: actions run only on your own machine under your own accounts and sign-ins, and each device asks you to approve an action’s exact instructions before the first run (and again whenever they change). The server never stores secrets.
A leaner desktop IDE: boards now live as icons in the left rail, the top bar is gone, and source control went master-only with automatic pulls. Your local copy quietly tracks the default branch, changes arrive via pull requests, and one button discards local changes if things get tangled.
Run configs retired: the old per-board terminal commands are replaced by actions.

Multi-select everywhere, a cleaner review flow

2026-07-23

Pick several issues at once on every client, a reworked review screen on mobile, and a tidier issue list.

Multi-select refinements: selecting several issues at once got faster and more predictable on the web, the desktop IDE, iOS, and Android, and the bulk action bar now matches across all of them.
Reworked review screen on mobile: merging and closing a pull request moved into a bottom action bar on iOS and Android, so the controls sit where your thumb is, and the file diff opens collapsed so big PRs load instantly.
Steering that reconnects: the live agent terminal on iOS and Android now reconnects on its own after a dropped connection instead of stranding you on a dead screen.
Issue list alignment: identifiers line up in My Issues and search results the way they always did on a board.

Browser AI agents can now work your boards

2026-07-23

The web app speaks WebMCP: in-browser AI agents can read your boards, file and update issues, comment, and navigate for you.

WebMCP support: the web app now registers page tools via the emerging WebMCP browser standard, so AI agents running in your browser (Chrome’s built-in agent, MCP browser extensions) can work with what’s on screen.
Read and act as you: agents can look up your boards, list and search issues, read full issue threads, check your inbox, create and update issues, comment, manage labels and subscriptions, and jump to any view, always as your signed-in user and only in teams you’re a member of.
Nothing new is exposed: tools reuse the exact same permissions and APIs as clicking the UI yourself.

Redesigned issue view on mobile, live support chat

2026-07-23

A reworked issue screen on iOS and Android, start coding from your phone, and live support conversations.

Reworked issue detail on mobile: iOS and Android get a cleaner issue screen with a bottom action bar, tidier property and label pickers, due-date and assignee sheets, and a collapsible activity timeline.
Start coding from iOS: kick off a coding session on a connected desktop straight from the iOS app.
Live support chat: when a reporter has their support thread open, replies appear live and we hold back the email notification while they’re watching.
Resizable web terminal: drag to resize the agent panel on the web, and it remembers your height.
Desktop IDE tabs: closing, middle-click, and right-click on editor tabs now feel like a real IDE.
More reliable email: hardened transactional email with automatic bounce and complaint handling.

Faster sync, tighter security, keyboard-driven search

2026-07-22

A reliability, performance, and security pass across every client.

Snappier real-time sync: reworked how boards, issues, and notifications sync so large teams stay fast and connections recover cleanly under load.
Keyboard-driven search: global issue search (⌘F on the web) now supports arrow keys to move and Enter to open a result.
Clearer billing errors: checkout and billing-portal buttons now surface a message when a request fails instead of doing nothing.
Security hardening: signing out now fully ends your session on the server, and we closed a case where an image link could carry your session token to another site.
Desktop IDE polish: fixes to issue-title editing and description layout.

2026-07-21

Issues filed through the embeddable feedback widget now carry a clear “Feedback widget” label.

Feedback widget label: issues that arrive through your embeddable widget now show a “Feedback widget” origin pill on the issue, on web, iOS, Android, and the desktop IDE.
No more hidden bot users: feedback used to be filed by a synthetic per-widget user that could show up in member lists; those are gone. Widget-filed issues simply have no sender, and everything (member lists, seat counts, account deletion) treats them cleanly.

Invites now live on the web

2026-07-21

Team invites are created here on the web. Invite links still open and join right inside the mobile apps.

Invite from the web: the iOS and Android apps no longer create invites. Invite teammates under Settings → Members, and the link you share still opens and joins directly in the app.
Clearer storage errors on mobile: when a team is out of attachment storage, image uploads now say so and offer a retry instead of retrying forever.
Privacy policy refresh: it now covers Sign in with Apple, the legal bases and your rights under the GDPR, international transfers, and the 48-hour board trash.

See when an agent needs you

2026-07-21

Coding sessions waiting on your input now show an attention badge on every client.

Needs-input badge: when a coding agent parks on a plan approval or a question, the session is flagged everywhere. The Agents tab and nav badges on web, iOS, Android, and the IDE light up until you answer.
Start-coding polish: reworked agent and model pickers in the Start-coding dialog on web, the IDE, and the mobile sheets.
Smoother steering on iOS: answering agent questions and plan approvals in the session view got a cleaner flow.
Marketing + pricing refresh: updated agents section and plan pages at exponential.at.

2026-07-20

Feedback widgets now always require a domain allowlist, and the mobile agent picker got a visual refresh.

Widget keys are locked to your domains: the “allow any website” mode is gone. Every widget config needs at least one allowed domain, and keys without one stop serving until you add it in Settings → Feedback widget.
Mobile Start-coding refresh: agent icons, per-agent options, and a cleaner repository picker on iOS and Android.
IDE fixes: window sizing polish and coding-flow refinements.

Pick your coding agent, and resume where you left off

2026-07-20

Start coding sessions with Claude, Codex, or pi. Resume an earlier session instead of starting over.

Three agents: the Start-coding dialog now offers Claude, Codex, and pi, each with its own model and effort picks; your defaults are saved per agent. Remote starts from your phone only offer the agents actually installed on the chosen desktop.
Resume coding: reopen a finished or interrupted session and the agent picks up with its previous context instead of starting from scratch.
Guarded by default: Claude runs now default to the guarded auto permission mode instead of skipping permissions; the IDE doctor needs claude ≥ 2.1.215 for it (run claude update if coding shows as blocked).
IDE polish: long issue descriptions no longer get cut off in the IDE editor.
Smoother marketing film: the exponential.at intro video now autoplays reliably.

Answer your agent from anywhere, and sessions that wait for review

2026-07-20

Tap to answer agent questions from your phone, and coding sessions now show a “ready for review” state once the PR is open.

Steer from your phone: when an agent asks a question, iOS, Android, and web now show it as a tappable card. Pick an option (multi-select included) instead of typing keystrokes.
Ready for review: when the PR opens, a coding session moves to an in-review state across all clients instead of disappearing, so you can see what’s waiting on you.
Better tabs on mobile: My Work and Support switched to a cleaner segmented control on iOS and Android, and agent sessions open full-screen on the mobile web app.
Editing on phones: the issue description editor keeps your cursor visible above the keyboard while you type.
Fresh marketing pages: new agents, teamwork, and helpdesk sections plus clearer pricing at exponential.at.

Create or join a team, a merged inbox, and a mobile-friendly web app

2026-07-19

Pick your own first team, My Issues lives in the Inbox now, and the web app works properly on phones.

Create or join: new accounts no longer get an auto-created personal team. On first launch you create a team (you own it) or join one by pasting an invite link; invites can now also be emailed directly.
One inbox: My Issues merged into the Inbox as a tab on web and in the IDE, so notifications and your assigned work live on one page. Support gets an unread badge on every client.
Web on your phone: a bottom tab bar, mobile-sized layouts, and detail pages that use the full screen.
Fixes: desktop steering activity works again, Android keeps the helpdesk entry after partial syncs and refreshes repositories after board creation, and the IDE got a round of polish.

Boards, a simpler helpdesk, and a private-by-default product

2026-07-19

Projects are now boards, the helpdesk moved to one team-level inbox, and public boards are gone.

Projects are now boards: same power, clearer name, on web, mobile and the IDE.
Public boards are gone: nothing in a team is readable from outside anymore. The feedback widget is the one way outsiders reach you, and it’s now included on every plan (1 widget on Free, 3 on Pro).
One helpdesk per team: flip a single switch under Settings → Feedback widget (Pro+) and every member shares the Support inbox. Tickets are standalone conversations with an email reply loop, and any ticket can be escalated into an issue on a board with one click.
Simpler board creation: no more board types. A board is a board; connect a repository when you want to code on it.

A changelog, mobile coding, and support inboxes

2026-07-17

Start coding from your phone, helpdesk widget mode, and this changelog.

What’s new lives here now: each release drops a note in this changelog. Dismiss the card and it stays quiet until the next release; reopen it anytime from the user menu.
Start coding from mobile: the iOS and Android apps can now remotely start coding sessions on your desktop, including batch runs.
Support inboxes: the feedback widget gained a helpdesk mode, so support tickets can file into a separate private inbox, away from your feedback board.
Steering polish: stale steering sessions are cleaned up reliably, and the web agent dock and review views got a refresh.

Changelog

November 2026

End-to-end encrypted, in plain words

MCP servers on your own machine

Apps with several screens

Import spreadsheets into apps

Steadier live sessions, apps that work offline

Undo and history for app records

Computed fields in apps

Publish apps when they are ready

Built-in skills for apps, UI and Motion

Sessions start fast again

App buttons work on desktop

Reliability fixes

Team skills

Exponential tools in groups

Voice works on Windows

App actions save all or nothing

Apps look the same everywhere

Passkeys on your iPhone

Subagents and menu values

Desktop confirms fit their content

Persist login

Keep signed in, fixed

Sessions keep track of their work

Live chats stay smooth

Owners can enter records for others

Records belong to their author

Animations in agent cards

Sessions move to your other machine

Usage for Keep signed in logins

CI checks on the Merge pill

Work never stays on one machine

Zoom into pictures

Claude stays signed in by default

Dismiss a question or plan

Wide tables scroll

Long plans scroll smoothly on desktop

A wider chat

The new-chat screen looks the same everywhere

Chats look the same everywhere

Devices as cards

Settings and lists tidied up on every platform

Desktop looks like the web app

Agents get the issue you hand them

Agents encrypt their messages from the start

Signed-out logins reach your inbox

Comments keep what you type while they send

A child’s tasks in the thread

Chats stay smooth and keep what you type

Keep a Claude login signed in

Agent logins stay signed in

Steadier live sessions

October 2026

Preview apps as a phone

App data in the editor

App editor tabs

Your apps, as MCP tools

Plans get their own page

New app opens the editor

Updates install within minutes

The live view stops flickering

Answering plans works again on desktop

Watching sessions connects on iOS and Android

Watching sessions works again on every app

Sidebar dots, the same everywhere

Sidebar indicators, lined up

The offline copy, everywhere

Worktrees and short session ids, fixed

Offline sessions reconnect on their own

The CLI follows sessions while its daemon runs

Sessions stream straight from your device

End-to-end encrypted session content

Questions push to your phone

Session rows open from a chat

Stories, tidied

Agent questions open from the inbox

Start coding keeps your issue

Calls say what’s missing

Stories step through every picture, and a steadier desktop