Skip to content
/
Tier A A12 UI passthrough

Vibe Kanban

vibe-kanban · BloopAI/vibe-kanban · ★ 27k · last commit 2026-04-24

Primitive shape
No installable primitives
00

Summary

Vibe Kanban — Summary

Vibe Kanban is a full-stack local web application (Rust backend + SvelteKit frontend, shipped via npx vibe-kanban) that serves as a multi-agent planning and review dashboard for 10+ coding agents (Claude Code, Codex, Gemini CLI, GitHub Copilot, Amp, Cursor, OpenCode, Droid, CCR, Qwen Code). It is not a prompt framework — it provides no commands, skills, hooks, or spec templates of its own. Instead, it wraps existing agents' native slash commands and provides a kanban board for issue planning, workspace management (each workspace = one agent + one git branch + one dev server), inline diff review with AI-generated PR descriptions, and a built-in browser with devtools. Note: The project announced sunsetting at the time of analysis.

Compared to seeds, Vibe Kanban is architecturally unlike all 11 seeds — the closest analogy is kiro (both are graphical environments for managing AI coding agents), but Vibe Kanban is a local web app you run via npx rather than a closed IDE. It adds no spec format, no methodology, and no prompt primitives; its value is entirely in the planning + review UX layer on top of existing agents.

01

Overview

Vibe Kanban — Overview

Origin

Created by BloopAI. Apache-2.0 license. 26,518 stars. Built in Rust (backend) + TypeScript (frontend). Last push April 2026.

Sunsetting notice: The README prominently displays "Vibe Kanban is sunsetting. Read the announcement." at the time of this analysis.

Philosophy

"In a world where software engineers spend most of their time planning and reviewing coding agents, the most impactful way to ship more is to get faster at planning and review."

The framework takes the position that AI coding agents are already good enough to write code — the bottleneck is human planning (defining work) and human review (checking results). Vibe Kanban optimizes for these two human activities.

Key Features (from README)

"Plan with kanban issues — create, prioritise, and assign issues on a kanban board" "Run coding agents in workspaces — each workspace gives an agent a branch, a terminal, and a dev server" "Review diffs and leave inline comments — send feedback directly to the agent without leaving the UI" "Preview your app — built-in browser with devtools, inspect mode, and device emulation" "Switch between 10+ coding agents — Claude Code, Codex, Gemini CLI, GitHub Copilot, Amp, Cursor, OpenCode, Droid, CCR, and Qwen Code" "Create pull requests and merge — open PRs with AI-generated descriptions, review on GitHub, and merge"

Target Users

Teams doing "vibe coding" who want to manage multiple concurrent coding agent sessions from a single UI without switching terminals.

02

Architecture

Vibe Kanban — Architecture

Distribution

  • Type: npm package (desktop-app served as local web app)
  • Install: npx vibe-kanban
  • License: Apache-2.0
  • Language: Rust (backend), TypeScript + SvelteKit (frontend)
  • Stars: 26,518

Technology Stack

  • Backend: Rust (crates/server/, crates/db/, crates/workspace-manager/, crates/worktree-manager/)
  • Frontend: SvelteKit + TanStack Router (packages/local-web/)
  • Remote: Docker-based self-hosting (crates/remote/)
  • Desktop (optional): Tauri app (crates/tauri-app/)
  • Database: SQLite (embedded, sqlx)
  • Workspace isolation: Git worktrees (one per workspace)

Crates Structure

crates/
  server/           ← Rust HTTP server
  db/               ← SQLite data layer
  workspace-manager/ ← Agent workspace lifecycle
  worktree-manager/  ← Git worktree operations
  executors/         ← Agent process execution (claude, codex, gemini, etc.)
  git/               ← Git operations
  review/            ← Code review primitives
  preview-proxy/     ← Built-in browser proxy
  tauri-app/         ← Optional desktop app wrapper
  remote/            ← Cloud/self-hosting layer
  relay-*/           ← WebRTC/WebSocket relay for remote access

Packages Structure

packages/
  local-web/        ← SvelteKit frontend (kanban, workspace, diff review)
  ui/               ← Shared UI components
  web-core/         ← Core web utilities
  remote-web/       ← Remote hosting frontend

