Agent Dashboard for VS Code

Monitor, chat with, and control your AI coding agents from anywhere -- including from your phone. Send prompts to GitHub Copilot, Claude Code, and other agents running in VS Code, view their responses in real time, and track every session, tool call, and token across all your machines.

Main Dashboard

See all your active AI agents at a glance — status, model, token usage, estimated cost, and task progress — all in one unified view.

Session Chat History

Expand any agent to view the full conversation — user prompts, assistant responses, and every tool call with inputs and outputs.

Session Details

Drill into session details including active tools, modified files, process info, and real-time token breakdown.

Why Agent Dashboard?

AI coding agents run in the background, sometimes for minutes. Without visibility you're left wondering: Is it still going? How many tokens has it burned? Did it error out?

Agent Dashboard gives you a live control room for every AI agent in your development environment:

Chat with your agents from your phone — send prompts to Copilot and Claude Code running in VS Code, and see their responses streamed back in real time via the companion iOS app
Remote control from anywhere — interact with agents over local Wi-Fi, Dev Tunnel, or a self-hosted relay, no matter where you are
See all running agents at a glance with live status updates
Track token usage and estimated costs in real time
View tool calls, file edits, and conversation history as they happen
Monitor agents across multiple VS Code windows and remote machines

Features

Live Agent Monitoring

Track every active AI coding agent across all your projects. Each agent card shows real-time status, model, token consumption, active tool calls, and elapsed time. The dashboard auto-refreshes every 3 seconds.

Supported agents:

GitHub Copilot -- Chat sessions, inline completions, and workspace agents
Claude Code -- CLI sessions with full JSONL transcript parsing
OpenAI Codex -- Session monitoring via ~/.codex/sessions/
Aider -- Chat history monitoring
Custom agents -- Define your own in .github/agents/

Multi-Source Data Providers

Agent Dashboard uses 11 independent data providers that can be individually toggled:

Provider	What it detects
Copilot Extension API	Active Copilot chat sessions via the extension API
Copilot Chat Sessions	Rich session data from VS Code's `workspaceStorage` (JSON + live JSONL)
VS Code Chat Sessions	Sessions via the proposed Chat Sessions API (requires VS Code 1.109+ with proposed APIs)
Chat Tools & Participants	MCP tools, chat participants, and workspace agents
Claude Code (JSONL)	Claude CLI sessions from `~/.claude/projects/`
Terminal Processes	Running `claude`, `codex`, `aider` processes
Custom Workspace Agents	Agent definitions in `.github/agents/`
GitHub Actions	Claude/Copilot workflows via `gh` CLI (Auto-authenticates via VS Code)
Remote Connections	SSH, WSL, and container sessions
Workspace Activity	Git and file system activity signals
Peer Instances	Agents from other VS Code windows (same machine + cross-machine via Settings Sync)

Token Usage & Cost Tracking

See exactly how many tokens each agent has consumed, broken down by input, output, cache creation, and cache read tokens. Estimated costs are calculated automatically based on the model.

Live Session Reading

Agent Dashboard reads live Copilot Chat sessions directly from VS Code's incremental JSONL files — not just finalized JSON snapshots. This means you see conversation turns, tool calls, and token usage as they happen, even while the agent is still running.

The JSONL parser handles VS Code's incremental patch format (snapshot + set/splice operations) and normalizes all response formats (thinking blocks, tool invocations, markdown content) into a unified structure.

Conversation History

Expand any agent to view its full conversation history, including user prompts, assistant responses, and every tool call with inputs and outputs. Conversations load on-demand to keep the dashboard fast.

Agent Role Classification

When agents spawn sub-agents, the dashboard automatically classifies each agent's role:

Orchestrator — an agent that other agents report to via parentId
Sub-agent — a child agent spawned by an orchestrator
Main — a standalone top-level agent

Roles appear as badges on agent cards and help you understand multi-agent workflows at a glance.

Activity Feed

A live timeline of everything happening across all agents -- tool calls, file edits, commands, completions, and errors -- with relative timestamps.

GitHub Actions Integration

Agent Dashboard automatically monitors your GitHub Actions workflows. It uses the gh CLI under the hood, but automatically authenticates using your built-in VS Code GitHub account. No need to run gh auth login manually — just sign in to GitHub in VS Code and your workflows will appear in the dashboard.

