kobe — the agent multiplexer in your shell

Multiplex your agents like you multiplex your terminals.
kobe is an open-source agent multiplexer: it runs Claude Code, Codex, and Copilot in parallel,
each session on its own git worktree and branch — attach, detach, reattach; they keep working after you disconnect.

Documentation · Quick start · Concepts · CLI · Agent API · Website

Terminal multiplexers let one terminal hold many shells that survive you. kobe does the same for AI coding agents: one TUI holds many engine sessions, each isolated on its own git worktree and branch, all alive after you close the laptop lid on your SSH connection. Fan a prompt across five attempts, walk away, come back, merge the winner, archive the rest. It runs where your code already lives — laptop, devbox, VPS — with no desktop app and no browser required.

• Safe parallelism — every task is git worktree + engine session + branch. Agents never trample each other or your checkout.
• Sessions survive you — quit the TUI, drop SSH, restart the daemon; reattach and the screen comes back. A separate PTY host owns the sessions, so nothing you close kills them.
• Real engines, real environment — kobe embeds the actual interactive CLIs next to your dependencies, services, and credentials. No API wrappers, no re-rendered streams.
• Any engine — claude, codex, copilot, or any command you add via kobe config, picked per task.
• Terminal first — notifications and clipboard ride SSH back to your local terminal.
• Agents orchestrating agents — kobe api lets a script, or another AI agent, fan out tasks, supervise them, and collect the results headlessly.

▶ watch the full-quality mp4

Requires Bun ≥ 1.3.11, git, and at least one engine CLI on PATH.

bun install -g @sma1lboy/kobe

# or try it without installing
bunx @sma1lboy/kobe

ssh devbox        # optional
cd your-repo
kobe

Press n, pick a repo, base branch, and engine, and prompt the embedded session. The worktree lands in ~/.kobe/worktrees/<repo-key>/<task-slug>/. Press F1 anytime for the live keybinding reference; ctrl+q focuses the sidebar, and from there quits — sessions keep running in the background.

Full documentation: docs.kobe.sma1lboy.me — quick start, concepts, CLI, agent API, configuration, keybindings, themes, engines, plugins, troubleshooting.

If kobe saves you an afternoon, star the repo — it is the single strongest signal that tells other developers this is worth their time.

Running many agents well is not prompt engineering — it's graph engineering. Nodes are isolated attempts, edges are dependencies, and the gates are your judgment. kobe gives you a primitive for each step:

Fan out — one prompt, N isolated attempts, one command:

kobe api fan-out --repo "$PWD" \
  --agents claude:2,codex:2,copilot:1 \
  --prompt "Try independent approaches to simplify the auth flow."

Completion — a worker messages its explicit outcome back to the spawning agent's chat tab (the exact command is baked into its first prompt). Silence is a checkpoint, never a verdict:

kobe api send --task-id <spawner> --prompt "succeeded: auth flow simplified (branch kobe/auth-flow)"

Observe — read the engine's own structured session, never scrape a TUI screen:

kobe api read-output --task-id <id>    # paged history, honest terminal fallback

Fan in — compare attempts, annotate diffs line-by-line and send the notes back to the agent as a prompt, then land the winner:

kobe api collect --task-ids a,b,c      # read-only comparison snapshot
kobe api land --task-id a              # merge the winning branch

Install the companion skill so Claude Code can drive this loop itself — an agent orchestrating agents while you keep the gates:

kobe skill install

Every verb, flag, and exit code: Agent API reference.

Task = git worktree + hosted engine session + branch

1. The daemon owns tasks, worktrees, and state — the TUI, the web dashboard, and kobe api are all clients of the same one.
2. The PTY host is a separate long-lived process that owns the engine sessions. It outlives the TUI and the daemon, which is why disconnects and restarts never kill your work.
3. The TUI just attaches: sidebar for tasks, workspace tabs for engines and shells (with splits and quick-fork), a files pane for diffs, review notes, and PR actions.

The same tasks are available from a browser — kobe web serves a local dashboard on the daemon the TUI uses, so both surfaces stay in sync:

kobe web            # http://localhost:5174

Tools like Conductor and orca wrap parallel agents in an Electron desktop app. kobe makes the opposite bet: the terminal is the product.

If your workflow is already SSH + terminal, kobe fits it instead of replacing it. If you want a desktop app, those tools are good — different bet.

• Competing implementations: fan the same refactor to Claude and Codex, keep whichever diff reads better.
• Long-running work from a laptop: kick off tasks on a devbox over SSH, close everything, reattach after dinner.
• Agent-driven delivery: your local Claude Code session uses kobe api to spawn, supervise, and merge remote attempts — you only review the final diff.
• Review with leverage: annotate an attempt's diff line-by-line in the TUI, send all notes back as one prompt, get a corrected attempt.

If you write about developer tools, this README plus the landing page (which links right back here) should give you everything you need — the full manual is at docs.kobe.sma1lboy.me, and architecture details live in docs/ARCHITECTURE.md.

kobe doctor            # read-only diagnosis: daemon, PTY host, engines, git
kobe doctor --report   # write a bundle you can attach to a bug report
kobe reset             # stop the runtimes; never touches your worktrees
kobe config            # open kobe's config file in your editor

More in docs/TROUBLESHOOTING.md.

bun install
bun run dev:sandbox    # run against a throwaway home, not your real ~/.kobe
bun run test

Start with CONTRIBUTING.md and docs/ARCHITECTURE.md; shipped behavior lives in the changelog.

MIT © Jackson Chen