Multi-repo projects, Mission Control, and a review queue

One agent, every repo

Real work rarely lives in one repository. A project can now group several repos, and an agent checks out all of them when it spawns. It's one workspace with a frontend, a backend, and a shared library side by side — the agent sees the whole thing.

Everything downstream understands the grouping:

The git panel shows each repo's changes separately, not one mashed diff PRs fan out across repos and cross-link as a set, so a change spanning three repos reads as one unit The Code tab spans every repo in the workspace Each repo carries its own settings and label

Mission Control

When you're running a fleet of agents, the bottleneck stops being the work and becomes you — reviewing it. Home now has a fleet review queue: everything waiting on you, in one place, ready to approve or send back. You triage the fleet instead of clicking through agents one at a time.

Workflows that show their work

Gates no longer just pass or fail — they produce evidence. A review gate shows you what it checked; a failed gate can be rejected with a reason that routes the work back. The new ReviewSurface gives you one consistent place to read that evidence and make the call.

Around that:

Promote any running agent into a workflow, or set a default pipeline for a whole project A workflow's step agents show in the sidebar, so you can watch the chain move Verification is now a reusable engine primitive — the same checked step, available anywhere in a run A require-tests toggle in the builder, and follow-ups that verify on turn end

GitHub issues to working agent

Your GitHub issues now land in an inbox on Home. Start work from one and Fletch prefills the workspace from the issue; the resulting PR closes it with Closes #N. Issue to branch to merged, without leaving the app.

Composer

@ and # mentions now work in the new-workspace draft composer, not just mid-run Invoke your library skills as slash commands, inline Per-model reasoning levels — set how hard a model thinks, per model Launch a workspace with file attachments, delivered to the run's first step

Lifecycle and reliability

Recover workspaces whose branch was deleted after a merge, instead of losing them Base-staleness and overlap hints in the git panel warn you when agents are about to collide Sleep assertion keeps long runs alive; close-to-tray and a quit confirmation stop you killing a fleet by accident Project deletion controls

One isolation model

With Docker sandboxing mature, the old git-worktree provisioning is gone — every workspace is now a full clone. One isolation model, documented canonically, with the terminology cleaned up across the app and site.

Slash commands and environment variables

If you've built custom slash commands, skills, or plugins for Claude Code, Fletch now finds them. Start typing in the composer and they're there — the same shortcuts you use in the terminal, no reconfiguration.

Per-project environment variables

Sandboxed runs are strict about what they can see, which is the point — but it made env vars a chore. You can now set them per project, and every sandboxed run picks them up.

Fixes and polish

• Merging now works on repos with auto-merge disabled — Fletch merges directly instead of stalling
• Refresh the model list from settings without restarting the app
• TUI-only Claude commands no longer flash through the managed view
• Removed the Density setting, which never did anything
• Balanced the auth button icons in onboarding
• Rewrote the README around what Fletch actually is now: workflows, isolation, control

Workflows

Fletch no longer just runs agents in parallel. It runs them in order.

Define a pipeline once — architect plans, coder builds, reviewer checks, tester proves — and every task runs that same pipeline, with a gate at every step. No step advances until its gate clears. The same disciplined process on every feature, not a prompt and a prayer.

Build a workflow

A visual block-tree editor for composing pipelines. Drag in steps, assign a specialist agent to each, set the gate that has to pass before the next one starts.

Every workflow is also a YAML file. Import one, export one, check it into your repo, share it with your team, diff it in a PR. The editor and the file are the same thing — edit either.

Gates

A step doesn't finish because the agent says it's finished. It finishes when its gate clears.

Tests gate — runs your test command. Green or it doesn't pass. Review gate — Greptile, your own reviewer agent, or your CI. Plan approval — you read it before anyone writes code.

Nothing advances on vibes.

Loops

A step can send work back. Tests fail, it returns to the coder, the coder fixes, the tests run again — until it's green or the loop hits its cap. Bounded, deterministic, no runaway.

Parallel blocks

Fan a block out across several agents at once, then join the results back. Code-producing branches merge for real, with conflicts surfaced for you to resolve rather than silently clobbered.

Budgets

Every run carries a ledger. Set a ceiling on a workflow and Fletch enforces it — a loop can't quietly burn your Max quota overnight.

Run monitor

Watch a workflow execute live: which step is active, which gate it's waiting on, what each agent is doing, where it looped back and why. When a run goes sideways you can see the exact step it went sideways at.

Agents that talk to you — and each other

A comms router lets steps report progress, ask each other for context, and escalate to you when they're genuinely stuck. Questions surface as real prompts you answer, not walls of text you scroll past.

An orchestrator role can compose workflows dynamically at runtime, choosing the next block based on what the previous one found.

Also in this release

• Force push support in git operations
• Composer restores drafts at their full height instead of collapsing
• Claude task notifications render as quiet system notices instead of cluttering the chat

Custom agents get skills and tools

Your custom agents are no longer just a model and a prompt. Give them a skills library and point them at MCP tool servers, and a specialist actually becomes a specialist — a reviewer that knows your review conventions, a tester that can reach your test infrastructure.