Agent Controls

Via Remote Control (iOS app / WebSocket): For agents with a known process ID, the remote control managers support signal-based process control:

Control	Action
Pause	Sends `SIGSTOP` to suspend the agent process
Resume	Sends `SIGCONT` to resume execution
Stop	Sends `SIGTERM` to terminate the process

These controls are available through the iOS companion app or WebSocket remote control sessions. They are not yet available in the VS Code dashboard webview (pending VS Code Chat Sessions API support).

In the Dashboard Webview:

Control	Action
Details	Expands agent detail card
Chat	Opens the conversation history panel
Log	Opens the extension output log

Multi-Window & Cross-Machine Peer Sync

Agent Dashboard auto-discovers peer instances across VS Code windows and even across different machines, showing all agents in a unified view. Peer agents appear with a gold tag showing which window/machine they belong to.

Same machine (zero config): Instances register themselves via a shared file at ~/.agent-dashboard/instances.json. Just set a different agentDashboard.apiPort in each window.

Cross-machine (automatic via Settings Sync): When multiple machines are signed into the same GitHub account with VS Code Settings Sync enabled, the extension automatically discovers peers across machines using Dev Tunnels.

Requirements for cross-machine discovery:

Same GitHub/Microsoft account — Both VS Code instances must be signed into the same account
Settings Sync enabled — Go to File > Preferences > Settings Sync (or Code > Settings > Settings Sync on macOS) and ensure it is turned on. The extension uses globalState sync to share a peer registry across machines.
Dev Tunnels enabled — The extension must have a Dev Tunnel running on the machine you want to connect to (enabled by default via agentDashboard.devTunnel.enabled)
GitHub authentication — Sign in to GitHub in VS Code on both machines (required for Dev Tunnels)

Note: Settings Sync propagation can take a few minutes. After enabling sync on both machines, wait 2–5 minutes for the peer registry to propagate. Use the Agent Dashboard: Dump Peer Registry (Debug) command to check the registry state.

Manual remote peers (alternative): If Settings Sync is unavailable, you can manually specify remote peers via the agentDashboard.remotePeers setting:

"agentDashboard.remotePeers": [
  { "host": "your-tunnel-url.devtunnels.ms", "port": 443, "token": "your-api-token", "name": "Work Laptop" }
]

Discovery tiers (in order):

Local file registry (~/.agent-dashboard/instances.json) — same machine, auto
Manual local ports (agentDashboard.peerPorts) — same machine, manual
Manual remote peers (agentDashboard.remotePeers) — cross-machine, manual
Settings Sync peer registry (globalState) — cross-machine, automatic

Mobile Monitoring (iOS Companion App)

For the full Agent Dashboard experience, download the free Agent Dashboard companion app from the Apple App Store. Monitor your agents from anywhere with three connection modes:

Local Wi-Fi (zero setup): The extension runs a REST API server on port 19850. Point the iOS app at your Mac's IP address and you're connected.

Dev Tunnel (free remote access): The extension integrates with VS Code Dev Tunnels to create a public HTTPS URL to your local API. Requires GitHub sign-in — scan the QR code from your phone to connect.

Self-Hosted Relay: Run the included relay server on your own hardware for full control. The extension pushes state to the self-hosted relay automatically.

iOS App Features:

SSE push-based updates — Real-time streaming updates with sequence numbering for reliable delivery
Markdown rendering — Agent responses with bold, italic, code blocks, headers, links, numbered lists, and more rendered as rich text
Image attachments — Attach images from camera, photo library, or clipboard to send with conversation messages
Confirmation cards — Interactive cards for agent confirmations with structured options (label, description, recommended badge)
Pinned todo widget — Collapsible progress tracker pinned at top of conversation view
Full-screen search — Search through conversation messages with a modal search interface
Setup prompt — Guided onboarding when no connection is configured
Disconnect overlay — Full-screen overlay with reconnect status and troubleshooting tips
WiFi security warning — Dismissible warning when connected over unencrypted Wi-Fi
Pull-to-refresh — Swipe down on the agent list to manually refresh
Automatic failover — Seamlessly switches between Wi-Fi and Dev Tunnel connections

Dev Tunnel

The easiest way to access your agents remotely. The extension integrates with VS Code Dev Tunnels:

Free with GitHub — sign in to GitHub in VS Code
Authenticate the Dev Tunnel CLI — in addition to signing in to VS Code, you must authenticate the Dev Tunnel CLI by running devtunnel user login -g in a terminal. This uses GitHub as the identity provider and is required before tunnels can be created.
Creates a tunnel — exposes your local API via a *.devtunnels.ms HTTPS URL
Shows a QR code — scan from the iOS app to connect instantly
Persists across restarts — once enabled, the tunnel auto-starts every time VS Code opens
Status bar indicator — shows tunnel state at a glance

Enable Dev Tunnel in settings (agentDashboard.devTunnel.enabled) to get started.

Relay with Automatic Failover

The extension pushes state to a self-hosted relay server. The iOS app automatically fails over between endpoints when one becomes unreachable, ensuring uninterrupted remote monitoring.

Multi-Instance Cloud Aggregation

When multiple machines push to the same cloud relay, the relay aggregates all instances into a single unified view. See agents from your desktop, laptop, and CI server all in one place on your phone.

Each instance is identified by hostname and workspace name. Stale instances are automatically pruned.

Alerts & Notifications

Get notified when agents complete, error out, or when providers degrade:

Email via SendGrid
SMS via Twilio
Webhooks for Slack, Discord, or custom integrations

Configure alert rules per event type in settings.

Diagnostics

Run Agent Dashboard: Show Diagnostics to see:

All active providers and their health status
Every detected agent with full metadata
Copilot extension details and API availability
Peer instance registry
Chat session file scan results

Background Daemon

A standalone Node.js daemon that monitors CLI agents (Claude Code, Aider, Codex) independently of VS Code. When VS Code is closed, the daemon keeps monitoring and serves the same REST API — so the iOS app and CLI viewer continue working.

Auto-coexistence: The daemon automatically pauses when a VS Code extension instance is detected, and resumes when VS Code closes
Session continuity: Agent IDs are identical between daemon and extension, so conversation history, token counts, and cost data transfer seamlessly
Zero dependencies: Pure Node.js — no npm install required
Start/Stop from VS Code: Use the Settings panel or Command Palette
Start from CLI: Run directly without VS Code (see Development)

The daemon binds to 0.0.0.0:19851 so the iOS app can reach it over Wi-Fi. All endpoints except /api/health require Bearer token auth for non-loopback callers.

Quick Start

1. Install & Open

Install from the VS Code Marketplace, then:

Press Cmd+Shift+D (Mac) or Ctrl+Shift+D (Windows/Linux)
Or click the Agents button in the status bar
Or run Agent Dashboard: Open from the command palette

2. Select Your Agent Source

Open settings and set agentDashboard.primarySource:

copilot -- Monitor GitHub Copilot sessions
claude-code -- Monitor Claude Code CLI sessions
aider -- Monitor Aider CLI sessions
codex -- Monitor OpenAI Codex CLI sessions
both -- Monitor everything simultaneously

3. Optional: Mobile Monitoring

Download the free Agent Dashboard app from the Apple App Store for on-the-go monitoring.

Local (same Wi-Fi): The REST API starts automatically. Open the iOS app and enter your Mac's IP.

Remote (anywhere — recommended):

Enable Dev Tunnel in settings (agentDashboard.devTunnel.enabled)
Sign in to GitHub in VS Code
Authenticate the Dev Tunnel CLI: run devtunnel user login -g in a terminal
Run Agent Dashboard: Show Tunnel QR Code and scan from the iOS app

Self-Hosted Relay (alternative):

Run the relay server: cd self-hosted && npm install && RELAY_SECRET=your-secret npx tsx self-hosted-relay.ts
Set agentDashboard.selfHostedRelayUrl and agentDashboard.selfHostedRelayToken in VS Code settings
Enter the relay URL in the iOS app settings

Commands

Core

