Agent Dashboard for VS Code

Monitor, chat with, approve tool prompts, inspect mockups, and deploy iOS apps from your AI coding agents from anywhere -- including from your phone. Send prompts to GitHub Copilot (VS Code Chat, Agent/CLI, Desktop App, and Cloud Agent Tasks), Claude Code, OpenAI Codex, and Aider, view their responses and interactive mockups in real time, answer tool confirmations and multiple-choice questions remotely, 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 and images to GitHub Copilot (VS Code, Agent/CLI, Desktop GitHub Copilot.app, and Cloud PR Agent Tasks) and Claude Code (including on-demand --resume of closed sessions), and see responses streamed back in real time via the companion iOS app
• Approve tool calls & answer questions remotely — approve or deny pending tool executions (allow-once or allow-session) and answer structured multiple-choice / free-text ask_user prompts directly from your phone
• Inspect Session Assets & Mockups on your phone — tap any .png, .jpg, .webp, .svg, or .html mockup/screenshot link in chat to open it in a native Pinch/Zoom (Fit Screen, Fit Width, 100%) or interactive WKWebView preview over Wi-Fi, Tailscale VPN, or Cellular
• Built-in iOS App Installer (Direct & Cellular OTA .ipa) — build, sign, and install any Xcode project onto your iPhone over Wi-Fi/VPN or Cellular OTA .ipa (via Tailscale Serve HTTPS or Dev Tunnel), complete with side-by-side ON THIS PHONE vs. READY ON MAC version cards
• Remote control from anywhere — interact with agents over local Wi-Fi, Tailscale VPN, Dev Tunnel (with private GitHub Gist auto-discovery & remote tunnel start/stop), or a self-hosted relay
• See all running agents at a glance with live status updates, token usage, and estimated costs
• 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.

Sessions that cannot accept chat messages are labelled Non-interactive and hidden by default. Enable Show non-interactive sessions in the dashboard filters to include them and inspect their saved history. The extension and iOS app each remember this preference locally. A finished session is not necessarily non-interactive: sessions that support follow-up messages remain eligible.

Supported agents:

• GitHub Copilot -- VS Code Chat sessions, Agent/CLI sessions (~/.copilot/session-state via AHP), standalone GitHub Copilot.app desktop sessions, and GitHub Cloud Agent Tasks (gh agent-task PR sessions)
• Claude Code -- CLI and desktop sessions with full 30-day JSONL transcript parsing, on-demand --resume messaging, and optional HTTP hook / OTel real-time approvals
• OpenAI Codex -- Session monitoring via ~/.codex/sessions/
• Aider -- Chat history and token/cost monitoring
• Custom agents -- Define your own in .github/agents/

Multi-Source Data Providers

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

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:

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:

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:

1. Same GitHub/Microsoft account — Both VS Code instances must be signed into the same account
2. 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.
3. 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)
4. 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):

1. Local file registry (~/.agent-dashboard/instances.json) — same machine, auto
2. Manual local ports (agentDashboard.peerPorts) — same machine, manual
3. Manual remote peers (agentDashboard.remotePeers) — cross-machine, manual
4. 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:

• Interactive Chat across Copilot, Claude Code, Codex & Aider — Send prompts and attach screenshots to VS Code Copilot, Agent/CLI sessions, standalone GitHub Copilot.app desktop sessions, GitHub Cloud Agent Tasks (@copilot PR comments), and Claude Code (automatically resumes finished/closed sessions in their working directory via claude --resume).
• Conversational "New Session" Launcher — Start a new VS Code or CLI agent session directly from your phone with personalized "For you" starter prompts drawn from your recent sessions, "Ask" templates, and inline image attachments.
• Remote Tool Approvals & Multiple-Choice Questions — Approve or reject pending tool executions (allow-once or allow-session), answer multi-question ask_user / AskUserQuestion option cards, or enable Auto-Approve Safe Tools for hands-free file reads/edits while keeping terminal commands gated.
• Session Assets & Interactive Mockups Viewer — Tap the Assets button on any session or tap any .png, .jpg, .webp, .svg, or .html filename/link directly inside a chat bubble to open a native UIScrollView Pinch/Zoom canvas (Fit Screen, Fit Width, 100%, − / +) or interactive WKWebView preview across session folders, ~/<project>-handoff, and git worktrees over Wi-Fi, Tailscale VPN, or Cellular.
• Built-in iOS App Installer (Direct & Cellular OTA .ipa) — Build, sign, and deploy any Xcode project from your Mac onto your iPhone even when VS Code is closed (via the background daemon):
  • Direct (Wi-Fi / Tailscale VPN) & OTA .ipa (Cellular) modes via Tailscale Serve HTTPS or Dev Tunnel
  • Universal side-by-side ON THIS PHONE vs. READY ON MAC version & build comparison cards for every selected project
  • Clean two-step Build & Package .ipa → Install .ipa (OTA) flow with a live 30-minute expiration countdown (Expires in Xm → Refresh Expired OTA Link)
  • One-tap Enable Tailscale HTTPS on Mac button and Kill Xcode Build on Mac button when a host build is busy
  • Deploy History with full build logs for your last 10 deployments
