What's new in Fleet.

Images and modals open above the dock. A shown file or any modal now paints over the in-app browser dock instead of behind it. The dock view is parked while a modal is open and restored when it closes.

The sidebar no longer overlaps the chat. When the dock is open, the chat column reflows beside the sidebar instead of sliding under it, so the composer and the latest messages stay fully visible.

Long briefs no longer hit a length limit. When you set a worker on a big, detailed task, Fleet writes the brief to a file and attaches it to the worker's session, so nothing gets cut off and the brief stays on record as what the worker was asked to do. Older setups fall back to the previous behavior automatically.

GPT-6 Astra, ready when your account is. OpenAI released GPT-6 Astra on September 3, 2026, rolling out in phases. It leads the Codex picker under Settings, marked "not enabled on this account yet" until the Codex CLI's own model list shows it for your login. The day OpenAI enables you, the card lights up and Codex workers can run on it. Terra stays the default.

No more launching a Codex worker into a model it cannot use. Fleet reads the model list the Codex CLI caches for your account. A model that is not on it cannot be selected in Settings, is refused by the config command with a one-line reason, and stops a spawn with a plain message on the board instead of a worker that dies on its first turn. If the cache is missing, the eight known models keep working as before.

Codex errors read as Codex. A rejected Codex request no longer shows a Claude-worded message.

The Captain writes an intent before a bigger build, on by default. It asks you at most three questions that change the outcome, writes your answers into an intent file in your project, and briefs the worker from it. The worker's branch starts with a commit of that file, so every pull request from that worker carries what you asked for. Small changes the Captain can describe in one sentence skip the gate. Turn it off under Settings, Workers, "Write an intent before bigger builds." This follows Anthropic's AI-Native SDLC playbook, published August 21, 2026, which makes a committed intent the first artifact of every change. The gate lives in the running app, so restart Fleet after updating before you expect the questions.

Run details shows the model a worker actually launched on. The panel used to print one fixed model name for every Claude worker. It now shows the model the session really started with, says "asked X, got Y" when Fleet's availability fallback moved a worker down the chain, and says "not recorded" for workers from before this release rather than guessing.

Fleet's guide to itself is one tenth the size. The CLAUDE.md every worker reads had grown to 205,000 characters, past the point where Claude Code truncates it, so workers were reading a cut-off file. It is now 22,500 characters, and each section points to a topic page that holds the full detail. Nothing was lost. 123 lessons moved word for word, and a size budget stops the file growing back.

The header pill is gone. The Raw terminal button in the Captain header is removed. You open the pane from the ledge under the chat, labeled RAW TERMINAL (⌘T), and close it from a HIDE (⌘T) control on the pane's own bar. Clicking the label closes it too.

⌘T toggles the terminal. Cmd+T on Mac, Ctrl+T everywhere else, and Cmd+J as an alias if you are coming from VS Code or Codex. It works with focus in the composer or inside the terminal, never reaches the shell as a control byte, and ignores key repeat. A matching Toggle Raw Terminal item is in the app menu.

The shortcut only fires when there is a terminal to toggle. On screens without the Captain's terminal the key is left alone, so nothing else that uses it changes.

This release was a user request. A user asked for it in the Captain chat at 6:24pm ET on September 1, 2026. The fleet built it, a second model reviewed the change twice and found two real bugs, the shortcut being swallowed on every screen and Ctrl+T being taken from the terminal on Mac, and both were fixed before merge. The pull request merged at 7:07pm ET, 43 minutes after the request. The release was published at 7:24pm ET, 59 minutes after the request.

Claude Fable 5.1 is in the model list. Anthropic released it today, September 1, 2026, built for demanding reasoning and long-horizon agentic work, with a 1M token context window, up to 128K tokens of output, and adaptive thinking always on. Pick it for one project or for your whole fleet the same way you pick any other model. Fable 5 stays exactly where it was, so if you already have that selected, nothing about your setup changes. One note if you choose Fable 5.1 and it does not take: the model list is read by the running app, so restart Fleet after updating before you set it.

Opus 5 is still the default, deliberately. Anthropic's own guidance is to start with Opus 5 for most work and reach for Fable 5.1 when a job is genuinely long-horizon, or when Opus 5 at a higher effort has not been enough. Fable 5.1 also costs more per token and runs slower, so Fleet treats it as the escalation rather than the everyday setting and leaves your default alone.

The availability fallback starts one step higher. When a model is unavailable, Fleet walks down to the next one rather than failing. That walk now begins at Fable 5.1 and descends through Fable 5, Opus 5, Opus 4.8 and Sonnet 5.

