Skip to content
| Marketplace
Sign in
Visual Studio Code>Visualization>FleetViewNew to Visual Studio Code?Β Get it now.
FleetView

FleetView

Karish911

|
2,029 installs
| (1) | Free
🚒 Run a fleet of AI agents without losing one: RELOAD pauses every agent and asks you once, a Start press is taken by exactly one session, 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 lanes a restart killed come
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

🚢 FleetView

Run 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.

What you get Since 2026-10-17
🔥 FleetView's own CPU fell from 82–86% to about 24% on the busiest box measured β€” it reads only what changed 🆕
⚑ RELOAD that never loses work by surprise β€” every agent is paused at a safe point, then ONE question lists what still runs, agent by agent, process by process, and nothing is killed until you answer 🆕
β–Ά🚢 Start agents from the board, in any session β€” a press is written down and taken by exactly one session; with no chat open FleetView starts one 🆕
🚪 A lane cannot walk away from its story β€” it may not end while a story it holds whole is open (unless the story is recorded as blocked on you or an outside party), or while a process it started still runs 🆕
🛟 Lanes come back by themselves after a restart killed them, once each 🆕
🌿 Every stray worktree and branch, in every project, on one line β€” who owns each, and one 🧹 Cleanup 🆕
🎫 A queue you can work in bulk β€” pick several rows, remove them together, see the agent that holds each story 🆕
🗂️ One live roster β€” Claude Code, Copilot Chat, Copilot CLI and Codex, each agent's state named in plain words Copilot CLI 🆕
♻️ Reuse instead of re-paying β€” what waking a warm agent saves, line by line
📊 This week's tokens and dollars by computer, account, model and day, against your budgets

🎯 Better together: BullseyeUber

FleetView 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.

  • The board and the fleet in one view. The 🎯🚢 Pair layout stacks the BullseyeBacklog board over the roster, so a story row and the agent working it sit on one screen, tied by the story number.
  • Start on the board, watch it here. BullseyeBacklog's β–Ά🚢 Start agents press feeds the 🎫 Queue FleetView starts from, and the agent's progress and ETA come back onto the board row.
  • One safe reload for every extension. FleetView's ⚑ RELOAD pauses every agent before the window goes, and brings back the lanes it took down.
  • Cost beside the keys. DeepAgent's per-agent BYOK / Subscription picks are one tab away, and its balances are read from the same ledger as your week's tokens and cost.

👉 Get BullseyeUber on the Marketplace

✨ What's new since 2026-10-17 β€” most important first

1. 🔥 A fleet watcher that no longer eats the box

On 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 once

Press ⚑ 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:

  • Reload stops every process listed and reloads at once; an agent that ignored the pause is killed by pid with its descendants, with no second question, and the log names it, its story and why; Cancel lifts the pause and every agent carries on exactly where it was.
  • Every process is sorted for you: 🟢 short, read-only work (a git status, a file read) that loses nothing, and 🟠 long, disruptive work (a build, a parse) whose kill costs the time it ran. Each one is named in plain words β€” what the command does, read through its whole chain, with a guess labelled as a guess β€” and the work a kill would lose.
  • One agents table: story, lane, the folder it works in, 🟢 N short, read-only Β· 🟠 N long, disruptive, and its state β€” ⏸️ PAUSED or ⏳ PAUSING with the call it is finishing. Each agent folds open (β–Έ) to show every process it runs. ⧉ Copy carries every process, folded or not.
  • A Copilot CLI lane is held by suspending its process and released untouched β€” never killed. A Codex chat begun after Codex's hooks were switched on is held like a Claude Code one: its subagent threads pause, and the chat itself may start no new one until you answer. A Codex chat begun before the hooks were on, or a VS Code Copilot chat, reads NOT HELD with the reason.

The RELOAD question: one agent paused, three finishing their call, one opened to show its build and status processes

3. β–Ά🚢 A Start press is a written record any session can take

A β–Ά🚢 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 presses and takePress tools. Exactly one session ever gets a given press.

  • When no chat is live on this machine, the press stays written on disk and FleetView starts nothing; the next Claude Code, Copilot or Codex session opened on that board takes it.
  • providerOrder in the workspace's fv.json sets which provider the story queue starts a worker on, top to bottom: AUTO takes the first whose subscription has room.
  • A row handed over that no lane takes is handed to the board again.

