Agent Watch

A status bar chip that shows every running coding agent session at a glance: the Agent Watch robot, the number of agents working, and one dot per session. For now it supports Claude Code.

The number after the robot counts the agents working right now, like the Source Control count of changes; the panel's badge in the activity bar shows the same number. The robot takes the color of the most urgent status: red if any session is waiting, yellow if any is working. With no sessions, the chip says No agents, in the language VS Code uses (English and Spanish so far).

Supported agents

Agent Watch is not tied to a single agent, but for now it supports only Claude Code.

Sessions open in the Claude Code extension's chat; CLI sessions focus their terminal instead. It works best on Linux; see Limitations.

This is a community project, not affiliated with or endorsed by Anthropic.

Using it

• Hover the chip to see the sessions in the same order as the dots, numbered, each with its title, status, time in that status, folder and branch, and what it is doing right now. Click a title to open that session. The filter links at the top (All · Working · Waiting · Idle) choose which sessions the chip and the panel show.
• Click the chip to open a searchable session picker. The first waiting session is highlighted, so Enter takes you to it. The funnel button in its title bar opens the status filter.
• A funnel appears in the chip while a filter is active. The filter is remembered across restarts.

The panel

The robot in the activity bar opens the Agent Watch panel: every session in one tree, with a badge counting the agents working.