Command	Description
`Agent Dashboard: Open`	Open the dashboard panel (`Cmd+Shift+D`)
`Agent Dashboard: Refresh`	Force a manual refresh
`Agent Dashboard: Start`	Start monitoring
`Agent Dashboard: Stop`	Stop monitoring
`Agent Dashboard: Restart`	Restart monitoring
`Agent Dashboard: Exit`	Fully shut down Agent Dashboard
`Agent Dashboard: Show Diagnostics`	Detailed debug info for all providers
`Agent Dashboard: Open Settings`	Open Agent Dashboard settings

Mobile API & Tunnels

Command	Description
`Agent Dashboard: Start Mobile API Server`	Start the REST API for iOS app
`Agent Dashboard: Stop Mobile API Server`	Stop the REST API
`Agent Dashboard: Copy API Token to Clipboard`	Copy the Bearer token for manual API access
`Agent Dashboard: Start Dev Tunnel`	Start a Dev Tunnel for remote access
`Agent Dashboard: Stop Dev Tunnel`	Stop the active Dev Tunnel
`Agent Dashboard: Show Dev Tunnel QR Code`	Display QR code for iOS app pairing
`Agent Dashboard: Dump Peer Registry (Debug)`	Show the Settings Sync peer registry in the output channel

Remote Control

Command	Description
`Agent Dashboard: Start Remote Control`	Start relay-based remote control
`Agent Dashboard: Stop Remote Control`	Stop relay-based remote control
`Agent Dashboard: Toggle Remote Control`	Toggle relay remote control on/off
`Agent Dashboard: Show Remote Control QR Code`	QR code for relay remote control pairing
`Agent Dashboard: Start P2P Remote Control`	Start WebRTC peer-to-peer remote control
`Agent Dashboard: Stop P2P Remote Control`	Stop P2P remote control
`Agent Dashboard: Toggle P2P Remote Control`	Toggle P2P remote control on/off
`Agent Dashboard: Show P2P QR Code`	QR code for P2P remote control pairing

Background Daemon

Command	Description
`Agent Dashboard: Start Background Daemon`	Start the background daemon process
`Agent Dashboard: Stop Background Daemon`	Stop the running daemon

GitHub

Command	Description
`Agent Dashboard: Sign in to GitHub`	Authenticate with GitHub (for Dev Tunnels and Actions)
`Agent Dashboard: Switch GitHub Account`	Switch to a different GitHub account

Settings

General

Setting	Default	Description
`agentDashboard.primarySource`	`copilot`	Agent source: `copilot`, `claude-code`, `aider`, `codex`, or `both`
`agentDashboard.pollInterval`	`3000`	Refresh interval in milliseconds
`agentDashboard.claudeHomePath`	(auto)	Override path to `~/.claude` directory
`agentDashboard.showRemoteAgents`	`true`	Show remote/cloud agent sessions
`agentDashboard.showTokenCost`	`true`	Show estimated token cost
`agentDashboard.enabledProviders`	(all on)	Toggle individual data providers

Peer Sync

Setting	Default	Description
`agentDashboard.peerSync`	`true`	Auto-discover other VS Code instances (local + cross-machine)
`agentDashboard.peerPorts`	`[]`	Manually specify local peer API ports
`agentDashboard.remotePeers`	`[]`	Manually specify remote peers: `[{ host, port?, token?, name? }]`

Mobile API & Remote Access

Setting	Default	Description
`agentDashboard.apiAutoStart`	`true`	Start API server on VS Code launch
`agentDashboard.apiPort`	`19850`	Local API server port
`agentDashboard.apiBindAddress`	`127.0.0.1`	Bind address — set to `0.0.0.0` for direct Wi-Fi access from the iOS app
`agentDashboard.selfHostedRelayUrl`	(empty)	Primary self-hosted relay URL
`agentDashboard.selfHostedRelayToken`	(empty)	Auth token for self-hosted relay
`agentDashboard.cloudRelayUrl`	(empty)	Fallback relay URL (used when self-hosted is unreachable)
`agentDashboard.cloudRelayToken`	(empty)	Auth token for fallback relay
`agentDashboard.devTunnel.enabled`	`true`	Enable Dev Tunnel for remote access (requires GitHub sign-in)

Remote Control

