# Kanbots

> A kanban board where every card is a coding agent in its own git worktree

- Category: AI Coding / AI SDLC Automation
- Language: TypeScript
- Licence: MIT
- Repository: https://github.com/leodavinci1/kanbots
- Canonical page: https://ai-tldr.dev/tools/kanbots/
- Updated: 2026-05-22

## In short

Kanbots is a local-first kanban application that turns a board into a control surface for coding agents. It sits in the AI SDLC Automation category of the AI Coding tools and is open-source, written in TypeScript and licensed MIT. To get started: run it with npx.

## Overview

Kanbots is a local-first kanban application that turns a board into a control surface for coding agents. Tasks move through an Inbox plus five columns from Backlog to Done, and any card can be handed to a supported agent CLI, which then works on it in the background while you keep triaging the rest of the board.

Each running card gets its own git worktree, so several agents can work on the same repository at once without stepping on each other's branches. The card view streams a live agent thread of every tool call and result, surfaces decision prompts in the UI when the agent needs an answer, and lets you preview the branch or start a dev server straight from the worktree. When the work looks right, a promotion step lands it as a commit or a draft pull request.

State lives in a local SQLite database under a `.kanbots/` directory inside the repository, or you can switch the board to GitHub Issues mode, where moving a card edits labels on the real issue. Kanbots also exposes itself as an MCP server, so tools like Cursor and Claude Desktop can drive the board, and it can import Sentry errors as cards for triage.

## What it does

- Runs 11 agent CLIs — Claude Code, Codex, Gemini, Cursor, GitHub Copilot, Amp, OpenCode, Droid, CCR, Qwen Code and any ACP-compatible binary — reusing each CLI's own authentication
- One git worktree per card, so parallel agents never share a working tree
- Live agent thread showing every tool call and result, with in-UI decision prompts
- Promotion workflow that lands finished agent work as a commit or a draft PR
- Local SQLite storage by default, or GitHub Issues mode where card moves become label edits
- Autopilot modes: `feature-dev` runs multi-persona parallel slots, `qa` runs check commands and dispatches fixes
- Ships an MCP server so other agents and desktop clients can drive the board

## Getting started

Kanbots needs Node 20+, pnpm 10+, git, and at least one supported agent CLI on your PATH. Optionally install and authenticate the `gh` CLI to use GitHub Issues mode.

1. Run it with npx

   The quickest path — no clone required.

```bash
npx kanbots
```

2. Or build the desktop app from source

   Clone the repository, install dependencies with pnpm, then build and open the Electron app. Use `pnpm desktop:dev` instead if you want hot reload.

```bash
git clone https://github.com/leodavinci1/kanbots.git
cd kanbots
pnpm install
pnpm desktop
```

3. Point it at a repository

   Open a workspace on a git repository. Kanbots creates a `.kanbots/` directory at the repo root holding `config.json`, the SQLite database, the agent worktrees, attachments and MCP runtime config — everything stays inside the project.

```text
.kanbots/config.json
```

4. Give a card to an agent

   Create a card, pick one of the installed agent CLIs, and start it. The agent runs in a fresh worktree; watch the live thread, answer any decision prompts, then use the promotion step to turn the result into a commit or a draft PR.

## When to use it

- Run several coding agents in parallel on one repository without branch collisions, and watch each one's tool calls as it works
- Keep a visible backlog for agent work — triage what to hand off next instead of losing tasks in terminal scrollback
- Review and land agent output deliberately, as a commit or draft PR, rather than letting an agent push directly
- Turn incoming Sentry errors into cards an agent picks up for first-pass triage

## Version history

- 2026-05-22: Kanbots was released as an open-source desktop app that runs Claude Code and Codex agents in parallel across a kanban board, giving each card its own git worktree, live updates and per-agent cost tracking.