An approval card says what is at stake, before you decide. When a worker wanted to do something destructive, Fleet showed you the command and the category it matched, such as "wants to delete files or data." That names the action and not the cost. Fleet now works out what the command would actually take and puts it on the card: how many files a folder holds and how many of them exist only there, or how many commits a force push would discard that live on no other branch. Clearing a build folder and deleting your notes no longer read the same. When Fleet cannot establish whether something is recoverable, it says so in those words rather than going quiet, because silence should never read as safe. The same sentence leads the message on your phone, where you have the least context to judge from.

A single worker's terminal renders sharp. With one pane open, the grid was magnifying the terminal to fill the space, which softened the text and showed you fewer lines of what your worker had done. It now renders at its natural size and centers, so you see more of the history and can actually read it.

Workers check the instructions they were given. A task written quickly can carry a wrong assumption, and a worker that treats it as fact builds carefully on a bad premise. Every worker is now told to verify the load-bearing claims in its brief against the real project first, and to say plainly when one is wrong instead of working around it in silence.

The blank Captain panel now explains itself. When the Captain would not start, most often after a Claude Code update put its new folder’s trust prompt in the way, the panel showed little more than a stuck screen. It now says in plain words why the Captain did not start and walks you through clearing it, so you are not left staring at an empty chat.

Send a task to a builder and a reviewer. You can now hand one task to two workers instead of one: a builder, and a second worker whose only job is to check the builder’s work and push back on it. The Captain stops being the sole reviewer of everything. It is opt-in per task, so nothing changes unless you ask for it.

You choose how hard your Captain and your workers think. Settings now takes a default thinking effort, and every Captain and worker you start from then on runs at it. Set it low when you want quick answers on small jobs, and higher for the work that deserves more deliberation, without editing anything by hand or remembering to say it in a prompt.

The effort you set is the effort you get. The level you picked and the level a session actually ran at could drift apart, and nothing on screen told you which one was in force. Fleet now applies your setting to the sessions it starts and reports the level actually in force, so what you see is what your workers are doing.

Verified against the latest Claude Code. This release was checked end to end against the current version of Claude Code, so the behavior described here is the behavior you get today. It also carries internal packaging improvements.

Scheduled runs survive a Claude Code update. Claude Code's latest update reworded the question it asks about trusting a folder and moved "No" to the front of the list. Fleet's automatic answer still went by position, so it landed on the wrong option, workers quietly exited before they started, and overnight scheduled runs failed with nothing to show for them. Fleet now reads the choices and picks the one that grants trust by its wording, whatever order the question puts them in. If that question ever changes past recognition, Fleet holds the worker and tells you rather than guessing.

A worker stopped by that question says so. A worker that never got past the trust question used to report a bare "Session ended." Its card now names the reason it stopped, so you can see what happened instead of guessing at it.

The fleet panel counts only the workers that are actually working. The small panel beside the Captain chat used to count a worker that had finished but not yet been looked at as still running, and it counted workers that had not started yet. Neither is counted now, so the number beside your chat matches what the board shows you.

Voice input is back in the new look. The microphone sits in the composer again, in the same place the classic look keeps it and on the same wiring underneath, so you can talk to your Captain in either look.

The Captain's raw terminal starts out of the way. In the new look it is hidden when you arrive, and a Raw terminal button in the chat header brings it back and tucks it away again while everything keeps running. Your choice is remembered, and hiding it never touches the session underneath.

The look switch is on the chat now. "Try the new look" sits centered in the chat header on the classic side, and "Back to the classic look" sits in the same spot on the new side. One click each way, from the screen you actually work in.

The browser can bring your Chrome sign-in with it, on any page. A key button in the browser toolbar copies your Chrome sign-in for the site you are looking at and reloads the page signed in. Your Mac asks for your login password first, and that prompt is the consent: no password and no cookie value ever passes through the AI.

Fleet wears its new mark. The app icon and the new look's sidebar now carry the four-square mark from the website, drawn so it stays crisp all the way down to the smallest menu bar sizes. The classic look inside the app is unchanged.

Long worker names stay in their lane. A long worker id or branch name in the chat's timeline column used to run into the conversation beside it. It now shortens neatly, with the full name on hover.

There is a new look, and you can try it and leave it whenever you like. Settings and the header now offer "Try the new look": a darker, calmer cockpit with a rebuilt Workspaces grid whose terminals fill their tiles, a redesigned chat, and one click to make any pane the big one. Today's look stays the default for everyone until you choose otherwise, your choice sticks, and switching back is the same one click. Nothing about your workers changes either way, and switching does not stop, restart or interrupt anything that is running.

The board stops telling you a worker is busy when it is not. A worker that had finished its turn could go on showing a "still working" line long after it went quiet, and a worker whose session never came up at all sat there as "Starting" indefinitely, holding on to its folder so nothing else could use it. Both now settle into a state that says what actually happened, so what the board shows you is true.

A file you ask a worker to produce is a promise Fleet keeps, however you started that worker. When you name a file the job is not finished without, Fleet checks for it before it calls the work done. That request used to travel with only some of the ways of starting a worker, so the same task started from the New task form was accepted with the file missing. Every way in now carries the request, and the same check applies to all of them.

Your Captain keeps Gmail, Calendar, and Slack across a restart. If your Captain happened to start up before those connections were ready, it came up with none of them and stayed that way, not only for that session but for good, because every later restart picked the same one back up. Nothing looked wrong: the board was green, the connection list still said everything was connected, and the only sign was that asking for something from your mail or your calendar quietly did nothing. Fleet now asks your Captain directly whether it can actually see them, and starts it fresh if it cannot. It only asks when your account really has connections to lose, it never restarts a Captain in the middle of your work, and a Captain that can see them is left alone.

Workers can run on a model you supply. Settings takes a model endpoint and a key, with ready-made setups for Kimi, Z.ai, Ollama, and LiteLLM, and your workers will run on it. Your Captain deliberately stays on your Claude subscription, so the thing steering the fleet is never the thing you are metering.

The Workspaces preview tiles are readable. A tile used to shrink a whole session until it fit, so the text got smaller the wider the worker's terminal was, down to a size nobody could read, with a third of the tile empty above it. A tile now shows a readable window onto the most recent output, at the same type size for every worker on the board.

The chat follows your Captain's reply as it is written. When an answer grew in place instead of arriving as a new message, the view stopped following it and the newest words went off the bottom. It keeps up now, and it still leaves you alone if you have scrolled up to read something.

Codex workers start reliably, and two of them never land in the same folder. A codex worker is now judged ready by its own start-up log rather than by a guess about how long starting takes, and Fleet turns down a second one for a folder a live worker is already using.

A worker that saves its report outside the project folder now finishes and tells you. When you asked a worker to write its findings somewhere outside the folder it was working in, the worker did the whole job, wrote the file, and then stalled at the very last step. Fleet looked for the report inside the project, could not find it there, and parked the worker for good. The board kept showing it as running, no completion ever arrived, and there was no way to clear it. Around nine finished workers were silenced this way. Fleet now catches an impossible request the moment the worker is created, names the path it cannot use and what would work instead, and every worker that finishes reaches you.

The workspace previews no longer disturb the worker they are showing. Opening Workspaces used to resize each running worker down to the width of its little preview tile, which changed the real session, not just the picture, so every line the worker wrote wrapped after about a couple dozen characters and stayed broken. The tile is now a mirror: it renders the worker at full width and shrinks the whole thing to fit, so the lines stay whole and the session is left untouched.

A message you send while the Captain is busy shows up in the chat. If you typed or sent a voice message mid-turn, it went through but never appeared, because Claude Code records that queued message differently and Fleet was not reading that record. Your message now belongs to the chat where you sent it.

Two quieter reliability fixes under the hood: the one safety stop that guards against shutting Fleet down now recognizes a destructive command written in more orders, and an internal test no longer depends on your recent chat, so the build stops flaking.

Ordinary commands stop being flagged as an attempt to shut something down. Fleet has one safety stop it never lifts and never lets you clear from your phone, because the command it guards against could shut down Fleet itself. It was firing on everyday work: reading a log file, saving a file whose own help text happens to list the word "kill" as an option, a note inside a script. Each one halted a worker until you were back at your desk. Those run now, and the thing the stop exists for is caught in more of its forms than before, including one hidden inside a script or assembled at the last second.

A picture you paste into the chat appears once. Pasting an image drew it twice, once above your message and once again below it, because Claude Code keeps its own second record of every image it takes in and Fleet was showing that record as if it were another message from you. It now belongs to the message it came from.

Remove works on every project, and tells you when it will not. Fleet holds on to a worker's folder while it still contains work that never reached GitHub. On any project Fleet cannot push to, and on every project once you switched off "Draft pull requests," that folder could never be released and the Remove button quietly did nothing. Remove now gives you its reason, offers a confirmation that names exactly what would be lost, and stays out of the way entirely when there is nowhere for the work to go.

Workers keep a full-size terminal. Opening Workspaces was shrinking every running worker down to the width of its little preview tile, roughly a quarter of a normal terminal. Claude Code lays its screen out against that width, so its own text became unreadable, and the checks Fleet uses to tell whether a worker is stuck or waiting were reading that same scrambled text and raising false alarms for workers that were only thinking.

Fleet notices a worker waiting on you no matter which account it runs under. Its most reliable signal for "this one is blocked and needs an answer" only ever looked at one account, so a worker running under a second one was simply invisible to it and Fleet fell back to guessing from the screen. It now checks every account in use.

Fleet's own notes stay out of your branches. After a run finishes, Fleet writes down what it learned, and when that run happened in its own working folder those notes were committed onto whatever branch was checked out there. Unrelated documentation could turn up inside a change you had open for review. The notes go back to the main project now.