Setting	Default	Description
`agentDashboard.remoteControl.mode`	`auto`	Connection mode: `p2p`, `relay`, or `auto` (tries P2P first)
`agentDashboard.remoteControl.sessionTtlMinutes`	`1440`	Session duration in minutes (default: 24 hours)
`agentDashboard.remoteControl.reconnectIntervalMs`	`5000`	Base delay between WebSocket reconnection attempts
`agentDashboard.remoteControl.maxReconnectAttempts`	`50`	Max reconnect attempts before stopping
`agentDashboard.remoteControl.turnServer`	(empty)	Self-hosted TURN server URL for WebRTC fallback
`agentDashboard.remoteControl.turnUsername`	(empty)	TURN server username
`agentDashboard.remoteControl.turnPassword`	(empty)	TURN server password
`agentDashboard.remoteControl.localDiscovery`	`true`	Enable UDP broadcast for P2P auto-discovery
`agentDashboard.remoteControl.signalingPort`	`19851`	Port for the P2P signaling server

Alerts

Setting	Default	Description
`agentDashboard.alerts.enabled`	`false`	Enable email/SMS/webhook alerts
`agentDashboard.alerts.email.provider`	`none`	`sendgrid` (SMTP support planned)
`agentDashboard.alerts.sms.provider`	`none`	`twilio`
`agentDashboard.alerts.webhook.url`	(empty)	Slack/Discord/custom webhook URL
`agentDashboard.alerts.rules`	(defaults)	Per-event alert routing rules

REST API

The extension exposes a local REST API for the iOS app and integrations:

Endpoint	Method	Auth	Description
`/api/stream`	`GET`	Bearer	SSE push-based state + conversation updates
`/api/state`	`GET`	Remote only	Current dashboard state (agents, activities, stats, tunnelUrl)
`/api/health`	`GET`	No	Health check with version, instance ID, and tunnel URL
`/api/agents/{id}/conversation`	`GET`	Remote only	Full conversation history for an agent
`/api/test/conversation`	`GET`	Remote only	Test conversation with confirmation + todo cards
`/api/agents/{id}/input`	`POST`	Bearer	Send message to agent (10 MB limit, supports images)
`/api/agents/{id}/approve`	`POST`	Bearer	Approve/reject pending action
`/api/tunnel/ensure`	`POST`	Bearer	Start Dev Tunnel, return URL
`/api/tunnel/status`	`GET`	Bearer	Check tunnel state
`/api/chat/models`	`GET`	Bearer	List available language models
`/api/chat/model`	`POST`	Bearer	Switch active chat model
`/api/chat/modes`	`GET`	Bearer	List chat modes
`/api/chat/mode`	`POST`	Bearer	Switch chat mode
`/api/github/repos`	`GET`	Bearer	List authenticated user's repos
`/api/github/repos/{owner}/{repo}`	`GET`	Bearer	Repo detail
`/api/github/repos/{owner}/{repo}/issues`	`GET`	Bearer	Repo issues
`/api/github/repos/{owner}/{repo}/pulls`	`GET`	Bearer	Repo pull requests
`/api/github/repos/{owner}/{repo}/actions/runs`	`GET`	Bearer	Repo workflow runs

Default: http://localhost:19850. "Remote only" means loopback clients pass through; non-loopback requires Bearer token.

When a Dev Tunnel is active, the same endpoints are accessible via the tunnel URL (e.g., https://your-tunnel.devtunnels.ms/api/state).

Architecture

VS Code Extension (modular, ~15 TypeScript modules)
├── Core Types (src/types.ts)
├── Base Class (src/data-provider.ts)
├── 11 Data Providers (src/providers/, polled every 3s in parallel)
│   ├── Copilot Extension API
│   ├── Copilot Chat Session Files (JSONL with confirmation/structured options)
│   ├── VS Code Chat Sessions API
│   ├── Chat Tools & Participants
│   ├── Custom Workspace Agents
│   ├── Terminal Process Scanner
│   ├── Claude Desktop Todos
│   ├── GitHub Actions (auto-auth via VS Code)
│   ├── Remote Connections (SSH/container)
│   ├── Workspace Activity (fs.watch)
│   └── Peer Instance Provider (multi-window aggregation)
├── DashboardProvider (orchestrates + deduplicates + enriches)
│   ├── Webview Panel (HTML/CSS/JS dashboard)
│   ├── REST API Server (port 19850, 17+ endpoints)
│   ├── SSE Push (Server-Sent Events with sequence numbering)
│   ├── JSONL File Watchers (fs.watch for live conversation streaming)
│   ├── Relay Push (self-hosted relay)
│   └── Dev Tunnel Manager (VS Code Dev Tunnels)
├── Remote Control (src/remote-control-manager.ts, src/p2p-remote-control.ts)
│   ├── WebSocket relay-based control
│   ├── WebRTC P2P direct control
│   └── Image attachment support
├── Alert Engine (src/alert-engine.ts) — email/SMS/webhook with 4-layer rate limiting
├── Client Connection Tracker (src/client-connections.ts)
└── Utilities (src/utils.ts) — QR generation, cost calculation, image security

Dev Tunnel (VS Code Dev Tunnels)
├── Tunnel → *.devtunnels.ms
├── Exposes REST API to internet (HTTPS)
└── QR code for iOS app pairing

Self-Hosted Relay (self-hosted/, v2.0.0)
├── REST API proxy (all endpoints)
├── WebSocket remote control
├── Multi-instance aggregation
├── Conversation cache (500/instance)
└── Bearer token auth (write + read)

iOS Companion App
├── 2-tier failover: Wi-Fi (primary) + Dev Tunnel (fallback)
├── SSE push-based updates with sequence numbering
├── QR code scanning for tunnel pairing
├── Markdown rendering (bold, code, headers, links, lists)
├── Image attachments in conversations
├── Confirmation cards with structured options
├── Pinned todo widget
├── Full-screen search
├── Setup prompt & disconnect overlay
├── WiFi security warning
└── Pull-to-refresh with native SwiftUI animation

Development

cd extension
npm install
npm run watch    # TypeScript watch mode
# Press F5 to launch Extension Development Host

Self-Hosted Relay Development

cd self-hosted
npm install
RELAY_SECRET=test-secret npm run dev   # Watch mode with auto-reload

Background Daemon (Standalone)

The daemon can run independently of VS Code, useful for monitoring CLI agents when VS Code is closed:

# Run directly (has shebang — requires Node.js in PATH)
./cli/agent-dashboard-server

# Or explicitly with Node.js
node cli/agent-dashboard-server

# Custom port (default: 19851)
./cli/agent-dashboard-server -p 19852

# Via the CLI tool's serve command
./cli/agent-dashboard serve

The daemon registers itself in ~/.agent-dashboard/instances.json, so the iOS app and CLI viewer auto-discover it. It serves the same REST API contract as the extension (/api/state, /api/health, /api/agents/:id/conversation, /api/agents/:id/input).

When VS Code launches, the daemon automatically pauses (the extension takes over). When VS Code closes, it automatically resumes.

Requirements

VS Code 1.85 or later
For Claude Code monitoring: Claude CLI installed (~/.claude directory)
For Copilot monitoring: GitHub Copilot extension installed
For mobile monitoring: Free Agent Dashboard iOS app from the App Store
For Dev Tunnel: GitHub account (sign in via VS Code)
For self-hosted relay: Node.js 18+ (uses tsx to run TypeScript directly)
For background daemon: Node.js 18+ (zero external dependencies)
For GitHub Actions monitoring: gh CLI installed (optional)

License

MIT

Agent Dashboard

Ami Schreiber

Agent Dashboard for VS Code

Main Dashboard

Session Chat History

Session Details

Why Agent Dashboard?

Features

Live Agent Monitoring

Multi-Source Data Providers

Token Usage & Cost Tracking

Live Session Reading

Conversation History

Agent Role Classification

Activity Feed

GitHub Actions Integration

Agent Controls

Multi-Window & Cross-Machine Peer Sync

Mobile Monitoring (iOS Companion App)

Dev Tunnel

Relay with Automatic Failover

Multi-Instance Cloud Aggregation

Alerts & Notifications

Diagnostics

Background Daemon

Quick Start

1. Install & Open

2. Select Your Agent Source

3. Optional: Mobile Monitoring

Commands

Core

Mobile API & Tunnels

Remote Control

Background Daemon

GitHub

Settings

General

Peer Sync

Mobile API & Remote Access

Remote Control

Alerts

REST API

Architecture

Development

Self-Hosted Relay Development

Background Daemon (Standalone)

Requirements

License