juggle

What you're seeing: orchestrator (top-left) dispatching parallel coders by writing task files, nvim (top-right) holding open context, and the Cockpit v2 (full-width bottom) tracking Topics, Action Items, and live Agents. Threads [LJ] and [LK] here are critiquing the same TF provider examples in parallel, one via Claude (juggle), one via Codex.

---

Claude Code runs one conversation at a time. A research detour, a parallel build, an unrelated question: each one competes for the same context window, and switching means losing your place.

Juggle turns a single Claude Code session into a multi-track workspace. Each topic lives in its own persistent thread (SQLite-backed, survives restarts and compactions), background agents do the heavy lifting in tmux panes while you stay focused, and the Cockpit dashboard shows every topic, action item, and live agent at a glance. When an agent finishes, a notification surfaces at the next natural pause, and your main thread was never interrupted.

Prerequisites

Requirement	Version	Notes
tmux	3.0+	Background agents run in tmux panes
Python	3.12+	CLI, hooks, cockpit
uv	any	Required to launch the cockpit
Claude Code CLI	current	Orchestrator and agent runtime
OS	macOS / Linux	TTS (talkback) is macOS-only

Quickstart

# 1. Install
/plugin marketplace add mikechen/juggle
/plugin install juggle@juggle

# 2. Activate in any Claude Code session
/juggle:start

# 3. Open the live dashboard in a second terminal
uv run ~/.claude/plugins/juggle/src/juggle_cli.py cockpit

# 4. Dispatch your first background agent
/juggle:delegate

After /juggle:start, talk normally. Juggle detects topic shifts and opens new threads automatically. Use /juggle:delegate to send explicit work to a background agent.

How it works

• Topics: each line of work gets a label (A–ZZ), its own SQLite-backed message history, and an independent context window. Switch anytime with /juggle:resume-topic.
• Agents: background workers (researcher / planner / coder) run in tmux panes, up to 20 concurrent. An auto-approver handles permission prompts so agents don't stall while you're focused elsewhere.
• Cockpit: a live dashboard (Topics | Action Items | Agents) updated every second. Textual-based with mouse drag-to-resize between panels (tmux mouse mode required).
• Action Items: persistent follow-ups created by agents or manually. Survive sessions until dismissed from the cockpit.
• Hindsight memory: opt-in long-term memory across sessions. Enable via hindsight.enabled in ~/.juggle/config.json. See docs/ARCHITECTURE.md.
• Self-healing watchdog: a background daemon keeps agents and the cockpit alive. It reaps orphaned daemons under a global cap, debounces respawns, and verifies each agent actually started before use (a fresh worktree's trust prompt can't leak an idle agent). juggle stop-watchdog --freeze holds it down; juggle start clears the freeze and brings it back up.

Project Autopilot

Hand Juggle a project objective and it delivers the whole thing end-to-end. The objective is decomposed into a task graph persisted in the DB (one node per unit of work, edges for dependencies), and the watchdog tick drives every node to a verified state without you dispatching anything by hand. There is no separate "arm" step: once autopilot is on, the tick auto-dispatches the ready nodes of every active project.

/juggle:toggle-autopilot <project>   # decompose a project into a task graph, then let the tick run it
/juggle:toggle-autopilot             # no arg → toggle global autonomous mode on/off
juggle autopilot status              # global flag + per-project graph progress (--json for machine-readable)

The flow for a project: