When working with Claude Code, I sometimes end up with so many plans and tasks that I lost the track of what I was doing... Especially after a computer crash or an unsolicited reboot.
So I built orchestrAI — a Rust dashboard that puts a live Claude Code terminal in any browser with all my plans and tasks tightly organized. But not just that.
That's not a screen recording of a chat UI. It's a real xterm.js terminal connected to a real Claude Code session running on my workstation. I click a task, a Claude agent spawns on a dedicated git branch, I watch it work, I type at it, and when it's done I review the diff and merge — all from the browser.
The problem
Most AI coding tools assume you're at your dev machine. That makes sense — the code is there, the credentials are there, the context is there. But it means:
- You can't hand off oversight. If an agent takes 20 minutes, you can't leave your desk without losing visibility.
- You can't check on agents from another device.
- Scaling beyond one agent at a time gets awkward fast — you're juggling tmux panes or editor windows.
What I actually wanted was something like Linear or Jira, except:
- Assignees are AI agents
- Status updates come from the code and from git, not from someone typing them
- "Complete a task" means: spawn an agent on a branch, watch it, review the diff, merge
What it does
Interactive agent sessions from any browser. Each task has a Start button. Click it and a Claude Code agent spawns on a dedicated orchestrai/<plan>/<task> git branch. You get a full xterm.js terminal — type at it, watch tool calls in real time, scroll back through the whole conversation.
Persistent across server restarts. Each agent runs inside a detached supervisor daemon that owns the PTY. Kill the dashboard server, restart it, the agent is still working and the terminal reattaches. No tmux required (more on that below).
Git-isolated changes with review before merge. Nothing lands on your working branch until you click Merge. The task card shows a diff tab, the branch name, and a merge banner once the agent reports done.
Plans as YAML, not parsed markdown. Each plan lives in ~/.claude/plans/*.yaml with phases, tasks, dependencies, file paths, acceptance criteria. Inline-editable from the UI. When you click "New Plan" and describe what you want, an agent turns your description into structured YAML.
Cost tracking. Per-agent USD reported by the CLI, aggregated per task and per plan. Budget limits per task.
"Is this actually done?" agents. Every task has a Check button that spawns a read-only agent to verify the code meets the acceptance criteria. No heuristics, no "the file exists so it must be done" — a real AI reads the diff and replies with a verdict.
A bit of architecture
It ships as a single ~15 MB Rust binary. No Node, no Docker, no daemon to install separately. The frontend (React + Vite + xterm.js) is embedded via rust-embed.
The interesting part was replacing tmux. My first version used tmux for session persistence — it works on Linux and macOS, but it's not available on Windows, and requiring users to install it separately was friction.
So I built a mini-supervisor: ~300 lines of Rust that forks into a detached daemon (fork + setsid on Unix, DETACHED_PROCESS on Windows) and owns one PTY per agent via the portable-pty crate. The daemon exposes the session over a Unix domain socket on Linux/macOS or a named pipe on Windows, using the interprocess crate. The dashboard server talks to the daemon over that socket. PTY output is mirrored to a log file so reconnecting clients get the full transcript.
Same persistence story as tmux, cross-platform, no external binary required.
Try it
Requires Rust 1.85+, Node.js 20+, pnpm, and Claude Code authenticated on the host machine. Git for branch isolation — orchestrAI auto-inits repos that don't have one. Or just download and run from the latest releases, available for Mac, Linux and Windows.
# build
pnpm --filter @orchestrai/web build
cd server-rs && cargo build --release
# run
./target/release/orchestrai-server
# open http://<host>:3100 in any browser on your network
Repo and full docs: github.com/cpoder/orchestrAI
What's next
Three things I'm working on:
Multi-AI via a driver abstraction. An AgentDriver trait lets me ship drivers for Aider, Codex CLI, and Gemini CLI alongside Claude Code. Binary name, prompt format, auth detection, and cost parsing are all per-driver. So you can run an Aider agent for one task and a Claude agent for another, from the same dashboard.
MCP server. Instead of agents running curl -X PUT .../status to report back to the dashboard, they'll use proper Model Context Protocol tools like update_task_status and get_task_context. The dashboard exposes itself as an MCP server, and spawned agents get it wired in automatically.
Remote runners for SaaS. The hosted version can't run agents directly — that requires the customer's code and credentials. So there's a lightweight agent-runner binary that runs on the customer's machine, connects to the SaaS over an authenticated WebSocket, and executes agents there. Outbox + ACK pattern for reliability across reconnects, no broker needed.
If you've tried running Claude Code at scale — or just want to watch an agent work from your phone while you're getting coffee — I'd love feedback. Issues and PRs welcome.