4. 🚪 A lane cannot end before its story is done

A 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 themselves

A 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 project

Under 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.

The worktree strip opened: six trees and branches across two projects, each with its story, whether it is in main, and its owner

7. 🎫 A queue you can work in bulk

Tick 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.

The queue: six pressed stories, two of them picked for a bulk remove

8. 🚦 Every lane's state, in plain words

State Means
🔴 IDLE the lane is sleeping in a poll loop instead of working
📦 RELEASING the lane is building and publishing its release
🔒 WAITING on the build lock another lane holds β€” not stuck
βœ… DONE Β· 🗄 ARCHIVED its story is finished
finished a review lane that delivered its verdict

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 wrong

A 🚧 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 calmer

The 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 .git pointer once and rereads it only when it changes, the panel no longer waits on the worktree sweep, and the one shared tooltip opens after the pointer rests, stays while the pointer is on it, and goes the instant it leaves. A button keeps its own label while it works.

See the Changelog tab for every version.

🚀 Start

Tell your AI what you want β€” fanout #412 #407 #419, or just a sentence β€” then open the Fleet tab to watch. Nothing is typed into FleetView itself.

Say it to your AI β€” what you type, and what you get

1. Start the work. In your Claude Code chat:

fanout #412 #407 #419

One agent per story starts. Each shows up on the roster with its story, its progress and an ETA that counts down.

The roster: five agents in two projects, each on its story, with progress, ETA and reuse reading

2. Ask what the board says about an agent.

Which agent is on story #412, and what does the board say it still has to do?

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.

Hovering #412 on the roster: the board's own priority, size, percent and LEFT

3. Reuse a warm agent instead of paying for a new one.

Before starting anything new, check whether the agent that cut the 3.2 release notes can take this on.

Your AI asks FleetView's reuse tool; each row's ♻️ cell shows the answer β€” 🆕 fresh, 🔥 standby with what waking it saves, ♻️ already reused. Click it for the whole derivation.

The Savings view: what continuing a finished agent saves, line by line

4. Look at the plumbing too.

Show me everything running, including the watches and background commands.

Watches and background shell commands that carry no story are hidden by default. Tick Infra agents and they appear, marked as processes, not agents.

Infra agents ticked: a CI watch and a shell command appear among the story agents

5. Ask what it cost.

What did my agents cost this week, by model and by machine?

The Usage tab: this week's tokens and dollars by computer, model, day and source

The TOKEN report: the same figures as a standalone page you can keep or send

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

  1. 🗂️ One live roster for every agent you run β€” Claude Code sessions, background sessions and subagents, GitHub Copilot Chat sessions, Copilot CLI sessions, and OpenAI Codex threads with their nested subagents, each with its status, model, tokens, context, files read and worktree branch.
  2. 🩺 Stuck detection with nudges β€” a silent lane is caught at a 30-second no-progress bound, a lane past 15 minutes or twice its story's wall clock is flagged, and a lane waiting on a live release lock or a background run reads waiting, not stuck. Main hears only about red overruns, dead lanes and revives, batched to one message a minute.
  3. 👥 One agent per story, or one per declared part β€” a story handed to a lane is held by that lane; a team of lanes on one story β€” parts, or a reviewer beside its author β€” reads as a team, a second lane on the whole story as a duplicate. The dispatch door refuses an undeclared brief on a held story and names the line to add.
  4. ♻️ Reuse instead of re-paying β€” 🆕 fresh, ♻️ Γ—N reused, 🔥 standby with what waking it saves. Codex agents get the same reading as Claude.
  5. 🔥 Light on your machine β€” no program started per beat, only what a transcript appended is read, unchanged finished lanes cost no git.
  6. 🧭 Process monitoring that points at the right lane β€” a process is pinned only on its own subagent, Git Bash children and detached processes are counted, and the Task cell shows only the processes that breach a bound.
  7. 📈 Progress read as a claim, never a measurement β€” the lane's own PROGRESS: <n>% β€” ETA <m>m line, with the countdown, revisions and overrun; a lane that states none falls back to FleetView's own readings.
  8. 🤖 One MCP server for every chat β€” Claude Code and GitHub Copilot Chat ask the same fleetview process what the fleet is doing, before they dispatch.
  9. 🔗 Joined to BullseyeBacklog β€” the 📋 Story column names each agent's story; a story id belongs to the board that minted it, and an archived story a live lane still works is put back on the board.
  10. 🙈 Infra agents on demand β€” watches and background commands that carry no story stay hidden until you tick the box.

