Vibe Kanban: The Git Worktree Strategy Behind Orchestrating Multiple AI Coding Agents

Hook

While most developers treat AI coding assistants as glorified autocomplete, Vibe Kanban tackled a harder problem: what happens when you want to run five different AI agents on five different features simultaneously without them stepping on each other's commits?

Context

The explosion of AI coding agents in 2023-2024—Claude Code, GitHub Copilot, Cursor, Codex, and dozens more—created a new problem that traditional development workflows weren't designed to handle. These agents work best when given focused, isolated tasks, but spinning up separate repositories or manually managing branches for each agent-driven task becomes unwieldy fast. Developers found themselves context-switching between planning tools (Linear, Jira, Notion) and their coding environments, manually syncing task status with agent progress, and dealing with merge conflicts when agents worked on overlapping code.

BloopAI built Vibe Kanban to bridge this gap: a hybrid Rust/React desktop application that combines kanban-style task planning with workspace orchestration specifically designed for AI agents. Instead of treating agents as IDE plugins, it positioned them as autonomous workers that needed their own isolated environments. The tool leveraged git worktrees—a relatively underutilized Git feature—to give each workspace its own branch and working directory, enabling true parallel agent execution. Though the project announced its sunset in late 2024, its architectural approach to agent orchestration offers valuable lessons for anyone building on top of AI coding tools.

Technical Insight

At its core, Vibe Kanban's architecture rests on three key components: a Rust backend for git operations and workspace management, a React frontend for the kanban UI and diff review, and an abstraction layer that normalizes interactions across different coding agents. The Rust backend handles the heavy lifting of git worktree creation, file watching, and serving a local API that the frontend consumes.

The git worktree strategy is the architectural linchpin. When you create a new workspace in Vibe Kanban, it doesn't just create a branch—it creates a completely separate working directory using git worktree add. This means each workspace gets its own file system representation of a different branch, allowing multiple agents to work simultaneously without conflicts:

// Simplified example of worktree creation logic
pub fn create_workspace(repo_path: &Path, task_id: &str, base_branch: &str) -> Result<PathBuf> {
    let worktree_path = repo_path.join(".vibe-workspaces").join(task_id);
    let branch_name = format!("vibe/{}", task_id);
    
    // Create new branch from base
    Command::new("git")
        .current_dir(repo_path)
        .args(&["worktree", "add", "-b", &branch_name])
        .arg(&worktree_path)
        .arg(base_branch)
        .output()?;
    
    // Initialize workspace metadata
    let metadata = WorkspaceMetadata {
        task_id: task_id.to_string(),
        branch: branch_name,
        created_at: Utc::now(),
        agent_type: None,
    };
    
    write_metadata(&worktree_path, &metadata)?;
    Ok(worktree_path)
}

This approach means Workspace A running Claude Code on feature authentication and Workspace B running Codex on refactoring the database layer are operating in completely separate directories with separate branches. No shared index, no .git/HEAD conflicts, no accidental overwrites.

The agent abstraction layer is equally clever. Rather than hardcoding support for specific agents, Vibe Kanban defines a standard interface that agents must conform to. Each agent implementation exposes a start command, environment variables, and a working directory. The frontend doesn't care whether you're using Claude Code or Gemini CLI—it just knows how to launch an agent in a specified worktree:

// Agent configuration abstraction
const agentConfigs = {
  'claude-code': {
    command: 'claude',
    args: ['--workspace', '{WORKSPACE_PATH}'],
    envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY },
    requiresAuth: true
  },
  'codex': {
    command: 'codex',
    args: ['--dir', '{WORKSPACE_PATH}'],
    envVars: { OPENAI_API_KEY: process.env.OPENAI_API_KEY },
    requiresAuth: true
  },
  'aider': {
    command: 'aider',
    args: ['--yes-always', '--in-place'],
    workingDir: '{WORKSPACE_PATH}',
    requiresAuth: false
  }
};

function launchAgent(agentType, workspacePath, taskContext) {
  const config = agentConfigs[agentType];
  const processedArgs = config.args.map(arg => 
    arg.replace('{WORKSPACE_PATH}', workspacePath)
  );
  
  return spawn(config.command, processedArgs, {
    cwd: config.workingDir?.replace('{WORKSPACE_PATH}', workspacePath) || workspacePath,
    env: { ...process.env, ...config.envVars }
  });
}

The diff review component integrates directly with git operations, watching for changes in each worktree and presenting them in a unified interface. It uses file system watchers on the Rust side to detect modifications, then streams diffs to the frontend via WebSocket. This creates a tight feedback loop: assign task on kanban board → agent executes in isolated worktree → review changes in diff UI → merge or request modifications.

For teams wanting remote access, Vibe Kanban implemented an optional relay tunnel system that exposes the local server through a secure connection. This is particularly interesting for organizations that want to host a central Vibe Kanban instance that multiple developers can access, each managing their own set of agent workspaces. The Rust backend handles the WebSocket relay logic, forwarding authenticated requests to the appropriate workspace contexts.

What makes this architecture compelling isn't any single component—it's how they compose into a workflow specifically optimized for agent orchestration. The kanban board becomes your task queue, worktrees provide isolation, the agent abstraction enables polyglot AI usage, and the integrated diff review closes the loop. It's a complete rethink of development workflow for an AI-augmented world.

Gotcha

The elephant in the room: Vibe Kanban is officially sunset. The maintainers announced the project's shutdown in late 2024, which means no active development, no security patches, and no guarantee of compatibility with newer agent versions. This isn't a tool you should adopt for production use today—it's a reference implementation and a source of architectural patterns you can borrow.

Even during active development, Vibe Kanban had sharp edges. The git worktree approach is powerful but can confuse developers unfamiliar with the feature—you end up with multiple copies of your repository on disk, and managing disk space becomes a concern for projects with large histories. The tool assumes you've already set up and authenticated with your chosen coding agents; it's an orchestration layer, not an agent installer. If your API keys aren't configured or your agent CLI tools aren't in PATH, you'll hit cryptic spawn errors. The self-hosting setup requires coordinating environment variables across the Rust backend, Node frontend, and optional relay service, which is more operational complexity than teams using managed services expect. Finally, the diff review UI, while functional, lacks the sophistication of dedicated code review tools—no conversation threads, no approval workflows, no integration with pull request systems beyond basic git operations.

Verdict

Use Vibe Kanban's codebase if you're building your own tooling for multi-agent orchestration and want to understand how git worktrees enable parallel agent execution, or if you're researching workflow patterns for AI-augmented development teams. Fork it as a foundation for internal tools where you can maintain it yourself. It's an excellent learning resource for Rust/React architecture and git integration patterns. Skip it if you need a production-ready, actively maintained solution—the sunset announcement makes it unsuitable for any context where you can't commit to maintaining the fork yourself. Skip it if you're working with a single agent in simple workflows where the overhead of workspace management and kanban planning isn't justified. Skip it if your team isn't comfortable with git worktrees or debugging Rust/Node hybrid applications when things inevitably break.