§01 — comind / dock terminal runtime for agents MIT · Rust · v0.8

comind-dock · cdock

Many agents.
One terminal.

A terminal-native runtime and multiplexer for AI coding agents. Each agent lives in its own persistent pane; the runtime detects who is working, blocked, or done, and surfaces the ones that need you. One orchestrator chat can run the whole team. Detach and reattach at will — agents keep running.

↗ comind-pro/comind-dock / GitHub ↓ Roadmap

$ curl -fsSL https://raw.githubusercontent.com/comind-pro/comind-dock/master/install.sh | sh

≡ menu

spaces

○ comind-dock

master · 2·2

+ new space

orchestrators

✦ orch-1

auto · 2 workers

agents

○ ✳ refactor auth

working · claude

○ ✳ migrate users

blocked · claude

✳ refactor auth × ✳ migrate users × zsh × + attached · session main

─ ✳ refactor auth ─working · claude

> refactor auth middleware

⏺ Reading src/middleware/auth.ts…

⏺ Running tests — 47 passed

✳ Editing token expiry check…

─ ✳ migrate users ─ blocked · needs you

> migrate users table

⏺ Generated migration 0042_users.sql

? Apply migration to dev database — proceed? [y/N]

▌

prefix C-b ? help 1 agent waiting on input

◆ Fig. 1 — cdock session: one space, an orchestrator, two workers — the blocked one surfaced to the top.

§02 — Core ideas six commitments

idea / A

Server-owned sessions

A background server owns every terminal and process. Clients are thin and disposable: close your terminal, reattach later, nothing dies — and each agent resumes its own conversation after a restart.

idea / B

Agents are first-class

Each agent pane is classified working / blocked / done / idle — from the agent’s own hooks, with screen detection as fallback — and rolled up to tabs and spaces. A sound and a clickable toast when one needs you.

idea / C

One chat runs the team

Talk to one orchestrator agent; it delegates to worker panes, gets woken when they report or get stuck, collects structured results and reports back. Any agent CLI can lead, any mix can work.

idea / D

Automation-friendly by design

Every menu action is also a CLI command and a JSON socket API. Agents inside panes spawn siblings, run tasks, read screens, wait on status — and ship with a skill that tells them how.

idea / E

Upgrades never kill work

Live handoff swaps the running binary in place: not one pane dies. Stable / preview channels, checksum-verified, one click from the UI.

idea / F

Mouse-first TUI

Click, drag, right-click menus, scroll — everything the keyboard can do, the mouse can too. Prefix-key model with a fully configurable keymap.

§03 — Roadmap all six phases shipped · v0.8

01 Core multiplexer done when: daily-drivable as a mouse-first terminal multiplexer shipped

02 Server/client split & persistence done when: close the terminal, reattach, everything is still there shipped

03 Agent awareness done when: the sidebar reliably tells you which agent needs you shipped

04 Automation surface done when: an agent can spawn a sibling, run tests in it, and wait — no human in the loop shipped

05 Ecosystem done when: third parties can extend the runtime without forking it shipped

06 Distribution & reach done when: curl | sh on a fresh machine gives the full experience shipped

07 Orchestration done when: one chat coordinates a team of agents and reports back beyond plan

◆ Every phase shipped usable on its own; none required rewriting an earlier one. Orchestration grew past the plan from field reports by agents running real teams. Full plan in docs/ROADMAP.md.

§04 — Orchestrator one chat · many agents

Talk to one agent.
It runs the rest.

Start an orchestrator from the sidebar menu and click chats into its team. It splits the work, hands it out, ends its turn — and is woken when a worker reports, blocks, stalls or hits a usage limit. Three modes: report (one final summary), auto (self-driving until the goal is met, no side quests), notify (asks you each step).

claude, codex, cline or agy can lead; any mix can work. Start typing in a worker and the orchestrator backs off until you’re done — just looking never blocks it.

delegate pane run 3,5 --file task.md same assignment to several workers, multiline-safe
report task done "what I did" worker hands back a structured result — no screen-scraping
wake team update → orchestrator chat woken on result, block, stall, usage limit — never by idle
talk msg 3,5 "need your API diff" team-scoped messages that wake the recipient
serialize lock acquire main --wait 600 one merge at a time; auto-released on exit
remember STATE.md + notes/ the folder is the orchestrator: memory survives restarts

§05 — Where it’s heading planned · not promised dates

Direction: the dock becomes the place agents work together — across machines, with less of you in the loop and nothing lost when you look away.

Remote attach planned

cdock --remote <host>, per-workspace remote bridges, host badges, reconnect

Quieter orchestration planned

a message channel that never touches the input line; permission-mode inheritance for spawned workers; a leaner role prompt

Homebrew tap planned

brew install comind-pro/tap/cdock — the formula is ready, the tap repo is next

Profile & skill editor planned

author agent roles and skills from the UI, not only from files

CLI completeness planned

cdock status, shell completions, send-keys, layout export/apply, formal JSON Schema for the API

Plugin marketplace planned

an index to discover and install plugins in one step

◆ Not built, on purpose: Windows (no machine to validate on), inline images, IME composition.

§06 — Get it end of sheet

Install it,
run it today.

One static binary into ~/.local/bin, checksum-verified. macOS and Linux, x86_64 and aarch64. Updates from the UI, in place, without killing a pane. Rust, MIT.

$ curl -fsSL https://raw.githubusercontent.com/comind-pro/comind-dock/master/install.sh | sh

# or with Nix

$ nix run github:comind-pro/comind-dock

# let claude report its own status, then go

$ cdock integration install claude

$ cdock

documentation

↗ github.com/comind-pro/comind-dock repo →

Many agents. One terminal.