This is the groundwork for chaining them into workflows.

Hardening

Fletch's whole pitch is that an agent can't touch anything you didn't hand it. This release closes the gaps between that claim and the code.

OAuth tokens moved to the macOS Keychain, and the app data directory is now walled off from agents entirely. An agent can't read Fletch's own credentials. Tighter sandbox write grants, unified under one policy that applies identically whether you're on sandbox-exec or Docker. One rule set, two engines, no drift. Claude's config directory is now read-only with narrow exceptions, rather than broadly writable. Crash reports are scrubbed before they leave your machine. Nothing from your code or your prompts rides along in a Sentry payload.

Sync health

Agent CLIs change their transcript formats without warning. Fletch now detects when a layout drifts out from under it and tells you, instead of quietly showing you a stale conversation.

Also in this release

• Queued follow-up messages survive a restart — close the app mid-turn and your queue is still there
• Fletch stays responsive during heavy agent I/O; the global lock is no longer held across blocking child reads
• CI gates on rustfmt and clippy warnings
• Corrected the sandbox description in the README

Setup, without the yak shave

Fletch needs three things: git, an agent CLI, and a repo. Onboarding is now built around exactly those three, and it can install the first two for you.

Missing git? Fletch installs a portable copy. No Claude Code or Codex on your machine? One click. You no longer have to leave the app, find the right install command, and come back.

Also in this release

Untracked files now show as green U in the git panel, with real diffs and line counts instead of a bare filename

Run config you can actually edit

Fletch detects how to run your project — Node, Python, Ruby, Rust, Go. When it guesses wrong, or finds nothing at all, you're no longer stuck: the run config is now editable, with empty fields waiting for you instead of a dead end.

A PR panel that doesn't blink out

PR state is now snapshotted and persisted, so the panel keeps showing your pull request even when the checkout underneath it breaks PR polling is batched, backs off when GitHub rate-limits you, and adapts its cadence — less noise against the API, fewer stalls when you're running a lot of agents

Also in this release

Agent spawn now survives a failed base fetch — the fork point resolves to a SHA and falls back cleanly instead of erroring out

Per-project settings

Every project now has its own settings modal. Set how it runs, rename it, move it somewhere else on disk — without touching global config or re-adding the project.

Run overrides are also agent-scoped now: one agent can run the thing differently from its neighbour, in the same project, at the same time.

Port safety

Five agents, five dev servers, one port 3000. Fletch now detects the conflict and falls back to the next free port instead of letting the second agent die on EADDRINUSE.

Forking that holds up

Clone-mode workspaces pin their fork point to the fetched tip SHA — no more silently forking from a stale local ref Repos with no commits yet are now forkable; Fletch seeds an initial commit instead of refusing

Also in this release

• New curated place names in the agent name pool
• Logs moved to ~/Library/Logs, where macOS expects them
• Fixed spacing in the history search popover

Sandboxes and docker support

An agent you have to supervise isn't saving you anything. Fletch already sealed every agent under a macOS sandbox — this release adds a second, stronger option: run each agent inside its own Docker container.

Pick your engine in settings. macOS seatbelt is instant and needs nothing installed. Docker gives you a full environment boundary — the agent's filesystem, network, and processes are its own. Choose per agent: a throwaway refactor can run under seatbelt while the one you don't trust runs in a container. Engines are sticky per agent, so an agent keeps the boundary it started with.

Works with every agent Fletch supports — Claude, Codex, Cursor, OpenCode, and Pi.

Your login comes with it

Containers usually break agent auth: your Claude subscription lives on your host, and the agent doesn't. Fletch resolves credentials through a chain — stored token, shell environment, credentials file — and captures a setup token for you automatically. Gateway tokens (ANTHROPIC_AUTH_TOKEN) work too, so Bedrock, Vertex, or a proxy are all fine.

You log in once, on your machine. The container inherits it. No API keys pasted into config files, no middleman.

Clone mode

Fletch can now provision a workspace two ways: a git worktree, or a full clone with its own .git. Clones are the stronger isolation — an agent can't reach the object store your other work depends on.

They're also cheap. Clones borrow objects from your original repo via git alternates, so a full clone of a large repo costs you almost no disk.

Tighter grants

• ~/.claude is mounted read-only, with credentials the only exception
• Repo hooks are neutralized on host-side git operations — a hook in a repo an agent touched can't execute against your machine
• Stale credentials files are rejected outright rather than silently failing later
• Git commit and merge now run natively inside the container instead of being marshalled back over RPC

Local-first projects

You no longer need GitHub to start. Add a local repo, work, and connect GitHub later — the connect flow is inline and only appears when you actually need a remote.

You don't even need git installed. Fletch resolves whatever git it can find and installs a portable copy if it can't find one.

Also in this release

• Drag to reorder projects in the sidebar
• Agent images stay fresh automatically — TTL, version parity with your CLIs, and garbage collection of orphans
• A badge marks agents running in a container, clarifying that container paths mirror your host paths
• Turn-end notifications can be toggled off
• A turn now stays active while a subagent is running, instead of reporting done early
• Rewrote the README and refreshed branding