A beautiful, native macOS liquid glass UI for managing Claude Code sessions.
The IDE for 2026.
Installation · Features · Getting Started · Architecture · License
A native macOS app for running multiple Claude Code agents in parallel. Each task is a card on a Kanban board that automatically links your Claude session, git worktree, tmux terminal, and GitHub PR together — cards flow from backlog to done as Claude works, opens PRs, and gets them merged. Push notifications on your phone when agents need attention, remote execution to offload work to a server, and sleep prevention to keep your Mac awake while agents run.
Kanban Code combines the lessons learned from claude-resume, claude-remote, git-orchard, claude-pushover, and cc-amphetamine into one unified experience.
Grab the latest .app from Releases, unzip, and drag to Applications.
Since the app is not notarized, macOS will block it on first launch. To open it:
- Right-click the app and select Open
- Click Open in the dialog that appears
- If blocked, go to System Settings → Privacy & Security, scroll down, and click Open Anyway
Requires macOS 26 (Tahoe) and Claude Code CLI installed.
git clone https://github.com/langwatch/kanban-code.git
cd kanban-code
make run-appSix columns that cards flow through automatically based on real activity signals:
| Column | What goes here |
|---|---|
| Backlog | GitHub issues, manual tasks, ideas waiting to start |
| In Progress | Claude is actively working (confirmed via hooks) |
| Waiting | Claude stopped, needs plan approval, or hit a permission prompt |
| In Review | PR is open, waiting for CI or code review |
| Done | PR merged, worktree ready to clean up |
| All Sessions | Archive of every past session, searchable |
Cards move between columns automatically. When Claude starts working, the card jumps to In Progress. When it stops and needs input, it moves to Waiting and sends you a push notification. When a PR opens, it shifts to In Review. You can always drag cards manually to override.
Every Claude task runs inside a tmux session. This means you can always take control — attach from your own terminal, send input, inspect output, or just watch Claude work. Kanban Code manages the tmux lifecycle for you: creating sessions on launch, reattaching on resume, killing on archive.
Each card can have multiple terminals associated with it — Claude's main session plus any extra shells you spin up. Start a dev server for one worktree, a test watcher for another, and they all live on the right card. When you have ten Claude agents running across five projects, you can see every terminal for every task at a glance, without losing track of which server belongs to which branch.
Inside the app, each card has a native terminal emulator (powered by SwiftTerm) that connects directly to the tmux session. True color, Unicode, mouse events, scrollback — the full terminal experience without switching windows. If Claude is waiting for input, hit Resume and you're typing to it immediately. Terminal state persists as you navigate between cards. Or copy the tmux attach command to connect from your own terminal instead.
Kanban Code automatically discovers all your Claude Code sessions from ~/.claude/projects/. Past sessions, active sessions, sessions you started from the terminal — they all show up.
BM25 full-text search lets you find any session across your entire history. Search by prompt, conversation content, or project name. Results are ranked by relevance with a recency boost.
Fork any session to branch off a new conversation with the same history — perfect for spinning up parallel tasks that share context, or exploring a different approach without losing your place. Checkpoint lets you roll back to any point in a conversation and continue from there. Both are dramatically faster than Claude Code's built-in equivalents, operating directly on the session files instead of going through the CLI.
Start a task and Kanban Code can create a git worktree automatically, giving Claude its own isolated branch. The app tracks which worktree belongs to which card, discovers orphaned worktrees, and offers cleanup when you're done.
Cards created from GitHub issues get named worktrees (issue-123). Manual tasks get auto-generated names. You can also link existing worktrees to cards.
Offload Claude to a remote machine and run even more agents in parallel without melting your laptop. Kanban Code manages a shell wrapper that transparently intercepts commands and executes them over SSH, with Mutagen handling bidirectional file sync. Local paths are automatically translated to remote paths — Claude doesn't know it's running remotely.
The UI shows Mutagen sync status in real time. If the remote host goes offline, Kanban Code automatically falls back to local execution and notifies you. Configure it globally or per-project.
Once Claude pushes a branch, Kanban Code discovers the PR via gh CLI and tracks it on the card:
- PR status (draft, open, merged, closed)
- CI check runs with individual pass/fail status
- Review decision (approved, changes requested)
- Unresolved review thread count
- Lazy-loaded PR description
Multiple PRs per card are supported. Click to open in browser, or copy the link.
Configure per-project GitHub issue filters (e.g. assignee:@me label:bug) and Kanban Code populates your backlog automatically. Issues become cards with the full issue body as context. Start working on one and Claude gets the issue description as its prompt.
Get notified on your phone — and your Apple Watch — when Claude needs attention, via Pushover. Notifications include a full summary of what Claude did, rendered as Markdown so you can read the last assistant response right from the lock screen. Multi-line responses are rendered as images for readability.
Smart deduplication prevents notification spam — rapid Stop events are collapsed, and duplicate notifications within 62 seconds are suppressed. Each notification includes the session number so you know which agent is calling.
Falls back to macOS native notifications if Pushover isn't configured. Just add your Pushover user key and API token in settings.
When Claude agents are actively working, Kanban Code spawns a lightweight companion process that keeps Amphetamine triggered — preventing your Mac from sleeping mid-task. The companion quits automatically when all agents are idle. No more waking up to find Claude was interrupted by sleep mode.
Configure multiple projects, each with its own GitHub filters, prompt templates, and repository settings. A global view combines everything — or focus on a single project. Exclude side projects from the global view to keep work and personal separate.
- ⌘K — Search sessions
- ⌘N — New task
- Drag and drop between columns
- Context menus on every card
These unlock additional features. Kanban Code works without them — it's all progressive enhancement.
| Tool | What it enables |
|---|---|
tmux |
Embedded terminal, session persistence, launch/resume |
gh |
GitHub PR tracking, issue backlog import |
mutagen |
Remote execution with bidirectional file sync |
| Amphetamine | Prevent Mac sleep while agents are working |
| Pushover | Push notifications to phone and Apple Watch |
Kanban Code scans your ~/.claude/projects/ directory and discovers all existing sessions. They'll appear in the All Sessions column immediately.
Open Settings and add your project path (e.g., ~/Projects/my-app). If it's a git repo with gh configured, Kanban Code will start pulling GitHub issues into your backlog.
Kanban Code uses Claude Code hooks for real-time activity detection. On first launch, it offers to install them automatically. The hooks fire on:
- Stop — Claude finished or needs input
- UserPromptSubmit — User sent a message
- Notification — Claude raised a notification
- SessionStart/End — Session lifecycle
Click a card in the backlog and hit Start. Kanban Code will:
- Optionally create a git worktree
- Launch a tmux session
- Start Claude with your prompt
- Open the embedded terminal so you can watch
Or just start Claude yourself from your terminal — Kanban Code will discover the session and create a card for it.
From here, cards move automatically. Claude working? In Progress. Claude stopped? Waiting (+ notification). PR opened? In Review. PR merged? Done. Clean up the worktree and it's archived.
Settings are stored in ~/.kanban-code/settings.json — human-readable, version-controllable.
Card coordination lives in ~/.kanban-code/links.json — the single source of truth linking sessions, worktrees, tmux sessions, and PRs together. You can inspect and edit it directly if needed.
Kanban Code follows Clean Architecture with an Elm-inspired unidirectional data flow:
User Action → dispatch(Action) → Reducer(State, Action) → (State', [Effect])
↓ ↓
SwiftUI EffectHandler
re-render (async I/O)
All state lives in a single AppState struct. All mutations go through the Reducer. Side effects (disk, network, tmux) are returned as values and executed by the EffectHandler. Views never mutate state directly.
Sources/
├── KanbanCode/ # SwiftUI + AppKit app
│ ├── BoardView.swift # Kanban board with drag-and-drop
│ ├── CardView.swift # Card rendering
│ ├── CardDetailView.swift # Detail drawer with terminal, history, PR tabs
│ ├── SearchOverlay.swift # BM25 search interface
│ └── ...
├── KanbanCodeCore/ # Pure Swift library, no UI
│ ├── Domain/
│ │ ├── Entities/ # Session, Link, Worktree, PullRequest
│ │ └── Ports/ # Protocol interfaces (adapter pattern)
│ ├── UseCases/ # BoardStore, CardReconciler, LaunchSession
│ ├── Adapters/ # Claude Code, Git, Tmux, Notifications
│ └── Infrastructure/ # CoordinationStore, KSUID, ShellCommand
└── Clawd/ # Background helper for hook event handling
The core library uses port/adapter pattern — all external integrations (Claude Code, git, tmux, GitHub, Pushover) are behind protocol interfaces. The same architecture could be adapted for other AI coding tools.
Card as first-class entity. A card can independently have (or not have) a session, worktree, tmux terminal, PR, and issue link. These are all optional typed sub-structs on the Link model. This prevents the "triplication bug" where the same work appears as three different cards.
Reconciler, not poller. Background reconciliation discovers external resources (sessions, worktrees, PRs) and merges them with existing cards using a matching algorithm (session ID → branch name → project path). New cards are only created for truly unmatched resources.
In-memory state is truth. The app uses in-memory state as the source of truth during reconciliation, not disk. Disk reads race with async writes — in-memory state eliminates that class of bugs.
KSUID for card IDs. Time-sortable unique IDs (card_2MtCMwXZOHPSlEMDe7OYW6bRfXX) that sort chronologically without a database.
Kanban Code is open source under the AGPLv3 license. Contributions are welcome.
# Run the full test suite
swift test
# Build and launch
make run-appThe spec files in spec/ document every feature and edge case in detail.
AGPLv3 — Kanban Code is free software. You can use, modify, and distribute it under the terms of the GNU Affero General Public License v3.
Built by LangWatch
{ "projects": [ { "path": "/Users/you/Projects/my-app", "github": { "issueFilters": "assignee:@me state:open" } } ], "globalView": { "excludedPaths": ["/Users/you/Projects/side-project"] }, "pushover": { "userKey": "your-key", "apiToken": "your-token" } }