One dashboard for every agent you run

The problem

I run background agents across more than one machine: Claude Code sessions in a few projects, Codex sessions, scheduled jobs that fire overnight. Each terminal only shows its own work. So I lose track of what is running where, and miss the sessions quietly waiting on my input while I assume they are still churning.

What I run instead

I have one local dashboard that shows every agent session across every machine: what project it is in, whether it is working or waiting on me, and a board of everything in flight. No cloud service, no database. The whole thing rests on one idea: git is the transport.

How does one dashboard see agents on every machine?

Two pieces do the work.

A collector runs on each machine on a schedule (launchd, Task Scheduler, or cron). Every minute it reads the local agent session files (Claude Code under ~/.claude, Codex under ~/.codex), builds a small JSON heartbeat with the machine name, a timestamp, and each session’s project and status, then commits that file to a shared private git repo as state/<machine>.json. Because git does the syncing, it works whether or not any dashboard is open, and it resumes on its own after every sleep and reboot.

A local server reads that repo. A tiny zero-dependency server pulls the state, merges every machine’s heartbeat, and renders a single board on localhost: queued, doing, needs input, done, failed. The needs-input column is the one that matters. It is the list of agents waiting on me.

Two rules keep it safe. The collector is read-only over your agent folders, it never writes back. And the heartbeat carries statuses and timestamps only, never prompt text or transcripts, so nothing sensitive leaves the machine.

Git is the whole backend: no server to host, no database, and it keeps syncing while every dashboard is closed.

Build your own

You do not need my code. Paste this into Claude Code and let it build a version for your machines:

Build me a local agent dashboard in two parts.

1. A collector I run on a schedule (launchd/cron on Mac, Task
   Scheduler on Windows). Each run: read my local agent session state
   (Claude Code under ~/.claude, Codex under ~/.codex) and write a JSON
   heartbeat with hostname, an ISO timestamp, and each session's
   project + status to state/<hostname>.json in a git repo I point you
   at, then git add/commit/push. Read-only over those folders. Statuses
   and timestamps only, never prompt text or transcripts. Always exit 0
   so the scheduler never sees a crash.

2. A zero-dependency local server that pulls that repo, merges every
   state/*.json, and serves a single-page board on 127.0.0.1: columns
   queued, doing, needs input, done, failed. Highlight the sessions
   waiting for my input.

If scheduling is new, putting your AI on a schedule covers the launchd and cron side, and the board pairs well with a task queue your agents own.

Do this now

1. Create a private git repo named something like agent-state and clone it on each machine.
2. Paste the prompt above and build the collector plus the server.
3. Run the collector once by hand, confirm a state/<machine>.json file lands in the repo, then put it on a one-minute schedule.

Once it is running, close every terminal. The board still fills in, and it tells you which agent is waiting.