What's new in Fleet.

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.

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.