Crowsnest

A fast, lightweight task manager for AI-agent workstations — built for machines running many Claude Code sessions, Codex, and MCP servers at once. It shows what each agent is doing, what it's costing, and lets you stop runaway processes safely.

Tauri 2 + Rust (sysinfo) backend, React 19 + TypeScript frontend. Idle footprint is ~30–45 MB working set with a ~5 MB binary — not an Electron task manager.

Windows is the primary target today. The UI is cross-platform (Tauri); the process classifier, kill path, security flags, and autostart are Windows-specific — see Platform support.

What it does

• Agents — each Claude Code session as a tile: model, effort, permission mode, live state (working / awaiting / idle), rolled-up CPU/RAM, a context-drift meter (fills toward red as the session nears its context limit), an estimated $ cost, and the MCP servers the session owns as nested rows. Sessions are parsed from their command line (--model, --effort, --permission-mode, fast mode, the embedded --mcp-config, working dir → project, tool count). Configured-but-not- running MCPs show as dashed chips.
• Load — every process ranked by combined CPU + memory impact, with gradient impact bars and a magnitude-colored score, so you can see what's draining the machine.
• Tree — a virtualized, sortable process tree. Agent/MCP processes carry an accent spine; pure-system subtrees auto-collapse on first load while agent chains stay open. Filter box (/).
• Watchdog — off / alert / auto-kill. Detects sustained CPU/RAM overload, agent context drift, and stuck agents (CPU-busy but the transcript has gone stale). Auto-kill terminates processes that stay critical past a kill window, with hard guards: protected system processes and Crowsnest itself are never auto-killed, and agent sessions are excluded unless you opt in. Defaults to alert-only.
• Security flags — masquerade (a system-named binary running from a non-system path), execution from Temp/Downloads, and UNC execution — surfaced as chips + alerts.
• Kill — inline arm-in-row (no modal): End a single process or +tree the whole descendant subtree. Kills verify PID identity (start time) first to avoid terminating a reused PID; access-denied / elevated failures surface honestly.
• Cost model — a deliberately small, append-only two-table model: a usage fact log (%LOCALAPPDATA%\Crowsnest\usage\usage-YYYY-MM.csv) joined against an editable pricing dimension (data/model-pricing.csv + src/data/pricing.ts) so costs can be re-rated over time. An audit log records kills and critical alerts.
• Light & dark themes (remembers your choice, follows the OS on first run), pin-on-top, start-on-boot, and a frameless custom title bar.

Everything is read locally. Crowsnest makes no network calls.

How agent / MCP detection works

Processes are classified by command-line signature. A Claude Code session is claude running --output-format stream-json --model …. MCP servers are recognized by common server names (postgres, sqlite, github, gitlab, filesystem, puppeteer, playwright, chrome-devtools, brave-search, slack, memory, sequential-thinking, fetch, …) or the generic @modelcontextprotocol / *-mcp patterns, and attributed to the session that launched them.

Live activity — state, current tool, context size, and lifetime token totals — is read from the local Claude Code transcript JSONL under ~/.claude/projects/.

Custom MCP labels. Recognize MCP servers Crowsnest doesn't know about (or relabel built-in ones) without touching code: drop a mcp-labels.json in the Crowsnest data dir (%LOCALAPPDATA%\Crowsnest on Windows, ~/Library/Application Support/Crowsnest on macOS, ~/.config/crowsnest on Linux). See mcp-labels.example.json:

[{ "match": "my-server", "kind": "my-server", "label": "My Server MCP" }]

match is a case-insensitive substring of the process command line; the first match wins and labels the process as an MCP server. Loaded at startup (restart to apply).

Cost estimates

Token costs are estimates from a small, editable price table using approximate public list prices, with a separate row for the 1M-context premium tier. Treat all $ figures as estimates and edit data/model-pricing.csv / src/data/pricing.ts to match your actual rates.

Build & run

Prereqs: Rust (stable), Node 18+, and the Tauri prerequisites for your OS.

npm install
npm run tauri dev      # native dev window with live data
npm run tauri build    # optimized release build + installer

The frontend also runs in a plain browser against a realistic mock snapshot — handy for UI work without the native shell:

npm run dev            # then open http://localhost:1420

Verify the classifier against your live machine without the GUI:

cd src-tauri && cargo run --example snapshot

The release profile is size-optimized (lto, codegen-units = 1, opt-level = "s", strip, panic = "abort").

Keyboard

Key	Action
1 / 2 / 3	Switch view (Agents / Tree / Load)
/	Focus filter
p	Pause / resume polling
Esc	Clear filter / close detail drawer

Architecture

• src-tauri/src/monitor.rs — one snapshot per poll: enumerate processes via sysinfo, classify the agent/MCP ecosystem by command-line signature, build the parent→child tree, roll up CPU/RAM to ancestors (cycle- and orphan-guarded), parse session metadata, compute risk flags, and dedupe MCP servers to their subtree root. CPU is normalized to a share of the whole machine (÷ logical cores), like Task Manager.
• src-tauri/src/agentlog.rs — maps each session to its transcript and tail-reads state/activity plus an incremental, append-only accumulation of lifetime token cost.
• src-tauri/src/lib.rs — Tauri commands (snapshot, process_details, kill_process, window controls, usage/event logging) over one persistent System behind a Mutex for accurate cross-poll CPU deltas.
• Frontend — usePoller runs a setTimeout-chain poll (never overlaps, pauses when hidden). Sparkline history lives in PID-keyed ring buffers; the tree is virtualized (@tanstack/react-virtual). All arithmetic happens in Rust; the UI only renders.

Platform support

Built and tested on Windows 11 (the primary, fully-tested platform). macOS and Linux support is implemented — cross-platform process classification (executable-name normalization + macOS Claude Desktop detection), kill (kill / pkill), risk flags, autostart (LaunchAgent plist / XDG .desktop), and a portable data dir — but not yet runtime-tested. Give it a try and please report issues; PRs welcome.

Design

An engineering instrument, not a dashboard: cold grounds, hairlines instead of boxes, tabular monospace numerics that don't jitter, and color reserved for agent identity and heat. Motion is gated to real change. The full token system is in src/styles/tokens.css.

License

MIT © Blake Stone