Workers start working again instead of quietly doing nothing. The latest Claude Code reworded the question it asks the first time it opens a folder, so Fleet no longer recognised it, waited, and then typed the worker's instructions straight into that question. The question got answered and the instructions were thrown away, leaving the worker with nothing to do until it timed out. Every scheduled run in a folder Fleet had not opened before died this way. Fleet now answers the question itself, and if it cannot, it tells you rather than typing into it.

Fleet asks you one question, once, when you set it up: do you write code? It only changes what Fleet shows you, never what your workers are allowed to do on their own. You can skip it and change your answer any time in Settings, and if you never answer, the app looks exactly as it does today.

If you write code, Fleet shows you the change first. The worker view opens on the actual diff rather than the plain-English account of it, and everyone else keeps today's order. Nothing is added or hidden either way, only reordered.

The diff is a real viewer now, with a section per file, counts of what moved, line numbers down both sides, colouring that survives the red and green, and a file list you can use to jump around.

The board tells engineers what each worker is measured by: the check it has to pass, how many attempts it has taken, and which agent and model did the work. That last one matters the moment you have more than one kind of worker running.

The proof panel says what actually ran, not just that something did. You get the command, the exit code, when it ran, and the runner's own summary, and when a check fails the error is right there instead of somewhere you have to go and find it.

A worker that failed brings its own output with it, so you stop going to fetch the log. When Fleet no longer has that output, it says so plainly instead of showing you an empty box.

A failing check can no longer show a green "Verified." A worker that passed once and broke later still read as verified. Fleet now tells "passed before, failing now" apart from "the check is failing," and keeps both facts.

A cut-off diff no longer looks complete. Long changes get trimmed so the page stays usable, but nothing said so, and you could read part of a change believing you had all of it. It says so now.

If your Captain would not start after the last update, Fleet now repairs it on its own. Version 1.0.18 started refusing to run on an old version of Claude Code, which was the right call, but Fleet installs its own copy of Claude Code once and never updated it. Some people were left with no Captain and no workers, and reinstalling Fleet did not help. Fleet now updates its own copy and starts up, with no restart needed.

And it tells you what it is doing instead of failing in silence. The old failure showed "Not started" and nothing more. A banner at the top of the app now names the problem, shows the repair running, and gives you a one-line fix for the rare case it cannot sort itself out.

Files you pinned survive a cleanup. Clearing the board deletes each worker's folder, and anything you had pinned to the Files tab was sitting inside it, so a cleanup quietly destroyed it. The files even looked like they were still there until you clicked one. Pinned files are now copied somewhere safe before anything is deleted.

A finish check that cannot fail no longer counts as proof. A check ending in something like "| tail -4" always reports success, so two workers were marked done with proof attached having proven nothing. One of them was hiding thirteen real test failures. Checks like that are flagged now, and a person decides.

Workers stop hanging on a password prompt you cannot see. Programs that would ask a hidden question are told upfront not to, so they fail where you can see it instead of stalling, and Fleet no longer reports that silence as a stuck worker.

Another Claude session on your Mac can no longer put words in a worker's mouth. Messages arriving from a different session are refused for workers, your Captain still accepts them, and a worker that tries to send one raises an approval card first.

Fewer false alarms on commands that merely mention "kill." A script whose text happens to contain the word no longer trips the process-kill warning. Commands that really would end a process still do.

Fleet will not start a worker on a version of Claude with a known approval-box bug. On those versions a command could hide part of itself from the box, so what you approved was not what ran. Fleet now refuses to start the worker instead of showing a badge you could miss.

Smaller repairs: the Files tab says what the tab is for, a verification record can say it could not be determined instead of being forced into a pass or a fail, and test runs stop leaving dead socket files on your disk.

Far fewer approval prompts you should never have seen. Opening a pull request, or running a command that merely had the word "deploy" sitting in a commit message or a filename, was being read as a production deploy. It either interrupted you or parked a worker on a prompt nobody could clear from a phone. Fleet now looks at the command itself instead of the prose around it.

A frozen worker recovers on its own. One that stalled mid-turn used to hold its task forever, and a one-off scheduled run missed during an outage never re-armed. Both come back now without you having to notice. One gap remains: work a worker committed but never pushed anywhere can still be cleared away by Fleet's cleanup, and a fix for that is tracked.

A worker no longer spends its one push on a passing failure. When a draft pull request push hit a temporary error, the attempt was used up and the work quietly disappeared. The skip is recorded and the push is tried again.

Design review sees the whole page. The proof screenshots it judged were being cut off at the bottom of the screen, so a critic was reviewing half a page as though it were all of it. Captures are full-page now, and the critic is told how tall the page is.

The built-in browser stops failing silently on heavy pages. It now waits for the page to commit before running anything against it, so a complex app can be diagnosed and driven instead of returning nothing.

The status labels on the board are pinned by a test, so the words Fleet shows you cannot drift from what the app is actually doing.

The Captain had quietly fallen about ten commands behind Fleet itself. It did not know it could check service health, switch between your accounts, read your settings, watch a worker live, or do anything in the built-in browser beyond opening a page. All of it is documented again, and a check now fails the build if a new command ever ships without the Captain being told about it.

Every lesson a worker wrote down was being thrown away. Workers finish by noting what tripped them up, so the next one does not repeat it, and none of it was reaching the project's notes. Across 71 projects, 618 of 738 of those notes were lost. They are saved now, and a batch of work that produces lessons but files none of them fails loudly instead of reporting a clean run.

A finished worker's proof no longer disappears. Clearing the board or restarting Fleet used to delete the evidence a worker left behind that its work actually passed.

Run the same task on Claude and on Codex from the command line with fleet-ctl spawn --ab. It starts both and prints both worker ids, so you can compare two answers to the same brief.

New tasks now start in the Captain chat. The separate task form is gone; ask the Captain for what you want instead.

Pick different models for the Captain and for workers. Run the Captain on your best model and workers on a cheaper one, or the other way round. Two independent choices instead of one setting for everything.

An HTML file a worker builds now opens as a page. Previously you got the source code. It renders in a sandbox, so a page a worker wrote cannot reach the rest of the app.

You choose whether Fleet sends diagnostics. A card asks once, your answer sticks, and nothing leaves your machine until you say yes.

Approvals waiting on you survive a restart. Quitting Fleet with approvals pending used to drop them and strand the workers behind them. They come back. And a card left over from a previous session now says so plainly instead of quietly doing nothing when you approve it.

Changing the model actually changes the model. Picking a new one in Settings now reaches the Captain that is already running, and the choice survives a restart instead of reverting.

Fewer false alarms on safe commands. Fleet was stopping ordinary commands because a risky-looking word appeared inside quoted text, like a column named created_at. It now reads the command instead of scanning the letters.

Reviews and research finish without being blocked. A worker whose job was to read and report was being stopped by the design-quality check meant for visual work.

Sites that check your browser work in the dock. Fleet was identifying itself with an outdated browser version that some sites reject.

Setup is steadier. Several timing problems during first run could leave onboarding stuck or open a login page twice.

Files you pinned survive a clean-up again. Fleet's routine tidying was deleting pins from the Files tab, and roughly 217 of them were lost. A pin now lives through a clean-up, through a restart, and even when the original file has gone missing.

Fleet tells you when it missed scheduled work. If Fleet was not running when a scheduled run was due, the next launch says so and names the runs that did not happen. Quitting on purpose is treated differently from a crash, so shutting down at night and opening up in the morning raises no alarm.

The chat no longer goes quiet without saying so. It follows the live conversation instead of latching onto the first one it saw, and when it is reading something that has stopped moving it tells you, instead of looking like a lull. Tuned against six days of real conversations: 56 false alarms became 6, and the real hang this fixes is still caught.

A finish check that cannot run at all is now reported as broken, instead of being tried three times and reported as a failure.

A session waiting on a prompt no longer looks like it's thinking. When Claude asks for permission and only you can answer, the session used to sit there looking busy, and the only way to find out was to open the terminal. It now raises a card. This covers prompts from Claude itself and the Captain parked on a dialog. A prompt from a tool running inside a command you already approved, such as npx wrangler login, gh auth login, or an npm y/N, is still not caught. Reported by a beta user.

Two messages sent in quick succession can no longer merge into one. A message typed while the previous one was still going out could be folded into it, sending the agent text you never wrote, or dropped entirely. Sends now happen one at a time, and a message typed in the gap is queued and delivered as its own turn. Reported by a beta user.

Recovering a frozen worker won't take over a branch that is already spoken for: one with an open or merged pull request, or one another live worker is holding. And if gh is missing or signed out, Fleet says so loudly instead of quietly disabling recovery.

Granting the browser session is a deliberate step during setup, instead of a Keychain prompt ambushing you mid-task.

Voice follow-ups work while the Captain is still working.

Your fleet can use sites you're already signed into. When a page sends you to a Google, Microsoft, Okta or GitHub sign-in, Fleet opens it in your normal browser, because those providers refuse to accept a sign-in inside an app. One button brings that session back, and the page loads signed in.

Paste a screenshot straight into the chat. Control-Command-Shift-4 copies an image without saving a file, and Command-V now attaches it.

The chat stays on the newest message, and stops pulling you back to the bottom while you're scrolled up reading, including when you answer from your phone.

The built-in browser can now be driven. Ask your fleet to click a button, fill a field, type, press a key, hover, pick from a dropdown, or wait for something to appear, and it happens in the browser you are watching.

The clicks and keystrokes are real ones rather than simulated, so pages treat them exactly like yours. It works while Fleet is in the background, and it never takes your keyboard away from you.

It refuses rather than guessing. A stale reference to something that has moved, or a button hidden behind an overlay, gets a clear error instead of a click landing somewhere you didn't intend.

One test could corrupt the others, which had been making test results unreliable across the whole app. That's fixed.

Passwords you type into the built-in browser stay private. The browser's page summary could include what you'd typed into an unlabeled field, so a password could reach the model. It can't now.

File names the Captain mentions in chat are clickable and open in Files. This never actually worked before: the feature was wired up but never ran, so nothing was ever clickable.

Sending a message with an image attached shows one message instead of two.

A smoother first run: sign-in, folder trust, and Codex setup are one guided flow instead of scattered prompts.

Open Settings from the menu bar or with Command-comma, the standard Mac shortcut.

Dictate to the Captain with your voice: a mic button and hold-Space push-to-talk in the composer.

Settings is reorganized into clear, labeled sections, so the setting you want is easier to find.

The live preview now follows the right dev-server port, and a new indicator shows when and where a server is running.

The tab for the files your fleet produces is called Files everywhere now (it used to say Artifacts in some places).

Reliability fixes under the hood.

New installs start on Opus 5. Anthropic's newest flagship is now what a fresh install picks by default, at the same cost as the model Fleet reached for before. A model you already chose in Settings is left alone.

An anonymous once-a-day usage ping, so we can count active installs and see which versions people are running. It carries no content and no way to identify you, just a random ID the app makes up for itself. It is on by default and there is a switch to turn it off in Settings.

While the Captain is writing, the chat shows a calm animated wave and a quiet "Composing" label, in place of the old three dots.

A worker that finished its job and is only waiting to be checked is no longer labeled stuck.

The fleet rail on the right keeps showing your workers when the window is narrow: it packs the rows tighter instead of hiding them, so a heading can never sit above an empty list.

When the Captain opens an image, the chat now shows you the picture itself instead of a line of text standing in for it.

A technical notice about image sizing no longer turns up in the chat dressed as something you typed.

Anthropic's Opus 5 is now one of the models you can pick for your fleet. It is their newest flagship, it holds far more of your project in mind at once, and it costs the same as the model Fleet reached for before.

The Captain chat is redesigned: warmer type, a cleaner header, a browser dock that splits into its own panel, and a sidebar you can fold away when you want the room.

Videos a worker hands you now play right in the chat, the same way images and PDFs already did.

A question from the Captain no longer disappears before you get a chance to answer it.

A Codex worker that finished its task now settles properly instead of stranding on the board as stuck.

Fleet's window shrinks further than it used to, so you can sit it beside another app on half your screen.

Switching the Captain to the model it is already on no longer produces a warning saying the change could not be confirmed.

You can now turn design reviews off in Settings, and they no longer hold up work that has nothing to do with design.

First-run setup now shows you the macOS folder-access confirmation, so you can see exactly what Fleet is asking for and grant it in one pass.

The prompt to finish an interrupted setup is clearer, and it sits alongside the update prompt instead of fighting it for the same spot.

The built-in browser reads properly: the active tab and its panel now sit on one distinct surface, so the page you're looking at is obvious.

Remote control no longer mentions Telegram before the setup wizard for it exists, so nothing in the app promises something you can't do yet.

Setup now installs Codex too, so cross-checking your fleet's work with a second model works out of the box.

Fleet now declines new work when your disk is nearly full, instead of taking the job and failing partway through.

Morning scheduled reports now appear in the Files tab automatically, no hunting required.

When workers share a project, one worker's work in progress can no longer be swept away by another's cleanup.

Internal hardening of the channel the Captain uses to direct its workers.

Groundwork for optional usage telemetry. It stays off unless you explicitly turn it on, and nothing is sent today: there is no way to enroll yet.

General reliability improvements across the app.

Fleet Desktop reaches 1.0 and opens to everyone. Give a goal in plain language, watch a fleet of workers take it on, and approve only work that arrives with proof.

Setup now detects your existing Codex wherever it is installed, even when the app is launched from the Dock or Finder.

Installing Codex honestly verifies that it actually runs, with clear guidance if macOS's security scanner interferes with the install.

Codex workers report their status accurately: no more false warm-up timeouts, and their questions reach you instead of being quietly marked done.

A setup worker that gets wedged while preparing a project now clears itself automatically instead of sitting on the board forever.

A worker whose job already finished is never respawned, so a restart can no longer leave duplicate workers on the board.

Workers always launch the newest Claude Code installed on your machine, not an older bundled copy, and the CLI keeps updating itself normally.

Reliability hardening across tests and cleanup paths, based on review feedback.

