Ban Kan

Installation

Run instantly

npx @stilero/bankan

Install globally

npm install -g @stilero/bankan
bankan

Run from source

git clone https://github.com/stilero/bankan.git
cd bankan

npm run install:all
npm run setup
npm run dev

Ban Kan starts a local server, opens your browser automatically, and serves the dashboard from the same process.

Contributor workflow, TDD expectations, pull request testing guidance, and verification commands live in CONTRIBUTING.md.

Requirements

• Node.js >= 18
• git
• At least one AI CLI tool:
  • Claude Code (npm install -g @anthropic-ai/claude-code)
  • Codex CLI (npm install -g @openai/codex)
• GitHub CLI (gh) — required only for automatic pull request creation

Native build tools may be needed only if node-pty has to compile during install.

macOS: xcode-select --install Linux: sudo apt-get install build-essential Windows: Install Visual Studio Build Tools with the "Desktop development with C++" workload, or run npm install -g windows-build-tools from an elevated PowerShell

Big heads up

Ban Kan is in early development.

The core workflow works, but bugs and rough edges are expected. Feedback is extremely valuable at this stage.

Quick Start

1. Launch Ban Kan

bankan

2. Complete the setup wizard

3. Configure agent CLIs in Settings -> Implementation and Settings -> Review as needed

4. Add one or more repositories in Settings -> General -> Repositories

5. Create a task in the dashboard

6. Approve the generated plan

7. Watch agents implement and review the change

8. Optionally create a pull request

What Is Ban Kan

Ban Kan is a local control center for AI coding agents that work across real repositories.

Instead of one long AI chat trying to do everything, tasks move through a structured pipeline inspired by a Kanban board:

Backlog → Planning → Implementation → Review → Done

Each stage can use different agents, prompts, and concurrency settings. Developers keep full visibility and control over what is happening at every step.

Ban Kan combines:

• structured workflows
• parallel agent execution
• human approvals
• local repository access
• optional pull request automation

All in one dashboard.

Why Ban Kan Exists

When developers levels up running multiple AI coding agents they often end up juggling multiple terminals:

• Agent 1 planning a feature
• Agent 2 implementing code
• Agent 3 reviewing changes
• Agent 4 generating tests

Keeping track of everything quickly becomes overwhelming.

In practice most developers struggle to manage more than 3–4 agents at once.

Ban Kan provides a control center that lets you coordinate 10+ agents simultaneously with full visibility of tasks, stages and activity.

a Kanban board with specialized AI agents.

Each stage has a clear responsibility, and tasks move forward only when the previous step succeeds.

Built for Agile Development

Ban Kan fits naturally into Agile workflows where work is organized as stories.

Each story moves through a structured lifecycle that mirrors how real development teams operate:

flowchart LR
    A[Story / Task Created] --> B[Planning Agent]
    B --> C[Implementation Agent]
    C --> D[Review Agent]
    D --> E[Done / Pull Request]

This structure makes Ban Kan especially useful when working with:

• Agile user stories
• sprint backlogs
• feature tasks
• incremental development

Instead of one AI trying to solve everything in a single prompt, each stage has a clear responsibility — just like in a real Agile team.

Developers plan the story, agents implement the work, reviewers validate the result, and the change moves forward when it meets quality gates.

What It Looks Like In Practice

Example story: Add Stripe payments

Below is the same task moving through Ban Kan's workflow from creation to completion.

1. Create the task

The developer creates a task in the dashboard and defines the story to be planned and executed.

2. Planning starts

The planner agent picks up the task, analyzes the repository, and prepares an implementation plan.

3. Review and approve the plan

The generated plan is shown in the dashboard so the developer can approve it before any code is written.

4. Implementation runs

After approval, the implementor agent creates its workspace, writes the code, and reports progress live in the UI.

5. Review stage

The reviewer agent validates the implementation, checks for issues, and decides whether the task is ready to move forward.

6. Done / ready for PR

Once review passes, the task moves to Done and can be used as the basis for a pull request.

Multiple tasks can move through these stages simultaneously with different agents assigned to each step.

How It Works

flowchart TD
    A[Developer creates task] --> B[Planner agent analyzes repository]
    B --> C[Plan generated]
    C --> D{Approve plan?}
    D -->|Yes| E[Implementor writes code]
    D -->|No| F[Revise plan]
    E --> G[Reviewer validates changes]
    G --> H{Review passed?}
    H -->|Yes| I[Done / PR created]
    H -->|No| E

Multiple tasks can run in parallel across different agents.

Key Features

Parallel AI agents

Run multiple planning, implementation, and review agents simultaneously.

Local-first workflow

Repositories stay on your machine. Agents operate directly on local clones and workspaces.

Human approval gates

Developers approve plans before implementation begins.

Live agent terminals

Open the terminal of any running agent and take control when needed.

VS Code workspace support

Open a task workspace directly from the dashboard.

PR automation

Configure GitHub settings to automatically create pull requests.

Real-time dashboard

Track:

• active tasks
• blocked tasks
• agent activity
• context usage

CLI

Ban Kan keeps the CLI intentionally simple.

bankan --port 3005
bankan --no-open
bankan --help

Options:

• --port bind to a specific port
• --no-open start without opening a browser

Most workflows happen inside the dashboard after launch.

Architecture

Ban Kan includes:

• Node / Express backend orchestration
• WebSocket communication for live updates
• React dashboard built with Vite
• CLI launcher that starts the local app
• Configurable planner, implementor, and reviewer agent pools

Development

npm run setup
npm run dev

Useful scripts:

• npm run build – build client bundle
• npm run dev – run server + Vite client
• npm run lint – run ESLint across the repo
• npm run lint:fix – apply safe ESLint autofixes
• npm run setup – interactive setup wizard for local runtime config
• npm run install:all – install all dependencies

Contributing

Contributions are welcome.

1. Fork the repository
2. Open an issue before starting work
3. Create a focused branch
4. Make your changes
5. Submit a pull request

Screenshots are appreciated for UI updates.

License

MIT