• Expand a session to see what it is doing, its folder and the files it edited, with the lines added and removed (or new, deleted, no changes). Changes are measured from where the work started, so what the session already committed counts too: on a branch, from where it left the default branch (main, master or origin's HEAD); on the default branch itself, from where HEAD was when the session started; failing both, from HEAD. The Files edited row says which (since main, since session start). A file edited and committed many times shows its final state against that starting point.
• Only files inside the workspace open in VS Code are listed, or inside a git worktree of one of its repositories wherever that worktree is: agents often work in worktrees under /tmp, and those files show with the worktree's branch (worktree feat/x). An agent's scratch files, say in /tmp, are left out. Inside a git repository a file must also be tracked (or have existed at the starting point, so files the session deleted still show), which leaves out ignored and build files, and new files until they are added to git; in a workspace without git, every file edited inside it is listed. Each file is compared with the repository it lives in, also in multi-root workspaces.
• Click a file to open the diff from that starting point to the working tree; the second button on the row opens the file itself. Edits made by the session's subagents count too.
• Group by branch with the branch button in the panel's title bar (or agentWatch.groupBy). Sessions that share a working tree land in the same group, which shows at a glance which agents may step on each other; each worktree is a group of its own. Grouping also applies to the chip (groups are separated by ·), the hover and the picker.

What each agent is doing

While a session works, the hover, the picker and the panel show its latest tool call in words, read from the session's transcript: Editing auth.ts, Running: Run the tests, Searching for "login", Running a subagent: Explore the API. Until it calls a tool it shows Thinking…; while it waits, what it waits for. Activity updates every few seconds.

Notifications

When a session in this window stops to wait for your decision, a notification says which one and what it needs, with an Open button that takes you to it. Turn Off in the notification (or agentWatch.notifyOnWaiting) disables them.

The images are mockups drawn by docs/render.js with made-up sessions, using VS Code's icons and Dark Modern colors.

Agent Watch only takes you to sessions that already exist; it never starts one. Clicking a session shows it in Claude Code:

• If it is open in a tab, or in Claude Code's sidebar, it is shown there.
• Otherwise it reopens in a tab from its transcript, with its whole conversation.

Chats that have no messages yet are hidden (set agentWatch.showEmptySessions to see them) and never opened: Claude Code cannot restore an empty chat, and asked to, it starts a new one instead. Your Claude Code settings are never touched.

Sessions running in an integrated terminal focus that terminal instead.

Sounds

A sound plays when a session in this window changes state, so you can look away while agents work:

Several sessions changing at the same moment make one sound, and if one finishes while another starts waiting, only the waiting sound plays. Each window only sounds for its own sessions. Sounds are played with the system player (pw-play, paplay or aplay on Linux, afplay on macOS). The finish blip is generated by scripts/make-sounds.js; the waiting sound is a recording by another author (see Credits).

How it works

Each agent is read by a provider (see Adding an agent). For Claude Code:

• Sessions: Claude Code writes one record per running session to ~/.claude/sessions/<pid>.json (or $CLAUDE_CONFIG_DIR/sessions) with its status (busy, waiting, idle), cwd and start time. The extension watches that directory and re-checks every 5 seconds. It only reads the .json records, never the .key files next to them.
• Titles, activity and edited files: read from the session's transcript in ~/.claude/projects/ and its subagents' transcripts. Each refresh reads only what was appended since the last one.
• Branches and changes: the branch comes from the folder's .git (worktrees included) without running git; line counts and diffs run git status, git diff and git show, only when the panel asks.

And for every agent:

• Liveness: a session whose process is gone, or whose PID was reused by another process, is ignored.
• Which window owns a session (Linux): chats opened by an agent's VS Code extension are child processes of the window's extension host; CLI sessions descend from one of the window's terminal shells. The extension walks /proc to tell them apart.

Nothing leaves the machine: no network calls, no telemetry.

Reliability

• It never starts a session. Only sessions with a transcript are handed to Claude Code, in the mode that reveals or restores them rather than the sidebar route, which opens a new empty chat when Claude Code's sidebar is closed. Clicks are handled one at a time.
• Nothing blocks VS Code. Files are read asynchronously; a terminal that never reports its process, a refresh that hangs or an audio player that gets stuck are all cut off after a timeout.
• Odd data is skipped, not shown. Half-written records, invalid fields, records from another machine or PID namespace (a dev container sharing ~/.claude), dead processes and reused PIDs are ignored. Two processes on the same session show as one dot. Titles are escaped before they reach the hover, which runs trusted command links.
• Invalid settings fall back to their defaults.
• Problems are written to the Agent Watch output channel (Agent Watch: Show Log), once per distinct problem.

Settings

Sessions that belong to another window or to a terminal outside VS Code are shown with the workspace and all scopes, but are not opened from here: attaching a second client to a running session would conflict with it.

Adding an agent

Everything specific to an agent lives in a provider under src/providers/. A provider lists its sessions in a shared shape (process, folder, status, what it waits for), describes each one (title, current action, edited files, branch) and, if the agent has a VS Code extension, opens a session in it. The chip, hover, picker, panel, sounds and notifications work from those fields alone. src/providers/index.js documents the interface and registers the providers; src/providers/claude-code/ is the reference implementation.

Limitations

• Claude Code's session records and transcripts are internal formats, not a documented API. If an update changes them, sessions or their activity may stop showing; Claude Code itself is unaffected.
• A status bar item takes a single text color and a single click target. That is why the dots are emoji, and why sessions are opened from the hover or the picker rather than by clicking an individual dot.
• Window ownership needs /proc (Linux). Elsewhere, sessions inside the workspace folders count as this window's.

Install

From the Visual Studio Marketplace: search for Agent Watch in the Extensions view, or run

code --install-extension csantosm.agent-watch-status

From source

You need node (18 or later, with npx) and VS Code's code command:

git clone https://github.com/CSantosM/agent-watch.git
cd agent-watch
./package.sh --install

package.sh builds the .vsix with the official packager, vsce, which runs the tests first and refuses to package if any fails. Then run Developer: Reload Window in each open VS Code window. To uninstall: code --uninstall-extension csantosm.agent-watch-status.

Development

Run the tests with npm test (or node --test 'test/*.test.js'). The extension tests start real sleep processes to stand in for Claude sessions, so they need Linux.

Credits and license

The code is under the MIT License.

media/waiting.wav, the waiting sound, is "Gunpoint" by LilMati on Freesound, released under CC0. The file's own metadata names Mattias "MATRIXXX" Lahoud and a Creative Commons Attribution license, so it is credited here either way.