A guided walkthrough of Settings for first-time setup: skip it anytime, and if you close it midway it picks up where you left off.

The update pill and Settings now link straight to the changelog, so you can see what changed before or after you update.

A bolder look: a stronger anchor icon and a heavier wordmark across the app.

Workers start faster. Each new worker begins from a warm build cache instead of compiling everything from scratch.

Fewer false safety prompts: a command that only mentions a risky phrase inside its data no longer trips the strictest safety gate.

A scheduled run that finished but could not be verified now says exactly that instead of reading as timed out, and gets a clear finish line.

The fuel gauge stays current even when the Captain's own feed is quiet, by using readings from active workers.

Reconnecting to a long-running Captain no longer replays the entire chat history into the conversation.

The design check blocks safely when its bundled reviewer is missing, instead of silently passing work through.

Reliability hardening behind the scenes: checkpoints can no longer sweep credentials into a commit, a folder of credentials no longer makes a checkpoint look dirty, and the Captain starts with its built-in helper loaded.

Start typing anywhere in the Captain chat and it lands in the composer, no click into the box first. Arrow keys move the cursor properly again, and Cmd+K opens search right where you are instead of switching screens.

Scheduled runs now report themselves: a job that finished is marked finished, and a worker stalled by a service error recovers on its own instead of sitting quiet until someone notices.

Plan approvals arrive as a proper card: see what a worker intends to do and approve or decline in place, instead of reading through a wall of text.

The design check can no longer wave work through when its reviewer goes silent: it blocks safely and tells you exactly why it blocked. The check itself also got stricter, with a tightened craft rubric behind it.

Test results are honest end to end: a skipped test is reported as skipped, and a failing check can never read as passed.

The fuel gauge shows the age of a reading it can't refresh, and low-fuel warnings track each account separately, so switching accounts can't silence one.

Images you attach appear once in chat, not twice.

Helpful setup prompts now reach people who installed long ago, not just brand-new installs, and updating no longer loses your place in them.

Workspace cleanup is fenced to exactly the folders it owns, and a reused workspace can no longer be mistaken for one queued for deletion.

A stop button for the Captain: halt it mid-turn when it's headed the wrong way, instead of waiting out the rest of a long answer.

Every worker now runs on a budget: hard caps on the helper agents it can spawn and the web searches it can run, so a big fleet can't quietly multiply behind your back.

Images you attach get their own row in chat above your message, instead of stretching the text bubble into an empty field, and they're still there after a restart.

A turn cut short by a rate limit now says so and recovers right away, instead of sitting there looking busy until a timeout swept it up.

Long conversations scroll with less stutter: the chat no longer redoes the same clock work for every row, every repaint.

Cleanup now reclaims stray workspace copies wherever they landed on your disk, not just the usual spot. One machine got 140 GB back.

Leftover names from the app's own development can no longer surface in anything it shows you.

Typing in the Captain chat is smooth again: the conversation no longer reshuffles under your hands with every keystroke.

When a worker hits your plan's usage limit mid-task, Fleet now says so plainly instead of leaving the turn looking frozen.

Long conversations scroll faster: chat timestamps now render far more efficiently.

Tighter workspace isolation: a worker's build files can no longer end up outside its own sandboxed copy of your project.

Design checks are quicker: an instant automated screen runs first, so the second AI reviewer only weighs in on designs that pass it.

Fleet now recognizes the exact moment a worker is genuinely waiting on your answer and flags it, so nothing sits blocked in silence.

Workers on the same project share one build cache, so big builds stop eating your disk and each new worker starts faster.

Long conversations now replay in full after an app restart instead of cutting off at the last few lines.

Demo builds are now visually unmistakable from the real app, so you always know which one you're looking at.

Fleet warns you when a worker's command-line tools are too old, and automatically sweeps away workers that died without cleaning up.

Attach images and PDFs in chat with real previews. Click any of them to expand full-size.

No more double approval prompts: when the Captain relays a request you've already answered, you're only asked once.

The fuel gauge remembers its last reading, so it shows real usage numbers immediately instead of a refreshing spinner.

Your chat history, including your own messages, fully survives an app restart.

Scheduled runs that finished successfully are no longer occasionally marked as failed.

Get notified the moment the Captain has a reply for you. No more checking back to see if it's done thinking.

Links in chat render as neat chips, with preview cards for pull requests and local dev servers.

Approval cards are clearer and color-graded by risk, so you can judge a request at a glance.

Workers' branches get readable names that say what they're building, instead of random strings.

The chat opens pinned to the newest message instead of somewhere in the middle.

Images you attach stay attached when you switch tabs before sending.

A worker you stop now stays stopped: recovery can no longer accidentally revive it.

Desktop notifications when the fleet finishes a job or needs your input. Walk away and let it work.

Links in the Captain chat now open reliably in your default browser.

Tables in chat no longer squeeze narrow columns down to a single character.

The fuel gauge holds one steady reading per account instead of flickering between sources.

Fleet's build folders are now hidden from Spotlight indexing, keeping your Mac responsive during big builds.

App updates now appear as a small "Update ready" pill in the title bar instead of a pop-up that blocks your work.

First-run sign-in is dependable: retries get a fresh sign-in link, and stray browser windows no longer float over the setup wizard.

A Settings toggle lets the Captain drive your already-signed-in browser when a task calls for it.

Switch which Claude account new workers use, handy if you have more than one subscription.

Fleet staggers heavy jobs so starting several workers at once doesn't overwhelm your Mac.

New Captain sessions start with a briefing from the previous one (active workers, open approvals, recent outcomes), so a fresh session picks up right where the last left off.

Stopping a worker whose task was still queued can no longer tangle the queue.

Stopping one worker can no longer sweep away unrelated queued work.

A safety circuit breaker: a worker that keeps retrying the same blocked action is paused with a single card for you, instead of looping forever.

Fleet now watches your Mac's resources and queues new workers instead of overloading it.

Multi-account support rounds out: remove an account you no longer use, with a smoother add-account wizard.

Pale, unreadable text in the light-mode terminal is readable again.

Fuel gauges mirror your live session in real time: the newest reading always wins, and switching accounts is reflected immediately.

When the gauge is between readings it says "refreshing..." instead of showing stale numbers.

File cards show when each item was posted, and turn amber when stale, so old ones are easy to spot and close.

A worker that finishes without attaching its proof of work gets one automatic reminder before anyone has to chase it.

Design review verdicts are final: no more loops asking you to re-approve the same design.

The scheduler no longer cuts off long research jobs mid-work, and any failure comes with a plain-English notice and a way to resume.

The New Task window fits on smaller screens.

The fuel gauge: a live usage-and-limits monitor in the sidebar, showing your session and weekly pools at a glance.

The Captain gives you a heads-up when fuel runs low, before it becomes a surprise mid-build.

Per-worker memory chips show what each worker is holding onto.

The account menu grew up: your avatar expands in place with Settings, Skills, Schedules, Memory, and Outcomes.

Setting up on a fresh Mac no longer stalls on phone pairing: it skips cleanly on first launch and heals itself later.

The header now reflects your actual Claude plan.

Fleet now bundles the developer tools it needs inside the app and installs them for you, so setup works on a brand-new Mac with nothing pre-installed.

Every step of first-run setup, from installing tools to signing in, now completes on a completely clean machine.

If your browser doesn't open automatically during sign-in, you get a link to click instead of a dead end.

The board no longer piles up: a worker that goes quiet with a dead session clears itself automatically, while freshly started workers are protected.

Drag to resize the Captain's terminal pane. Your chosen height sticks across restarts.

The Captain's attention badge counts down correctly as you clear cards.

Fleet's memory compounds: every project keeps a permanent record of what its workers learned, and new projects start by reading lessons from your past builds instead of re-deriving them.

The built-in design standards got a major update: stricter checks against generic-looking AI design across app, mobile, marketing, and ad work.

Terminals no longer freeze under heavy output: they now render on the graphics chip and stay smooth.

New projects begin with an accurate, brief-informed project guide (the right stack and current versions) instead of a guessed one.

Security hardening: a worker can no longer gain the Captain's control authority, and secrets are kept out of places other processes could read.

The Captain returns to your chosen model automatically after a restart, with your conversation preserved.

The whole top bar is now a drag handle: moving the window no longer means hunting for the tiny strip by the traffic lights.

No more false "Captain failed to start" banner after an app restart.

The safety reviewer got sharper: a command that starts innocent but chains into something riskier now gets full review instead of a free pass.

A slow completion check can no longer freeze stuck-worker detection for everyone else.

Workers show their project's name instead of a raw internal path.

Fewer false "secret detected" prompts on safe commands.

Terminal tiles use less memory across the grid, with full history preserved.

Secrets Manager: paste an API key into a card and it's stored in your Mac's Keychain, never in the chat.

Autonomous disk cleanup keeps old build files from quietly piling up.

The installer is notarized by Apple, so the download opens with no security warning.

Every finished design is automatically screenshotted and scored by an independent AI critic before it reaches you, with no manual step.

The design critic runs reliably in the installed app. Previously it could wave designs through without actually judging them.

The Captain stays under control across app restarts and auto-updates.

The worker grid shows friendly descriptive names, matching the cards and detail view.

The first self-updating release: from here on, Fleet downloads, installs, and relaunches new versions in place.

The build is signed with a hardened runtime, so macOS trusts it out of the box.

Fleet ships with its skills built in, so workers know the house playbook from the first launch.