🚢 FleetViewRun a fleet of AI agents without losing one. One tab shows every agent your Claude Code, Codex or Copilot session starts β its story, its progress and estimate, what reusing a warm one would save β and FleetView keeps the fleet safe: a reload pauses every agent and asks you once, a lane holding a story whole cannot quit before it is done unless that story is recorded as blocked on you or an outside party, and a lane a restart killed comes back by itself.
🎯 Better together: BullseyeUberFleetView works on its own, and it gains the most inside BullseyeUber β one install puts it with FleetView, BullseyeBacklog, DeepAgent, BullseyeSync and BullseyeNotify in a single Bullseye Control tab. Installing BullseyeUber pulls in any member you are missing, and each keeps its own listing and updates.
👉 Get BullseyeUber on the Marketplace β¨ What's new since 2026-10-17 β most important first1. 🔥 A fleet watcher that no longer eats the boxOn the busiest box measured, FleetView's own CPU fell from 82β86% to about 24%. It no longer starts a program on every beat, reads only what a transcript appended, reads each board once per version, keeps a finished lane's reading until something it depends on moves, and starts no git for a repo's own checkout or for a tree a live lane works in. 2. β‘ RELOAD pauses every agent first, then asks you oncePress β‘ RELOAD on the FleetView toolbar. Before anything reloads, every agent is paused at a safe point: its next call is refused, and the call it is in finishes β nothing running is frozen mid-write. While a pause stands, no new subagent is dispatched. Then ONE question opens in the middle of the Fleet tab β on every reload you press in FleetView (β‘ RELOAD, the DEV restart, or the Reload window button on a newer-build notice), even over a window that holds nothing. It is never offered anywhere you did not press. Nothing is killed until you answer:
3. βΆ🚢 A Start press is a written record any session can takeA βΆ🚢 Start press on the BullseyeBacklog board is written beside the board the moment you press it, and waits there until a session takes it β Claude Code, GitHub Copilot or Codex, through the
4. 🚪 A lane cannot end before its story is doneA lane's stop is refused while a story it holds whole is still open on the board β so a story is never left at 80% with its agent gone. A lane briefed on one part of a story, or a role on it such as review, leaves the rest to its lead; a story recorded as blocked on you or an outside party lets its lane stop. A lane that started a background process is held in its turn until that process finishes. A lane whose stories are all DONE leaves the roster. 5. 🛟 Lanes a restart killed come back by themselvesA lane a restart took down is revived into its own chat, once per board state. A lane nothing can resume is said once, with a working Start, not asked about every two minutes. A revived lane that is writing is never called 💀 dead. 6. 🌿 Every stray worktree and branch, in every projectUnder the toolbar: 🌿 N orphan Β· M genuine. Hover it for the table β repo, tree or branch, its story with priority and %, whether its work is in main, and its owner (the live agent, the release build, or ORPHAN). 🧹 Cleanup acts on the orphans; an orphan whose story is open is queued so a lane resumes that tree, and one with no story goes to a judge that lands or keeps its work β never discards it. A process a dead lane left behind is killed by pid; a live lane's files are never touched. 7. 🎫 A queue you can work in bulkTick rows, or the one box in the table header for all of them, then Remove them together; β really removes a row. The queue starts stories P0 to P4, XS to XL, each the moment the box has the measured free CPU and RAM a lane takes (P0 first), never a fixed count, and a 🎫 Queued story lands on the agent that holds it. 8. 🚦 Every lane's state, in plain words
A lane waiting on its next model reply, or inside a reviewer it called, is never flagged as making no progress. 9. 🧭 Status bar says what went wrongA 🚧 item names a release that did not ship, and another names a lane the box's CPU gate is holding. Each opens the Fleet tab. A CB item shows the state of the continuous build β queued, building, green with the time it took, red with its error count, or unfinished β with the detail in a table on hover and a red build's compiler errors in the Problems panel; a machine with no build running shows nothing. 10. β‘ Lighter and calmerThe live dot pulses on the compositor instead of repainting the panel every frame (on a 24-dot test page, 13 to 27 points of one core cheaper; a live roster draws fewer dots, so expect a few points), the census reads each worktree's See the Changelog tab for every version. 🚀 StartTell your AI what you want β Say it to your AI β what you type, and what you get1. Start the work. In your Claude Code chat:
One agent per story starts. Each shows up on the roster with its story, its progress and an ETA that counts down. 2. Ask what the board says about an agent.
Hover the story number on its row: the story's priority, size, board % and what is left, read live from BullseyeBacklog. The same agent shows on that story's row in the board, with its progress and ETA when you hover it there. 3. Reuse a warm agent instead of paying for a new one.
Your AI asks FleetView's 4. Look at the plumbing too.
Watches and background shell commands that carry no story are hidden by default. Tick Infra agents and they appear, marked as processes, not agents. 5. Ask what it cost.
Every picture is rendered from the shipped panels in a headless browser over an invented fleet β no real session, folder, host or name in them. Click any picture to open it full size. β¨ Everything it does
How it works with BullseyeBacklogFleetView and BullseyeBacklog are one workflow. You never edit a story or start an agent by hand: you ask your AI, and the two panels show the result.
Press βΆ🚢 Start agents on the board and the stories go to the 🎫 Queue: it starts them, P0 to P4 then XS to XL, each the moment the box has the measured free CPU and RAM a lane takes, and stops itself when empty. βΈ Stop it, βΆ Run it, reorder (β¬ β¬), remove rows, or β Kill a running agent right there. The queue lives in memory: a reload empties it, while the written press beside the board stays until a session takes it. If BullseyeBacklog is not installed the roster simply draws without these columns. What it readsFleetView reads the session and transcript files Claude Code already writes on your machine, so you can see every live main agent, every subagent it launched, what each one is writing right now, and what the main agent did with the result. GitHub Copilot Chat sessions are picked up the same way on Windows, and Copilot CLI sessions from their own session files. Codex main agents and their nested subagents are discovered from Codex rows show each thread's own recorded turn state, model, token counts, output and answer. Descendants stay grouped under their parent conversation, including when a subagent forks its parent's history. A turn with no terminal event becomes presumed after 45 minutes of silence; that is not proof that its process stopped. Use Codex itself to chat, stop or resume these threads; FleetView's Claude-specific controls are unavailable on Codex rows. What FleetView starts and stops on its own: a background Claude Code session to take a Start press when no chat is live; the revive of a lane a restart killed; the pause a β‘ RELOAD writes; and the kill of a process a dead lane left behind. Everything else waits for a button you press. The Fleet tabNothing of FleetView opens by itself at window start. The Fleet tab is an editor tab, not a sidebar view; A session is a group row: a caret that collapses it, a live or idle dot, the session name, its ID, Under each session, one entry per agent. Every column sorts and resizes, and the layout survives a reload:
β° Columns hides or shows any of them. The filter row carries 🏃 Running Β· 💤 Standby Β· βΉοΈ Stopped, each showing the count it is hiding, plus Only me (this window's own work), Show empty and Infra agents. The strip under it carries the 🌿 worktree line, 🚨 for a read that FAILED (naming the file and the reason), and β³ for a session file still being read. What the buttons do
The PROGRESS line, and the check you can installEvery lane FleetView shows is asked to end each reply with one line:
The Progress column reads that line β the lane's own claim, never a measurement β and it moves without anything being installed: the percentage and its countdown come from the lane's own stated ETA against the clock, and when a lane states none the column falls back to FleetView's own readings (steps taken, files written, how long since anything moved). FleetView: 🔒 PROGRESS check (opt-in hook) β the button in the Fleet tab's title bar, or the same command in the Command Palette β asks first, then adds a reminder to your own Claude Code settings: a lane is asked for its PROGRESS line the moment it starts, and once more each time it runs past its own estimate; a main chat is told on its next prompt about a lane of its own that went silent or overran. It only ADDS a reminder β nothing is refused, blocked or held.
🔌 The hooks a Start press needsA Start press reaches a session through a hook. On a machine where it is missing or hooks are switched off, the press still queues and its reply names the gap; Agent detail β Output Β· Diff Β· HarvestClick a subagent to open its panel.
βοΈ SettingsFleetView keeps no VS Code settings. Its settings live in
The file is
Keys in the repo. Moving from VS Code settings. The first start of this build copies each 🤖 The
|
| Tool | Does |
|---|---|
presses |
the βΆ🚢 Start presses written beside a board that no session has taken yet β every session checks it at the start of its turn |
takePress |
takes one written press and answers with the work; exactly one caller ever gets a given press, every other is told another session has it. The story's Agent on the board then names the session that took it |
reuse |
what the fleet could reuse instead of paying for again β every warm agent ranked against the pending job, what continuing it would save, what it did and holds, and which lanes already hold the story |
occupied |
who else is already writing a repository, so a lane is not dispatched into a tree another session is changing |
health |
whether every agent is alive, its lifespan, and a list of the ones a main should act on now |
progress |
what every lane is doing right now β steps, files, the last thing it reached for, and how far past its estimate it has run |
releaseRow |
ends a queue row handed to you β waiting, handed over, or failed; with a reason it DECLINES the press, and the board's row says who declined it and why |
holdRow |
holds a queue row handed to you that you cannot start yet: it stays queued and quiet, and is handed to you again after a lane that was running when you held it finishes, once the box has room |
holdLanes |
pauses or resumes your own lanes through the one lane hold the panel's βΈ Pause uses: a held lane reads PAUSED on its row, also after it ended its turn, and is owed no revive until you resume it |
Every reading is a fact, never a refusal: which lane the work goes to is your call.
📊 Usage and 💰 budgets
📊 Usage (the status-bar 💰 item, or the command) adds up this week's transcripts: 🔑 who paid (each payer on each box), 🌐 by computer and all computers together, by computer, account, model and day, 🧾 at a glance (direct App calls included) and 🧾 by source, all against the prices used; a model with no known price is named beside the total, never counted as $0. The first read of a week takes about 40 seconds.
- 🔐 Connect GitHub β signs FleetView in to GitHub once; the sign-in is saved in the machine's
fv.jsonand travels with it. Each computer then writes its own day files to the private repofleetview-usageand reads every other computer's. Until you sign in, the status bar reads Usage not syncing β sign in to GitHub.usage.repoin the machine'sfv.jsonpoints every computer at another repo instead. - Sources counted β Claude Code (main sessions and subagents), GitHub Copilot, OpenAI Codex rollouts under
~/.codex/sessions, and direct API calls your own scripts record. - Direct API calls β a script appends one JSON line per call to
~/.fleetview/app-usage/<user@host>/<YYYY-MM-DD>.jsonl(~/.bullseye/app-usage/is read too). Python can importscripts/fleetview_usage.pyand callrecord(...); any other language writes{"ts": <epoch ms>, "app": "...", "provider": "...", "model": "...", "inputTokens": 0, "cacheReadTokens": 0, "cacheWriteTokens": 0, "outputTokens": 0, "totalCostUsd": 0.0, "costKnown": false}βcostKnown: falsecounts the call as unpriced, never $0. - A computer with no VS Code publishes with
node vscode-extension/dist/publishUsage.jsfrom a clone. On Windows,scripts/register-usage-publish.ps1schedules it every 15 minutes with no window. It signs in with the token saved in the machine'sfv.json, elseGH_TOKEN, the GitHub CLI, or Git's own GitHub sign-in, and reads the repo from the samefv.json. - 🧾 TOKEN report writes the same figures to a standalone HTML file you can keep or send.
- 💰 Budgets β set a daily token or dollar budget per project in
budgetsof the machine'sfv.json. The 💰 item then reads Budgets OK or names the project that went over, and turns red.
Status bar
| Item | Reads |
|---|---|
| 🚢 🏃 N Β· 💤 M | Running and standby agents, always visible, matching the Only me scope; opens the Fleet tab |
| 🚧 release not shipped | A release a lane started in the background that failed or was killed β shown only while one stands |
| CPU gate | A lane the box's CPU gate is holding β shown only while one is held |
β³ / 🔨 / β
/ β / β οΈ CB <sha> |
The continuous build: queued, building, green with its time, red with its error count, or unfinished; the hover is a table, and a red build's errors go to the Problems panel. Shown only on a machine whose build writes its state |
| Usage not syncing | Until this computer signs in to GitHub for usage sync |
| 💰 | Today's budgets, shown only once you have set one |
Commands
| Command | Does |
|---|---|
FleetView: Show Fleet |
Reveal the Fleet tab |
FleetView: Refresh |
Re-read every source from disk |
FleetView: 📊 Usage |
Open the usage tab |
FleetView: 🔐 Sign in to GitHub for usage sync |
Sign this computer in once for usage sync |
FleetView: 🧾 TOKEN report |
Write the usage report and open it in your browser |
FleetView: 🔒 PROGRESS check (opt-in hook) |
Install the PROGRESS check, or take it back out |
FleetView: 🔌 Install the hooks the start path needs |
Install the hooks a βΆ🚢 Start press needs on this machine |
FleetView: Toggle Detailed Log (evidence behind each state change) |
Switch FleetView's log to the evidence behind each state change and back |
FleetView: DEV |
The DEV pulldown, in the Fleet tab's own toolbar β only on a machine with this extension's own checkout open |
Files it reads
| Source | Used for |
|---|---|
~/.claude/sessions/*.json |
which main agents are alive right now |
~/.claude/projects/<enc-cwd>/<session>.jsonl |
session identity, terminal status, the harvest, story ids |
~/.claude/projects/<enc-cwd>/<session>/subagents/agent-<id>.jsonl and its .meta.json |
per-subagent transcript, worktree path, model |
~/.claude.json, ~/.claude/settings.json, ~/.claude/.credentials.json |
which Claude account or BYOK endpoint this machine is using, for 📊 Usage |
VS Code's User/workspaceStorage/<id>/GitHub.copilot-chat/ and User/globalStorage/ |
Copilot Chat sessions, turns and tool results |
CODEX_HOME/sessions (~/.codex/sessions) |
Codex threads: turn state, model, tokens, answer |
BACKLOG.md / BACKLOG_ARCHIVE.md above an agent's folder, and <board>/.fleetview/press/ |
where a 📋 Story link lands, and the Start presses waiting there |
~/.fleetview/app-usage/ and ~/.bullseye/app-usage/ |
per-call AI spend your own scripts record, for 📊 Usage |
~/.bullseye/claude-accounts/, ~/.bullseye/claude-provider.json |
names for your Claude accounts and BYOK endpoints, if an account switcher keeps them there |
A file or folder that is not there reads as "none"; one that is there and cannot be read is named as a failure.
What it needs
Requires VS Code 1.101 or newer. Each tool below only powers the part named beside it; a machine without it still shows the whole roster.
Tool on your PATH |
Powers | Without it |
|---|---|---|
git |
🌿 Worktree, the Diff tab, the worktree strip | each says git could not be read, rather than showing a clean tree |
claude (the Claude Code CLI) |
💬 Chat, the session a Start press opens, and the revive after a reload | the button fails with the command's own error |
gh, or Git signed in to github.com |
📊 Usage sharing for the headless publisher | that machine writes its own day files and says it is not syncing |
| Environment variable | Effect |
|---|---|
CLAUDE_CONFIG_DIR |
where Claude Code's files are read and the hooks are written, instead of ~/.claude |
CODEX_HOME |
where Codex threads are read, instead of ~/.codex |
ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN |
a BYOK provider is live: 📊 Usage names it by its host, and the sessions FleetView starts name a model that provider serves |
GH_TOKEN / GITHUB_TOKEN |
the headless publisher's GitHub sign-in when the machine's fv.json holds none |
What it writes
FleetView writes only inside your own machine's Claude Code and VS Code files, and beside your board:
- A copy of its own MCP server and hook scripts into this extension's VS Code storage folder, kept equal to the installed build.
- The hooks β the PROGRESS check and the start-path hooks, only when you press their command. Nothing else in that settings file is rewritten.
- Start presses under
<board>/.fleetview/press/, and the mark a session leaves when it takes one. - The RELOAD pause under
~/.bullseye/fleetview/reload-pause/, lifted when the reload ends or you choose not to reload. - Its own usage day files under
~/.bullseye/usage/, the identity ledger~/.bullseye/identity-ledger.ndjson, and the report file when you ask for 🧾 TOKEN report. - Its own state under
~/.claude/fleetview/(the reload snapshot, the resume briefs, rows you dismissed, andlifespans.jsonβ each lane's start, every state it was seen to enter, and its end, for the lanes on the roster now). - The fleet's holds under
~/.bullseye/fleetview/:story-holders.json, which lane holds which story, read by the dispatch door; andlane-hold/, the record of a lane paused for RELOAD so it is released untouched. - The folder-trusted flag for one folder in
~/.claude.json, only when you 💬 Chat into a folder Claude Code has not trusted yet.
Privacy
FleetView reads your machine and nothing else, with one exception you opt into: once you sign in to GitHub, the 📊 Usage day files are exchanged with a private repo in your own account (fleetview-usage, or the one usage.repo in the machine's fv.json names) over GitHub's API. Without that sign-in FleetView makes no network calls of its own. The only other socket is local: the one fleetview MCP process listening on 127.0.0.1:7472, which answers sessions on this computer and keeps running after the window that started it closes.