How it works with BullseyeBacklog

FleetView 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.

You say The board shows FleetView shows
fanout #412 #407 #419 (or press β–Ά🚢 Start agents on the board) the stories with a live agent icon one agent per story, with progress and ETA
hover a story number on the roster β€” the board's priority, size, % and LEFT for that story
hover the live agent icon on the board the agent's progress and ETA β€”

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 reads

FleetView 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_HOME/sessions (or ~/.codex/sessions).

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 tab

Nothing of FleetView opens by itself at window start. The Fleet tab is an editor tab, not a sidebar view; FleetView: Show Fleet or the status-bar item opens it.

A session is a group row: a caret that collapses it, a live or idle dot, the session name, its ID, 🏃 N running Β· 💤 M standby counted over the rows actually shown, and its up time. A session whose own read failed says so on its header before those counts.

Under each session, one entry per agent. Every column sorts and resizes, and the layout survives a reload:

Column Reads
🕐 Started when the agent began
💓 Pulse how long ago it last wrote to its transcript
🚦 Status 🏃 Running Β· 💤 Standby Β· ⏳ Waiting Β· ⏸️ Paused Β· ❔ Presumed stopped Β· ⏹️ Stopped
β–°β–°β–± Progress the lane's own PROGRESS: <n>% β€” ETA <m>m claim β€” the bar, the %, the countdown, how often it was revised
📝 Task the agent's description, and what it is doing right now
📋 Story the BullseyeBacklog story its own dispatch assigned it, clickable
🤖 Model the model badge β€” on a BYOK provider, the model the transcript names β€” orange when it changed mid-run
♻️ Reuse 🆕 fresh, ♻️ Γ—N reused, or 🔥 standby with what waking it saves
🔢 Tokens Β· 🧠 Context Β· 📂 Files what its own transcript recorded
🌿 Worktree the agent's own worktree branch
🆔 Agent the id you paste back to the main agent

☰ 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

Button Does
🎫 Queue Opens the queue, with its live count
💬 Chat Chat with the one selected row. A Claude subagent opens here with its conversation and a message box: a running one reads your words on its next step, and one that has ended sends them to its parent chat. A session, a Codex or a Copilot agent opens its own prompt
📄 Output Β· 🔀 Diff Β· 🌾 Harvest Opens the agent's panel on that tab β€” see below
β›” Kill Stops the selected running rows
🔃 Refresh Re-reads every source from disk
⚑ RELOAD Pauses every agent, asks once, reloads β€” see above
☰ Columns Shows or hides columns
📜 Logs FleetView's own output channel, where every settled subagent is logged with its duration and newest write; the same note waits on the status bar with View result and View output
🧾 TOKEN report Writes and opens the token usage report

The PROGRESS line, and the check you can install

Every lane FleetView shows is asked to end each reply with one line:

PROGRESS: <n>% β€” ETA <m>m β€” DONE: <done> β€” NEXT: <next>

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.

What it writes PreToolUse, PostToolUse, SubagentStart and UserPromptSubmit hooks, appended to ~/.claude/settings.json (or your CLAUDE_CONFIG_DIR) β€” only when you press Install
What it does to the rest of your settings Nothing. Hooks are lists and they chain: the check is appended to whatever is registered, and a settings file FleetView cannot read is refused by name rather than rewritten
Your own hooks They still run, untouched
Taking it back out The same command, which removes exactly the entries it added

🔌 The hooks a Start press needs

A 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; FleetView: 🔌 Install the hooks the start path needs installs the dispatch door (PreToolUse) and the stop door (SubagentStop), clears a disableAllHooks that would silence them, and appends to your hooks rather than replacing any.

Agent detail β€” Output Β· Diff Β· Harvest