• Host Workspace Files & Git Browser — Browse your Mac's live directory tree with file-type icons, inspect uncommitted git changes on the Checked Out tab, and read source files from your phone.
• Open Folder in VS Code on Host — Remotely open any repo or .code-workspace on your Mac in VS Code, with color-coded badges showing which folders are already open in VS Code, Daemon, or CLI.
• GitHub Repositories, Commits & Workflow Dependency Graphs — Browse repos, issues, PRs, and commit history; inspect GitHub Actions runs with an interactive job dependency graph (portrait & landscape) and a pinned "What Failed" card that extracts the exact error lines and files from failed runs.
• Token Cost Analytics & Usage Timeline — Model-segmented bar chart timeline, daily breakdown tables, and filters by date range (Today, 7d, 30d, All, or custom) and project across By Model, By Project, By Machine, and Top Agents.
• Project Grouping, Source Filtering & Date Sorting — Group agent sessions by project (keeping orchestrators and sub-agents together), filter by All / VS Code (Extension vs CLI) / Daemon, and sort by Last Activity or Started date (Newest ↓ / Oldest ↑).
• 4-Tier Automatic Failover + Tailscale VPN & Gist Discovery — Seamlessly routes across Local Wi-Fi, Tailscale VPN (100.x / MagicDNS *.ts.net), Dev Tunnel (with private GitHub Gist auto-discovery and remote tunnel start/stop), Self-Hosted Relay, and Peer instances.
• Native Camera QR Deep-Linking (agentdashboard://) — Scan Dev Tunnel or Daemon QR codes directly from the native iPhone Camera app (or in-app scanner) to open Agent Dashboard and pair immediately.
• Real-Time SSE Streaming, Pinned Todo Widget & Full-Screen Search — Push-based conversation streaming with sequence numbering, collapsible task progress widget, and full-screen message/workspace search.

Dev Tunnel

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

1. Free with GitHub — sign in to GitHub in VS Code
2. 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.
3. Creates a tunnel — exposes your local API via a *.devtunnels.ms HTTPS URL
4. Shows a QR code — scan from the iOS app to connect instantly
5. Persists across restarts — once enabled, the tunnel auto-starts every time VS Code opens
6. 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):

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

Self-Hosted Relay (alternative):

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

Commands

Core

Mobile API & Tunnels

Remote Control

Background Daemon

GitHub

Settings

General

Peer Sync

Mobile API & Remote Access

Remote Control

Alerts

REST API

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

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)
├── 13 Data Providers (src/providers/, polled every 3s in parallel)
│   ├── Copilot Extension API
│   ├── Copilot Chat Session Files (JSONL with confirmation/structured options)
│   ├── Copilot Agent / CLI Sessions (~/.copilot/session-state & GitHub Copilot.app)
│   ├── VS Code Chat Sessions API
│   ├── GitHub Cloud Agent Tasks (gh agent-task PR sessions)
│   ├── 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
├── 4-tier failover: Wi-Fi / Tailscale VPN → Dev Tunnel → Self-Hosted Relay → Peer Instance
├── Interactive chat (VS Code Copilot, Copilot CLI/Desktop App, Cloud PR Tasks, Claude Code --resume)
├── Conversational New Session launcher ("For you" & "Ask" starters + image attachments)
├── Remote tool approvals (allow-once / allow-session / Auto-Approve Safe Tools) & ask_user cards
├── Session Assets & Mockups viewer (native Pinch/Zoom Fit Screen/Width + interactive HTML/SVG)
├── Built-in iOS App Installer (Direct Wi-Fi/VPN + Cellular OTA .ipa, ON THIS PHONE vs READY ON MAC)
├── Host Workspace Files & Git Checked-Out browser + Open Folder in VS Code on Host
├── GitHub Commits, Actions workflow dependency graph & "What Failed" error extractor
├── Token Cost timeline chart & date/project breakdowns (By Model, Project, Machine, Top Agents)
├── Project grouping, Source filter (VS Code / Daemon / Extension / CLI) & Sort By Date
├── Native iPhone Camera QR deep-linking (agentdashboard://connect/...) & Gist tunnel control
├── SSE push-based updates with sequence numbering
└── Pinned todo widget & full-screen conversation search

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