TaskYou is an autonomy-first task orchestrator for coding agents. You drop a task on a board, an agent picks it up and works in its own isolated git worktree in the background, and the card tracks all the way to a merged PR. One agent per task. A worktree per agent.
+That's a different job from a terminal multiplexer, a process dashboard, or a worktree-diff tool. This page lays the whole landscape on one grid, then links to a detailed page for each contender. We try to be fair: where a tool genuinely beats us at its job, we say so.
++The short version: most of these tools help you watch and drive agents you launch by
hand. TaskYou helps you queue outcomes and walk away. If your mental model is "panes I'm
babysitting," you want a multiplexer. If it's "a backlog that clears itself," you want TaskYou.
| Capability | TaskYou | tmux / Zellij | cmux / Warp | Conductor / Emdash / Superset |
|---|---|---|---|---|
| Unit of work is a task / outcome (not a pane) | ✓︎ | ✕︎ | ✕︎ | ✓︎ |
| Queue + background execution (stack work, walk away) | ✓︎ | ✕︎ | ✕︎ | ◐︎ |
| Kanban board (Backlog / In Progress / Blocked / Done) | ✓︎ | ✕︎ | ✕︎ | ◐︎ |
| Worktree-per-task isolation, automatic | ✓︎ | ✕︎ | ◐︎ | ✓︎ |
| PR-aware completion (task state follows the PR to merge) | ✓︎ | ✕︎ | ✕︎ | ◐︎ |
| Pluggable executors (Claude, Codex, Gemini, Pi, OpenClaw, OpenCode) | ✓︎ | n/a | ✕︎ | ◐︎ |
| Routines — scheduled unattended runs that feed the queue | ✓︎ | ✕︎ | ✕︎ | ✕︎ |
| Live executor panes to watch/drive an agent | ✓︎ | ✓︎ | ✓︎ | ◐︎ |
| Runs over SSH (board from anywhere) | ✓︎ | ✓︎ | ✕︎ | ✕︎ |
| Web UI (same board in a browser) | ✓︎ | ✕︎ | ✕︎ | ◐︎ |
| Desktop app (macOS / Linux) | ✓︎ | ✕︎ | ✓︎ | ✓︎ |
| Email control (create + unblock tasks from your phone) | ✓︎ | ✕︎ | ✕︎ | ✕︎ |
| Fully scriptable CLI / agent API | ✓︎ | ◐︎ | ◐︎ | ◐︎ |
| Open source | ✓︎MIT | ✓︎ | ◐︎ | ◐︎ |
✓︎ first-class · ◐︎ partial / possible-but-not-the-point · ✕︎ no · n/a not applicable (◐︎ and ✕︎ for other tools reflect their stated positioning as of mid-2026; correct us with a PR if a tool has shipped past this.)
One line: cmux and Warp are polished apps for running agents on your machine; TaskYou is the same job as a board that runs anywhere — terminal, browser, desktop, email, and over SSH — and is built to queue work and walk away.
+cmux (a Mac terminal app for agents) and Warp (an agentic development platform / terminal) both bet on a beautiful, local, GUI-forward experience. TaskYou bets on autonomy and reach: file an outcome, let an agent run it in the background in an isolated worktree, and pick up the result from whatever device you have.
+features; cmux is a focused Mac app for driving agents. If you want a beautiful local cockpit, this is the camp.
+SSH server to think about.
+If you primarily work on one Mac and want the most polished local agent experience, these are strong, and TaskYou doesn't try to out-pretty them.
+| TaskYou | cmux / Warp | |
|---|---|---|
| Center of gravity | A task board + queue | A polished terminal/app you drive |
| Queue + background execution | ✓︎stack work, walk away | ✕︎you drive sessions live |
| Worktree-per-task isolation | ✓︎automatic | ◐︎varies |
| PR-aware completion | ✓︎ | ✕︎ |
| Pluggable executors (6) | ✓︎per task | ◐︎tied to the app's agent(s) |
| Routines (scheduled unattended runs) | ✓︎ | ✕︎ |
| Runs on a headless server / over SSH | ✓︎taskd | ✕︎desktop-bound (cmux); ◐︎ (Warp) |
| Same board on web + email + Chrome | ✓︎ | ✕︎ |
| Open source | ✓︎MIT | ◐︎ |
Two differences matter most:
+work: queue a column, walk away, come back to diffs. The board, the worktrees, and the PR-aware lifecycle exist so you don't have to sit in the loop.
+in your terminal, your browser (ty serve), a desktop app, over SSH (taskd, so it can live on a remote box or a cloud VM), via email (create and unblock tasks from your phone with the ty-email extension), and through a Chrome extension for annotate-and-fix loops. You can kick off work from a VM you SSH into and review it from your phone.
Pick cmux / Warp when:
+Pick TaskYou when:
+including your phone, by email.
+They can coexist: TaskYou can run on a server and own the queue and worktrees while you use a slick local terminal (Warp, cmux, or anything else) as the place you drop in to take the wheel on a single task.
+Accuracy note: TaskYou capabilities are documented in the README and the extensions/ty-* READMEs. cmux/Warp entries reflect their general positioning as desktop/terminal agent apps; ◐︎ marks places their scope varies or we haven't individually verified a feature. This is a category comparison, not a feature audit. PRs welcome to correct anything.
One line: Conductor, Emdash, and Superset isolate a worktree per branch and help you review the diff; TaskYou does that and runs the work in the background on a queue, across six executors, on whatever surface you happen to be holding.
+This is the comparison closest to TaskYou's own job. These tools share TaskYou's core insight — give every agent its own isolated git worktree — so the differences are about everything around the worktree: the queue, the lifecycle, the executor choice, and where you can drive it from.
+Conductor, Emdash, and Superset are worktree-orchestration tools for coding agents. Like TaskYou, they:
+If the terminal-multiplexer tools are one camp, this is the "worktree orchestrator" camp — and TaskYou lives here too. So we'll be precise about the differences instead of hand-waving.
+| TaskYou | Conductor / Emdash / Superset | |
|---|---|---|
| Worktree-per-task isolation | ✓︎ | ✓︎(the shared idea) |
| Diff / PR review flow | ✓︎+ PR-aware completion lifecycle | ✓︎ |
| Kanban board as the home surface | ✓︎Backlog / In Progress / Blocked / Done | ◐︎varies; often a list or per-agent view |
| Queue + background execution | ✓︎stack a column, walk away | ◐︎varies by tool |
| Pluggable executors | ✓︎Claude, Codex, Gemini, Pi, OpenClaw, OpenCode — per task | ◐︎usually one or two |
| Routines — scheduled unattended runs feeding the queue | ✓︎ | ✕︎ |
PR-aware completion (task auto-done on merge/close) | ✓︎ | ◐︎ |
| Multi-surface (TUI · web · desktop · email · SSH · Chrome) | ✓︎ | ◐︎usually one app (often desktop or web) |
| Fully scriptable CLI + MCP for agents to drive the queue | ✓︎ | ◐︎ |
| Open source | ✓︎MIT | ◐︎varies |
The pattern: this camp tends to ship one polished surface (a desktop app or a web app), one or two agents, and a worktree-plus-diff flow. TaskYou matches the worktree-plus-diff flow, then adds the things that make it an orchestrator rather than a launcher:
+background — you're not launching agents one at a time.
+Gemini or Pi or OpenClaw or OpenCode for whatever fits — on the same board.
+blocked for human review, then ispromoted to done automatically when the PR merges or closes. The board mirrors your repo.
file tasks into your queue. Your backlog can fill itself.
+and over SSH. Most tools in this camp are a single app.
+Pick Conductor / Emdash / Superset when:
+no extra surfaces.
+Pick TaskYou when:
+Accuracy note: TaskYou capabilities are documented in the README and the extensions/ty-* READMEs. The competitor column is deliberately marked ◐︎ where these tools differ in scope or have shipped features we haven't individually verified — this page describes the category difference (launcher vs orchestrator), not a feature-by-feature audit of each product. Corrections welcome via PR.
One line: tmux and Zellij multiplex terminals; TaskYou multiplexes tasks — and since TaskYou is built on tmux under the hood, you get the panes anyway.
+This is the friendliest comparison on the list, because it isn't really a competition. tmux and Zellij are terminal multiplexers — they keep sessions alive and tile panes. TaskYou is an autonomy-first task orchestrator that uses a multiplexer as plumbing. The question isn't "which one" — it's "what sits on top."
+A Kanban board for coding agents. You drop a task in a column, an agent picks it up in its own isolated git worktree, runs in the background, and the card tracks itself to a merged PR. One agent per task, a worktree per agent.
+Under the hood, each executor runs in a tmux window inside a daemon session:
+task-daemon-{PID} (tmux session)
+├── _placeholder (keeps the session alive)
+├── task-123 (window for task 123)
+│ ├── pane 0: executor (Claude / Codex / … output)
+│ └── pane 1: shell (workdir access)
+├── task-124 (window for task 124)
+└── ...So TaskYou doesn't replace tmux — it programs it. The difference is everything that wraps those panes: a board, a queue, worktree isolation, PR tracking, and a database that remembers what every task is doing.
+What they don't do — by design, because they're general-purpose terminal tools — is understand your work. A pane is a pane. tmux doesn't know that window 3 is an agent, that it's blocked waiting on you, that it's working in an isolated worktree, or that it just opened a PR.
+| TaskYou | tmux / Zellij | |
|---|---|---|
| Persistent sessions | ✓︎(via the daemon) | ✓︎ |
| Tiled panes | ✓︎(executor + shell per task) | ✓︎ |
| Knows a pane is an agent | ✓︎ | ✕︎ |
| Kanban board of work | ✓︎ | ✕︎ |
| Queue + background execution | ✓︎ | ✕︎— you launch every process by hand |
| Worktree-per-task isolation | ✓︎automatic | ✕︎— you git worktree add yourself |
| PR-aware completion | ✓︎ | ✕︎ |
| Pluggable AI executors | ✓︎6 of them | ✕︎— not its job |
| Task database + history | ✓︎SQLite | ✕︎— panes are ephemeral state |
| Routines (scheduled unattended runs) | ✓︎ | ✕︎ |
| Web / desktop / email / SSH surfaces | ✓︎ | terminal only |
The honest way to say it: you could build a poor man's TaskYou out of tmux — a session per task, a git worktree add for each, a shell loop to launch agents, and a wall of sticky notes to track which is which. TaskYou is what you get when someone builds that properly and adds a board, a queue, worktree lifecycle, PR tracking, and a database so nothing gets lost.
Reach for tmux / Zellij when:
+Reach for TaskYou when:
+it together yourself.
+terminal.
+You're already using both. TaskYou runs on tmux. If you live in tmux today, TaskYou is the task layer that sits on top of it — and you can still tmux attach to the daemon session and poke at any task's panes by hand whenever you want to take the wheel.
Accuracy note: the tmux architecture shown above is TaskYou's actual executor model, documented in the README under "How Task Executors Work." Zellij/tmux capabilities are their standard documented features.
+ +{html.escape(spans[int(m.group(1))], quote=False)}", text)
+ # Map status emoji to crisp text glyphs (U+FE0E forces text, not emoji,
+ # presentation) so they match the terminal aesthetic instead of bolting on
+ # OS color emoji. Applied globally so table cells AND the legend line agree.
+ text = text.replace("✅", '✓︎')
+ text = text.replace("◐", '◐︎')
+ text = text.replace("❌", '✕︎')
+ return text
+
+
+def style_cell(cell):
+ return inline(cell.strip())
+
+
+def value_cell(cell):
+ """Format a comparison-column cell as a centered status glyph with the
+ annotation (if any) as a small caption beneath it. Keeps every glyph on a
+ consistent baseline so rows don't read ragged when annotations vary in
+ length. Cells with no leading glyph (prose like 'A task board + queue',
+ 'n/a') render as a plain centered caption."""
+ h = inline(cell.strip())
+ m = re.match(r'^([^<]*)\s*(.*)$', h)
+ if m:
+ mark, rest = m.group(1), m.group(2).strip()
+ return mark + (f'{rest}' if rest else "")
+ if not h:
+ return ""
+ return f'{h}'
+
+
+def convert(md):
+ lines = md.split("\n")
+ out, i, n = [], 0, len(md.split("\n"))
+ while i < n:
+ line = lines[i]
+ if line.startswith("```"):
+ buf = []
+ i += 1
+ while i < n and not lines[i].startswith("```"):
+ buf.append(html.escape(lines[i], quote=False))
+ i += 1
+ i += 1
+ out.append("" + "\n".join(buf) + "" + "".join(f"") + continue + if re.match(r"^\s*[-*]\s+", line): + buf = [] + while i < n and re.match(r"^\s*[-*]\s+", lines[i]): + buf.append(inline(re.sub(r"^\s*[-*]\s+", "", lines[i]))) + i += 1 + out.append("{inline(b)}
" for b in buf if b) + "