KanBots: Orchestrating Parallel AI Agents via Kanban
The traditional Kanban board is designed to visualize workflow and limit work-in-progress to ensure quality. However, a new breed of tools is flipping this metaphor on its head. Instead of using a board to manage human capacity, KanBots uses the Kanban interface as a command-and-control center for fleets of AI agents.
By treating every card on a board as a potential execution thread, KanBots allows developers to dispatch multiple agents—powered by Claude Code or Codex—to work on different features, bugs, or refactors simultaneously. This approach moves the AI interaction model away from a single chat window and toward a system of record for autonomous software engineering.
The Architecture of Parallel Agency
At the core of KanBots is the integration of AI agents with git worktrees. Rather than having a single agent struggle with a monolithic context or overwrite files in a way that makes manual intervention difficult, KanBots assigns each agent its own dedicated worktree on a specific branch (e.g., kanbots/issue-N).
This architectural choice solves several critical problems:
- Isolation: Agents cannot accidentally corrupt the main development branch while experimenting.
- Parallelism: Multiple agents can work on different parts of the codebase without merge conflicts occurring until the final PR stage.
- Observability: The board updates in real-time, showing the progress, decisions, and costs associated with each specific task.
Key Features for Agent Orchestration
KanBots is designed not as a wrapper for a CLI, but as a full-lifecycle management tool for agentic workflows.
Autopilot and Persona-Driven Development
One of the most ambitious features is "Autopilot," which allows users to define a roster of personas (e.g., Product Manager, Engineer, Reviewer, Tester). The orchestrator round-robins through these personas, splitting parent issues into smaller subtasks and evolving the backlog dynamically. As agents discover new requirements or bugs during implementation, they can spawn new cards on the board for future cycles to address.
Human-in-the-Loop Decisioning
To prevent the "silent mutation" problem—where an agent makes a series of incorrect assumptions and ruins a codebase overnight—KanBots implements a pause-and-prompt system. Agents can pause execution to ask for a decision, providing numbered options or accepting slash commands like /spec or /review. This ensures that the human remains the architect while the agents handle the implementation.
Local-First and Privacy-Centric
For many developers, sending entire repositories to a cloud-based orchestrator is a non-starter. KanBots adopts a local-first approach: everything—including the SQLite database, configurations, and worktrees—lives in a .kanbots/ folder within the local repository. No telemetry, no cloud accounts for local use, and no HTTP servers are required.
Ecosystem Integration
KanBots leverages the Model Context Protocol (MCP), exposing the board itself as an MCP server. This means other MCP-aware tools, like Cursor or Claude Desktop, can interact with the KanBots board, effectively making the project management tool a first-class tool for other agents.
Community Perspectives and Critical Counterpoints
The reception of KanBots on Hacker News highlights a fundamental tension in the current state of AI engineering: the balance between autonomy and supervision.
The Review Burden
Several developers expressed skepticism about the feasibility of "overnight" agent activity. As one user noted:
"I feel 30 minutes of planning and 30 minutes of implementation in my solo side project's repo is too big to review."
This suggests that while parallel agents can increase output, they may simultaneously increase the review burden on the human developer, potentially creating a bottleneck at the PR stage.
The "Kanban" Philosophy
Some purists argued that the tool's name is a misnomer. Traditional Kanban is about limiting work-in-progress (WIP) to ensure flow and quality. KanBots, by contrast, encourages "jamming as much work as you can" into parallel agents. This shift from managing capacity to maximizing throughput represents a significant departure from Lean manufacturing principles.
Integration with IDEs
There is a strong desire for deeper IDE integration. Some users argued that a chat interface—even one organized on a board—is insufficient. They envision a world where "1 task = 1 worktree = 1 full IDE instance," allowing the developer to jump into a fully configured environment for each agent's task rather than reviewing diffs in a restricted UI.
Summary of Capabilities
| Feature | Implementation |
|---|---|
| Runtime | Claude Code / Codex CLI via AgentCliAdapter |
| Storage | Local SQLite in .kanbots/ |
| Concurrency | Up to 4 parallel slots via round-robin personas |
| Deployment | GitHub Mode with draft PRs and pre-push hooks |
| Extensibility | MCP Server for external agent control |
| Budgeting | Live cost analytics with per-run and per-session caps |