ADHDev Agent Dashboard Hub

One control plane for every coding agent on every machine — a shared task queue, isolated worktrees, and merges to main only when your own gates pass.

Source repo
vilmire/adhdev
Stars
★ 116
Last updated
today
License
AGPL-3.0
Primary language
TypeScript

At a glance

How it runs
CLISelf-hosted serviceWeb app
Works with
Universal · cross-platformCodex · Claude CodeOpenAI API · Claude API (Unsupported)
Cost
Free tier plus a paid hosted plan
Setup effort
Medium · a few setup steps
You'll need
Node.js 22 LTSgitat least one installed and authenticated coding agent CLI/IDEShell / CLINetwork accessLocal filesystem
Typical use
A developer with a laptop, a desktop and a build box who wants one shared queue where idle machines pull coding tasks on their own.
Not a fit if
  • Users who need a zero-config, fully offline setup in one command
  • Solo developers running one CLI on one machine with no queue or auto-merge needs
  • Windows users on Node.js 24+ who cannot switch to 22.x

What does this agent do, and when should you use it?

ADHDev is a self-hosted control plane for AI coding agents. It does not replace your agents or spawn its own: it attaches to the CLIs already installed on your machine (Claude Code, Codex, Cursor Agent, Antigravity CLI, Grok CLI, Kimi, OpenCode via PTY), to IDEs through the Chrome DevTools Protocol (Cursor, VS Code, Antigravity, Kiro, Windsurf and others), and to IDE extensions through CDP webviews. A local daemon serves a dashboard at localhost:3847 over HTTP/WebSocket, while a separate adhdev-sessiond process owns the PTY runtimes so CLI sessions survive daemon restarts or upgrades. The centerpiece is Repo Mesh: tasks enter a SQLite queue (pending → assigned → completed/failed with depends_on ordering and retries), idle nodes claim work themselves, each task runs in its own bootstrapped git worktree, and the Refinery validates, checks patch equivalence, rebases submodule-aware, and merges to main only if main has not moved. Quota-aware routing reads each CLI subscription's 5-hour and weekly windows to pick which slot takes the next task. The open-source edition is AGPL-3.0; the cloud edition adds internet-wide reach, push notifications and project file transfer.

On startup the daemon detects installed agents, launches and drives CLI sessions over PTYs, connects to IDEs over CDP, and exposes both a chat view and a raw terminal view in the web dashboard. You describe a task to a coordinator, which files it via mesh_enqueue_task into the SQLite queue with a difficulty tag; an idle node claims it and runs a worker agent inside a fresh worktree that was bootstrapped first (dependencies installed, native rebuilds, gitignored build outputs). Completions and failures land in an append-only ledger kept in the mesh's local SQLite store, and operating notes learned at runtime are injected into every future coordinator prompt. The Refinery then runs the repo's own validation gates, patch-equivalence detection, a submodule reachability check and atomic pointer bumps, rebases, and merges only when main is unchanged — anything undecidable is held for a human; it never force-pushes. Quota routing reads each machine's remaining 5-hour and weekly subscription windows, skips plans that are nearly exhausted, spends quota that would otherwise expire unused first, and the Tasks tab forecasts which slot takes the next task per difficulty. The dashboard transports chat, commands, screenshots and remote input over an encrypted WebRTC data channel; self-hosted mode also exposes GET /api/v1/status, POST /api/v1/command, /api/v1/runtime/:sessionId/snapshot and events, /api/v1/mux/:workspace/state and control, plus ws://localhost:3847/ws.

  1. A developer with a laptop, a desktop and a build box who wants one shared queue where idle machines pull coding tasks on their own.
  2. Teams already paying for several CLI subscriptions (Claude Code, Codex, Kimi…) who want unused quota spent before its window resets and cheap models handling routine work.
  3. Anyone running parallel agents in a submodule-heavy monorepo who needs unattended rebase, atomic submodule pointer convergence, and test gates before main moves.
  4. A developer who wants to read agent output, approve or interrupt work, and send the next instruction from a phone instead of babysitting a terminal.
  5. Engineers who want a multi-perspective review — the same RCA or design question sent to 2–3 workers on different providers, with agreements and disagreements laid out.
  6. Teams that need an auditable trail of every dispatch, completion, failure and stall for later investigation.
  7. Developers with an in-house or niche coding CLI they want to surface in the same dashboard via a provider.v1.json manifest.

How do you install or deploy this agent?

Requirements: Node.js 22 LTS, git, and at least one coding agent already installed and authenticated. On Windows, Node.js 24+ is currently blocked for normal startup, so use 22.x or the PowerShell installer.

Recommended path with the adhdev CLI:

npm install -g adhdev
adhdev standalone

Or install the standalone daemon package directly (both install an adhdev command — install one, not both):

npm install -g @adhdev/daemon-standalone
adhdev-standalone

Cloud edition via install scripts or Homebrew:

curl -fsSL https://adhf.dev/install | sh
irm https://adhf.dev/install.ps1 | iex
brew tap vilmire/adhdev && brew install adhdev
adhdev setup

Building from source requires a submodule-aware clone because vendor/seqscribe is a build dependency:

git clone --recurse-submodules https://github.com/vilmire/adhdev.git
cd adhdev
npm install
npm run build
npm run dev

How do you use this agent?

Open http://localhost:3847 after starting the daemon; the dashboard detects which agents are installed on this machine. Useful flags:

adhdev standalone --host 0.0.0.0   # allow other devices on the same LAN
adhdev standalone --port 8080      # custom port
adhdev standalone --token mysecret # token auth for scripts / operator access
adhdev standalone --no-open        # don't auto-open the browser
adhdev standalone --dev            # enable local DevServer endpoints (:19280)

Start a session by picking a provider and a working directory, then toggle between chat and raw terminal. Permission prompts land in the activity inbox instead of blocking an unwatched terminal. To try the mesh on one machine, open /mesh, create a mesh bound to your repo, clone a worktree node, queue a task and watch the ledger go dispatch → completion → Refinery → rebase and merge into main. A second machine on the same network or Tailscale is paired from the mesh screen with its address and a one-time code.

The local API is callable directly:

curl http://localhost:3847/api/v1/status
curl -X POST http://localhost:3847/api/v1/command -H 'Content-Type: application/json' -d '{"type":"..."}'

Custom provider manifests are dropped here:

~/.adhdev/providers/provider.v1.json

What are this agent's strengths and limitations?

Pros
  • Genuine multi-machine parallelism: a coordinator dispatches difficulty-tagged tasks to whichever node has capacity, and each runs in its own git worktree so parallel agents never collide.
  • The Refinery treats submodules as first-class — reachability gate against the submodule's origin/main, patch-equivalence detection when SHAs change, atomic pointer bumps — and the project dogfoods it on its own submodule monorepo.
  • Quota-aware routing reads each CLI subscription's 5-hour and weekly windows, skips nearly exhausted plans and spends soon-to-expire quota first, which directly reduces wasted multi-subscription spend.
  • Approvals are deliberately narrow: auto-approve presses only the one-time option and never 'always'; delegated workers ask the coordinator first and the user is pinged only after a minute, with the command itself in the prompt.
  • The self-hosted edition runs Repo Mesh, Refinery and worktree nodes fully local with no account and no quotas; the cloud layer adds reach and push while the data plane stays on a direct WebRTC channel.
Limitations
  • The open-source edition omits push notifications, the hosted REST API and project file transfer; reaching machines outside your own network requires the cloud edition.
  • Setup is not trivial: Node.js 22 LTS plus at least one installed and authenticated coding agent, and binding to 0.0.0.0 for LAN access requires you to configure token auth or a dashboard password yourself.
  • Windows with Node.js 24+ is explicitly blocked for normal startup and install paths.
  • The provider catalog is broad but unverified end to end — 'built-in' only means the integration exists, so some CLI/IDE combinations may need a locally overridden provider manifest.
  • Core pull requests require signing a CLA, and new providers are expected to go to the separate adhdev-providers repo rather than the core.
  • Headline metrics such as the share of Refinery auto-merge commits come from the upstream private monorepo and cannot be checked in this public mirror's history.

How does this agent compare with similar options?

The README names its alternatives directly. Claude Code Remote Control and Codex Remote are good at driving one vendor's session from a phone but offer no queue shared across vendors and machines and no test-gated merges. Paseo and Happy are open-source remote-control and mobile apps for coding agents; ADHDev focuses on the work after the prompt — idle machines pull tasks, each in its own worktree, and only work that passes your tests lands on main. Conductor, Superset and Vibe Kanban run parallel agents in worktrees but end in a diff or PR you review and merge; ADHDev runs one queue that your Mac, Windows and Linux machines pull from and merges for you when the gates pass.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
ADHDev Agent Dashboard Hub This agent 46 · Major gaps CLIFreemium ★ 116 today TypeScript Codex · Claude Code
AGRO Sandbox Runtime 49 · Major gaps CLIFree + model costs ★ 42 2d ago TypeScript Codex · Claude Code
Agor 45 · Major gaps CLIFree + model costs ★ 1.5k today TypeScript Codex · Claude Code
CC-Connect 60 · Some gaps CLIFree + model costs ★ 16k today Go Codex · Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
46/ 100 5-point scale 2.3 / 5
Trust 13/29
Reliability 6/14
Adaptability 9/18
Convention 8/18
Effectiveness 7/13
Verifiability 3/8
Why each dimension lost points
Trust13 / 29 · 2.2/5

README and configuration.md show intent for least privilege (standalone binds localhost by default, warns on 0.0.0.0 without auth) and user confirmation (auto-approve only presses one-time yes, Refinery never force-pushes and blocks on ambiguity), each scoring 2. Sensitive-data handling is only prose promises (.env exclusion, files stay in workspace) with no code evidence, so 1; dependency security shows only npm ci and lockfile checks in CI, no audit/SCA, so 1; external effects include default auto-merge to main and submodule publishing gated but still high-impact, so 1; rollback only mentions worktree cleanup and blocked_review, no explicit rollback path, so 1; source attribution is AGPL plus author field but publisher is unverified, so 1.