Click a subagent to open its panel.

  • Output β€” tails that agent's own transcript, live; prose, 🔧 tool calls and β†©οΈŽ tool results are rendered apart. It follows the tail and pauses the moment you scroll up.
  • Diff β€” git diff of the agent's worktree against its merge-base with the default branch, committed and uncommitted work and untracked files included, re-diffed every 6 seconds while the agent is alive. Hover a changed line and click 💬 to draft a review comment pre-filled with the agent id and file:line, then ⧉ Copy for main agent. Rendering is capped at 60 files and 500 lines per file.
  • Harvest β€” what the subagent handed back and its terminal status, the main agent's next turn, and the tool calls it queued off the back of it β€” read from the parent session transcript.

βš™οΈ Settings

FleetView keeps no VS Code settings. Its settings live in fv.json, committed in the workspace repo, and the window, the service on 7472 and the web page all read and write that one file:

  • A workspace's own β€” <workspace>/.bullseye/settings/fv.json for every workspace on the Bullseye Control list.
  • The machine's β€” the fv.json of the BullseyeVSC checkout, or ~/.bullseye/settings/fv.json on a box without one.
  • This box only β€” ~/.bullseye/settings/[<workspace>/]fv.box.json, never committed.

The file is { "schema": 1, "settings": {…}, "ui": {…}, "secrets": {…} }. A change is written to a temporary file and renamed over the old one, then committed on its own and pushed, so every box gets it on its next pull.

Where Key Does
workspace settings maximumLanes how many lanes run at once (the spinner on the queue strip)
workspace settings providerChoice auto, claude, copilot or codex β€” the picker on the queue strip and on the BullseyeBacklog board
workspace settings providerOrder which provider the story queue starts a worker on, top to bottom (Claude, Copilot, Codex): AUTO takes the first whose subscription has room
workspace ui fleet what the roster remembers on every box: filters, sort, hidden columns, column widths
workspace box fleetHere what the roster remembers on this box only: folded sessions, dismissed notices
machine settings model / subscriptionModel the model named for a working session, on a BYOK provider / on your subscription (empty names none)
machine settings fastModel / subscriptionFastModel the model named for a session that only carries out a written instruction
machine settings usage.repo the GitHub repo every computer writes its daily usage file to (owner/name, or a bare name under your account)
machine settings budgets daily token or dollar budgets per project
machine secrets githubToken the GitHub sign-in the usage store uses: kept from VS Code's GitHub sign-in when the file holds none, and replaced when you click sign in to GitHub

Keys in the repo. githubToken is stored in plain text in the private repo, as you chose. Git keeps every earlier value forever, in every clone; anyone who can read the repo can use it; removing it for real means rewriting history and revoking the token at GitHub. FleetView never prints it.

Moving from VS Code settings. The first start of this build copies each fleetView.* value VS Code still holds into these files once per box, never over a value a file already holds.

🤖 The fleetview MCP tools

FleetView runs one MCP server named fleetview per machine, at http://127.0.0.1:7472/mcp β€” it is resident on the machine and serves with no VS Code window open: a panel tool no window can answer runs in it, through the code a window's press runs, on the rows of the workspace the call names. Every session and window is a client of the same process. It is published to VS Code, so GitHub Copilot Chat reaches it with no setup; Claude Code reaches it through a fleetview entry naming that URL, which you add yourself to ~/.claude.json or a folder's .mcp.json β€” FleetView never writes it. It reads the roster off disk and changes only what these tools say: a Start press it marks taken (and the board row's Agent, which then names the taker), a queue row you release on purpose, and a queue row you hold for later.

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.json and travels with it. Each computer then writes its own day files to the private repo fleetview-usage and reads every other computer's. Until you sign in, the status bar reads Usage not syncing β€” sign in to GitHub. usage.repo in the machine's fv.json points 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 import scripts/fleetview_usage.py and call record(...); any other language writes {"ts": <epoch ms>, "app": "...", "provider": "...", "model": "...", "inputTokens": 0, "cacheReadTokens": 0, "cacheWriteTokens": 0, "outputTokens": 0, "totalCostUsd": 0.0, "costKnown": false} β€” costKnown: false counts the call as unpriced, never $0.
  • A computer with no VS Code publishes with node vscode-extension/dist/publishUsage.js from a clone. On Windows, scripts/register-usage-publish.ps1 schedules it every 15 minutes with no window. It signs in with the token saved in the machine's fv.json, else GH_TOKEN, the GitHub CLI, or Git's own GitHub sign-in, and reads the repo from the same fv.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 budgets of the machine's fv.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, and lifespans.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; and lane-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.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
Β© 2026 Microsoft