CLI Binary

vibe-kanban binary (from npx-cli/bin/cli.js) downloads and launches the Rust backend + web frontend.

Default Port

Auto-assigned (configurable via PORT env var). Frontend on PORT, backend on PORT+1 (dev). Production: single port.

Self-Hosting

Docker Compose self-hosting available (docs/self-hosting/). Relay, attachments, and WebRTC support for remote access.

03

Components

Vibe Kanban — Components

Vibe Kanban ships no commands, skills, hooks, or agents of its own. Its "components" are UI features and backend services.

UI Features

Kanban Board

  • Create, prioritize, assign issues
  • Drag-and-drop status management
  • Parent/child issue relationships
  • Tags, priorities

Workspaces

  • Each workspace = one agent + one git branch + one dev server
  • Agent process is launched and managed by the backend
  • Terminal access within the workspace UI
  • Chat interface (sends messages to the agent)

Slash Commands (Agent Pass-Through)

  • Vibe Kanban discovers and exposes native slash commands from each connected agent
  • Commands are passed through to the underlying agent (not Vibe Kanban's own commands)
  • Supported agent commands: Claude Code /compact, /review, etc.; Codex /compact, /status; and more
  • Only non-interactive commands supported (TUI commands like /model excluded)

Diff Review

  • Inline code diff viewer
  • Leave comments on specific lines
  • Send feedback directly to the agent

Built-in Browser

  • Integrated browser for app preview
  • DevTools access
  • Inspect mode
  • Device emulation

Git Operations

  • Create PRs with AI-generated descriptions
  • Review on GitHub
  • Merge via the UI

Multi-Repo Sessions

  • Single workspace can manage multiple repositories

Backend Services

  • Workspace manager: Lifecycle management for agent processes
  • Worktree manager: Git worktree creation and cleanup
  • Executors: One executor per supported agent (claude, codex, gemini-cli, copilot, amp, cursor, opencode, droid, ccr, qwen-code)
  • Preview proxy: Reverse proxy for the app preview browser
  • Relay: WebRTC/WebSocket relay for remote access

Supported Agents

Claude Code, Codex CLI, Gemini CLI, GitHub Copilot, Amp, Cursor (CLI), OpenCode, Droid, CCR, Qwen Code

05

Prompts

Vibe Kanban — Prompt Excerpts

Vibe Kanban does not ship prompt files (commands, skills, or agents). It exposes agents' native slash commands as pass-through UI elements. The closest things to "prompt content" are the onboarding documentation and the CLAUDE.md/AGENTS.md in the repository, which are for Claude Code working on the Vibe Kanban codebase itself — not for end users.

Excerpt 1: Slash Commands Documentation (Pass-Through)

Source: docs/workspaces/slash-commands.mdx

## Available Commands by Agent

The available slash commands depend on which coding agent you're using. Vibe Kanban discovers
and exposes the same commands you'd have in the agent's native CLI, so the experience matches
what you're used to.

### Claude Code

| Command | Description |
|---------|-------------|
| `/compact` | Clear conversation history but keep a summary in context |
| `/review` | Review a pull request |
| `/security-review` | Complete a security review of pending changes |
| `/init` | Initialize a new CLAUDE.md file with codebase documentation |
| `/pr-comments` | Get comments from a GitHub pull request |

Note: These are Claude Code's built-in commands surfaced by Vibe Kanban. Vibe Kanban does not define its own.

Excerpt 2: Getting Started Onboarding

Source: docs/getting-started.mdx

## 6. Create a workspace

**Workspaces** are another core concept of Vibe Kanban, they represent a space to work on an
issue with a coding agent. When you create a workspace, Vibe Kanban automatically creates git
worktrees for your selected repositories, and launches your coding agent.

To create a workspace, make sure the issue you created is selected and click the 'create' button
in the workspaces window.

Vibe Kanban is a UI layer, not a prompting framework. For prompt engineering analysis, the interesting primitives are in the agents it wraps (Claude Code, Codex, etc.), not in Vibe Kanban itself.

09

Uniqueness

Vibe Kanban — Uniqueness

Differs From Seeds

Vibe Kanban is architecturally unlike all 11 seeds. The closest analogy is kiro (both are graphical environments for AI coding agent workflows), but the comparison is limited: kiro is a closed IDE fork with its own spec format and hook events, while Vibe Kanban is a local web app that wraps any of 10+ existing agents without defining any prompt primitives. Among seeds, claude-conductor (markdown scaffold, no commands) is the only other framework that ships no commands/skills/hooks of its own — but claude-conductor is a passive file-injection approach, not a dynamic UI. Vibe Kanban's defining contribution is the kanban+workspace+diff-review loop for human planning and review around existing agent sessions.

Positioning

  • "The bottleneck is planning and review, not implementation"
  • UI-layer approach: adds value on top of agents without prescribing methodology
  • Broadest agent compatibility in this batch (10+ agents vs. 1-2 for most)

Notable Patterns

  1. Git worktree per workspace: The only framework in this batch (besides Forge) that creates git worktrees as an isolation primitive — but vibe-kanban uses them for independent parallel work, not sequential task isolation
  2. 10+ agent executors: More agent integrations than any other framework in this batch
  3. Built-in browser with DevTools: Unusual — no other framework provides preview infrastructure
  4. Sunsetting: The most-starred framework in this batch is also the only one explicitly sunsetting

Observable Failure Modes

  1. Sunsetting: The project announced sunsetting — adopter risk is high
  2. No spec format: Provides no guidance on how to write good agent prompts
  3. Human-bottleneck orchestration: The user must manually manage task distribution across workspaces
  4. Sign-in gate for team features: Requires cloud connectivity for multi-user kanban

Cross-References

  • Described itself as "Get 10X more out of Claude Code, Codex or any coding agent" (same slogan as Nimbalyst in this batch — both are UI wrappers for agent sessions)
  • Nimbalyst (also in this batch) offers similar capabilities and is the natural successor for users migrating from vibe-kanban
04

Workflow

Vibe Kanban — Workflow

Vibe Kanban does not define a spec-driven development workflow. It provides a UI wrapper around any workflow the user applies with their chosen agent.

Typical Usage Pattern

1. Create issue (kanban board)
2. Assign priority + description
3. Create workspace from issue
   → Git worktree created for selected repo
   → Agent process launched
4. Chat with agent in workspace
   → Use agent's native slash commands
   → Review inline diffs
   → Leave comments (sent to agent)
5. Preview app in built-in browser
6. Create PR with AI-generated description
7. Review on GitHub, merge

Approval Gates

None defined by the framework. The user decides when to move an issue between kanban columns and when to merge a PR.

Phase Artifacts

Step Artifact
Issue creation Issue card (stored in Vibe Kanban DB)
Workspace creation Git worktree + agent process
Agent work Code changes (whatever the agent produces)
Review Inline comments
Completion PR → merged code

Multi-Agent Parallelism

The key workflow feature: multiple workspaces can run simultaneously with different agents, each on its own git branch. The kanban board provides the coordination surface.

Sign-In

Optional sign-in via GitHub or Google. Without sign-in: workspaces work, but kanban board and team features are unavailable.

Self-Hosting

For teams: Docker Compose self-hosting with Relay (WebRTC for remote access) and attachments support.

06

Memory Context

Vibe Kanban — Memory & Context

State Storage

  • Vibe Kanban state: SQLite database (embedded, managed by Rust backend)
    • Issues, comments, workspace metadata, project/organization data
    • User preferences (default agent, IDE, notifications)
  • Agent state: Managed by each individual agent's native mechanisms (not by Vibe Kanban)
  • Code state: Git worktrees (one per workspace, on disk)

Persistence

  • Scope: Local machine (SQLite file) or cloud (with self-hosting and sign-in)
  • Issues persist across sessions via the database
  • Agent conversation history: managed by the agent itself

Context Injection

Vibe Kanban does not inject context into agents. Users send messages to agents through the workspace chat interface; Vibe Kanban is a passthrough.

Cross-Session Continuity

  • Workspaces persist in the database — users can see which agents are working and which need attention
  • The kanban board shows issue status across sessions
  • Agent conversation history depends on the agent (e.g., Claude Code's own session management)

No Framework Memory Layer

Unlike all other frameworks in this batch, Vibe Kanban has no spec files, no CLAUDE.md injection, no SessionStart hook, and no project-level context management. It is entirely a UI layer.

07

Orchestration

Vibe Kanban — Orchestration

Multi-Agent Pattern

Yes — but not through a framework-defined orchestration protocol. Vibe Kanban enables multiple concurrent agent workspaces, each independently controlled by the user through the kanban board.

  • Orchestration pattern: none (the user IS the orchestrator)
  • Coordination: human-driven via kanban board
  • Isolation: git-worktree (one worktree per workspace)

Agent Execution

Each workspace launches an independent agent process:

  • Claude Code: claude process
  • Codex: codex process
  • etc.

The executors/ crate contains one executor implementation per agent type.

Isolation Mechanism

Git worktrees — when a workspace is created, Vibe Kanban creates a new git worktree for the selected repository. Each agent works on its own branch without interfering with other workspaces.

No Programmatic Orchestration

Vibe Kanban does not:

  • Route tasks between agents automatically
  • Define agent handoffs
  • Implement any consensus mechanism
  • Chain prompts programmatically

The human reviews the kanban board and decides which agents to create workspaces for.

Multi-Model

Yes — in the sense that different workspaces can use different AI models (Claude, GPT, Gemini, etc.). But there is no programmatic model routing; the user selects the agent per workspace.

Remote Access

For teams, the relay layer (WebRTC/WebSocket) enables remote access to running workspaces. This is a UI tunneling mechanism, not an orchestration protocol.

08

Ui Cli Surface

Vibe Kanban — UI / CLI Surface

CLI Binary

Yes — vibe-kanban (npx-cli/bin/cli.js):

  • Downloads and launches the Rust backend + SvelteKit frontend
  • Single command: npx vibe-kanban or vibe-kanban if installed globally

Local Web Dashboard

Yes — this is the primary interface.

Property Value
Type Web dashboard (local)
Port Auto-assigned (configurable via PORT env)
Tech stack SvelteKit + TanStack Router (frontend), Rust Axum (backend), SQLite
Features Kanban board, workspace management, diff viewer, chat interface, built-in browser, PR creation

Features Detail

Feature Description
Kanban board Issues as cards, drag-and-drop status management
Workspace view Agent chat, terminal, dev server preview
Diff viewer Inline diff with line comments
Built-in browser App preview with DevTools, inspect mode, device emulation
PR creation AI-generated PR descriptions, GitHub integration
Multi-repo sessions Single workspace manages multiple repos
Slash commands Agent-native slash command typeahead

Desktop App (Optional)

Tauri wrapper available (crates/tauri-app/). Can be built from source as a native desktop app.

Mobile App

iOS and Android apps (listed in packages/ios/, packages/android/) — not detailed in public docs at analysis time.

Sign-In

Optional GitHub or Google OAuth for kanban/team features.

Self-Hosting

Docker Compose self-hosting with Relay (WebRTC for remote access) and attachment storage support. Documentation at docs/self-hosting/.

Observability

  • Workspace status visible in real-time in the UI
  • Agent terminal output visible in workspace view
  • No audit log beyond what the agent itself produces

Related frameworks

same archetype · same primary tool · same memory type

Goose (Block/AAIF) ★ 46k
A12 UI passthrough

General-purpose AI agent (not just code) with security-first tool inspection, recipe-based shareable configurations, and 15+ LLM…

1Code ★ 5.5k
A12 UI passthrough

Cursor-like desktop experience for Claude Code and Codex with cloud background agents, event-driven automations, and a full…

Crystal (stravu) ★ 3.1k
A12 UI passthrough

Manage multiple parallel AI coding sessions in isolated git worktrees from a single desktop GUI.

Maestro (RunMaestro) ★ 3.0k
A12 UI passthrough

Orchestrate unlimited parallel AI agent sessions with a keyboard-first desktop app including Group Chat coordination and Auto Run…

AgentsMesh ★ 2.1k
A12 UI passthrough

Multi-tenant workforce platform that gives every team member a squad of AI coding agents coordinated through channels, pod…

Open Cowork ★ 1.4k
A12 UI passthrough

Makes Claude Code accessible to knowledge workers on Windows/macOS with one-click install, VM sandbox, document skills, and IM…