Reliability6 / 14 · 2.1/5

CI defines multi-package build/test/typecheck and tests show targeted assertions for failure results and hidden-panel fallback, so self-consistency 2. Dependency availability has a clear gap: tests depend on an external adhdev-providers submodule that fork PRs may lack, which CI comments admit can fail spec tests, so 1; failure messages are scattered strings without systematic error taxonomy, so 1.

Adaptability9 / 18 · 2.5/5

README clearly defines audience (developers with multiple machines/CLIs) and scenarios, and states boundaries (does not replace agents, connects to installed CLIs), each 2. Trigger precision describes approval detection and auto-approve scope in detail but without code verification, and mesh scheduling/difficulty routing is complex, so 1; environment fit covers only Node 22 and Windows 24+ blocked notes, thin cross-platform detail, so 1.

Convention8 / 18 · 2.2/5

Documentation structure is clear (multilingual README, self-hosted config, SECURITY, CI), so information architecture 2; install notes are detailed with multiple paths and Windows caveats, so 2. Naming stability is weakened by the adhdev vs adhdev-standalone dual-command conflict warning, so 1; examples/FAQ are marketing-style with no troubleshooting FAQ, so 1; known limitations are only scattered (Windows, cloud feature differences), so 1; LICENSE is full AGPL-3.0, so 2; version exists in package.json but no CHANGELOG, so 1; maintenance responsibility is only SECURITY response targets and email with unverified publisher, so 1.

Effectiveness7 / 13 · 2.7/5

Output usability is clear (dashboard, approval inbox, task queue), so 2; marginal value over single-CLI remote control is differentiated by queue/multi-machine/test gates, so 2; cost-benefit is limited by needing multiple authenticated CLIs, Node 22, submodules and complex mesh setup, so 1.

Verifiability3 / 8 · 1.9/5

Many README capability claims (P2P encryption, quota routing, Refinery gates) rest on self-description without traceable code/test anchors, so claim_traceability 1; cross-source corroboration is only partial overlap between configuration.md and SECURITY, so 1; fact/inference separation is weak because README mixes marketing comparisons and unverifiable claims like 'about one in six commits are auto-merges', so 1.

Risks and how to mitigate them
  • Publisher identity is not verified by the FollowAgents registry; verify npm package and repo ownership before installing.
  • Default auto-merge to main and submodule publishing are high-impact external effects; confirm Refinery gates and allowAutoPublishSubmoduleMainCommits before use on production repos.
  • Tests depend on an external adhdev-providers submodule, so spec tests may not reproduce in forks or offline environments.
  • Sensitive-data handling (.env exclusion, files staying in workspace) is only documented, not verifiable statically.
  • Windows + Node 24+ is blocked; use Node 22.x or the PowerShell installer.
Evidence confidence: Low Reviewed Oct 29, 2026 Reviewed revision 760f17bb2ea9
See the full review method →

FAQ

What exactly do I lose by staying self-hosted?
Mainly the reach layer: accounts (GitHub/Google OAuth), machines anywhere over internet-wide P2P WebRTC + TURN, push notifications, the hosted REST API with API keys, and project file transfer between your own machines. The dashboard, all three provider categories, Repo Mesh, the Refinery, worktree nodes, the assistant and direct pairing on the same network or Tailscale are in the open-source edition.
How risky are the permissions it grants on my behalf?
The design is deliberately narrow. Auto-approve answers only the one-time option, never 'always' or a session/project-wide grant. Requests show the provider's real choices with standing grants last and marked. Approval text an agent merely prints or has scrolled past is never treated as a live prompt, and a choice for a request that has since changed is refused. The Refinery never force-pushes and holds anything it cannot decide for a human.
What happens when a task fails or stalls after being claimed?
Tasks move pending → assigned → completed/failed in the SQLite queue with retries and depends_on ordering. A failed or cancelled predecessor holds (or by mesh policy cancels) the downstream chain and notifies the coordinator. Every dispatch, completion, failure, stall and checkpoint is an append-only ledger record, so you can reconstruct what happened.
Do I need API keys for each agent?
No. ADHDev does not manage agents' API keys; each tool handles its own auth, and ADHDev only detects install status and surfaces errors. What it does read is the remaining quota windows of your subscriptions, for routing decisions.
Can I add an agent that isn't in the catalog?
Yes. Providers are data, not code you fork: a versioned provider.v1.json manifest plus scripts describing how to detect the tool, launch it, parse output into chat turns and recognise approval prompts. Drop it in ~/.adhdev/providers/ and the dashboard picks it up; an override wins over the built-in of the same name, so you can fix a broken parser locally without waiting for a release.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents