GitHub All-Stars #11: vibe-kanban – a Kanban board for AI agents

GitHub stars… hundreds of projects marked “for later,” which inevitably turn into a digital graveyard of good intentions. Everyone has that, right? So at VirtusLab, we decided to actually do something with it. Every other Wednesday, we pick one trending project and break it down into its core pieces. Not another React framework or even an agent framework - but something fresh, something that helps us understand where our industry is heading.

Today’s pick: BloopAI/vibe-kanban. A tool written in Rust that tries to bring order to the chaos of working with coding agents.

And honestly? This is one of the most interesting projects I’ve seen in a while.

A problem that hurts everyone

If you work with Claude Code, Gemini CLI, or similar tools, you know the drill. You type a prompt: “Refactor the auth module, add JWT rotation.” And then you wait. Two minutes. Five minutes. The terminal is frozen, the agent is “thinking.”

What do you do in the meantime? You check Twitter. You scroll. Your flow goes straight to the trash.

Louis Knight-Webb (CEO of BloopAI) called this the “doomscrolling gap.” AI was supposed to speed us up, yet it introduces a new kind of delay - because LLMs operate in System 2 mode (slow, analytical thinking). 

The first idea? Trying to work around it by running multiple agents in tmux?

Agents overwrite each other’s files, run into conflicts, and you lose track of who’s working on what. Classic.

vibe-kanban – agents as parallel developers, not chatbots

This is where the idea behind vibe-kanban comes in: stop treating AI agents like chatbots you talk to. Start treating them like asynchronous workers you manage.

Sounds simple? Because the idea is simple. The execution - not so much.

The project is built on four pillars:

• Parallelism – multiple agents at once, each doing its own thing.
• Isolation 0 (and this is the killer feature) – each agent gets its own Git worktree. Zero conflicts. Agent A messes with auth.ts, Agent B with user.ts, and neither steps on the other’s toes.
• Visualization – a classic Kanban board (To Do → In Progress → Review → Done) to track what your silicon interns are up to.
• Verification – a dedicated interface for reviewing diffs before merging. Because trust is good, but verification is better.

In this model, you stop being a “programmer writing code". You become an “agent manager” - defining tasks, assigning workers, reviewing their output, and approving merges. And a good manager needs proper tools.

So what does it look like in practice?

Before we dive into the code, let’s look at what it’s like to work with this day-to-day. Because even the most beautiful architecture means nothing if the UX falls apart.

Installation and getting started

One command:

Seriously - that’s it, I was surprised as well. It runs locally, opens a browser, and you’re greeted with a Kanban board. Zero configuration is needed to get started.

A typical workflow

You create a project - point it at the Git repository you want to orchestrate - and then add a task. You create a card with a description, for example: “Add a REST endpoint for exporting CSV reports.” You can add tags, set a priority, and provide a detailed prompt for the agent.

You drag the card into “In Progress” — and that’s where the magic happens. The system:

• Creates a new branch (e.g. vk/3f20-generate-integra)
• Spins up a Git worktree in an isolated directory
• Launches the selected agent (Claude Code, Gemini, whatever you’ve configured) and passes it the card’s prompt along with the repository context

You can watch everything in real time — a WebSocket streams the agent’s logs. You see its “thinking,” the files it reads, the code it generates. You can hit “Stop” at any moment.

The card lands in “Review” — the agent is done. Now you see the diff, line by line. You can add comments that will be sent back to the agent as feedback. Or you can reject it and create a new “Attempt” with a different agent or prompt.

Merge — one click. The system rebases onto main, merges, and cleans up the worktree. You can also automatically create a PR on GitHub.

In the meantime? You’ve got three other cards in “In Progress”, each handled by a different agent. Every one of them is in its own worktree; none of them is aware of the others’ existence. You scroll between them like a project manager checking in on team status.

On top of that, there’s an “Open in IDE” button that opens the worktree directly in your editor. If vibe-kanban is running on a remote server, it uses SSH remote.

You can enter the isolated directory, apply manual fixes, return to the board, and continue.

Under the hood: Rust doing its thing

The backend is written in Rust, the frontend in TypeScript/React. The choice of Rust is no accident — file system management, child processes, WebSockets, concurrency. This is where you need performance and memory safety.

The structure uses Cargo Workspaces — standard practice for larger Rust projects:

Git Worktrees — a clever use of what Git gives you for free

How does isolation work? When you drag a card to “In Progress”:

1. The system takes the base branch (usually main)
2. Runs git worktree add <path> <new_branch>
3. This creates a linked copy of the repo — it shares .git but has its own checkout
4. The agent runs inside that directory
5. All npm install, builds, and modifications happen in isolation

You avoid Docker overhead (volumes, networks, images) while getting isolation that’s perfectly sufficient for file-level operations. You can have five different versions of the code at the same time, without switching branches in your main terminal.

The trade-off? Each worktree may need its own node_modules. The disk cries, but the isolation is worth it.

State — local first, always

SQLite with SQLx. A local-first architecture - your data lives with you, not in the cloud (unless you explicitly enable PostHog telemetry).

An interesting architectural detail: the code state is managed by Git, while the workflow state is managed by SQLite. vibe-kanban acts as a meta-layer on top of the code. Your Kanban board is not committed - it lives in db.sqlite.

SQLx verifies queries at compile time. If the schema changes and a query becomes invalid, the project simply won’t compile. Rust being Rust.

Patterns worth stealing

Even if you never use vibe-kanban (who has time to try all those “life-changing” tools anyway?), there are patterns here worth remembering:

The Executor trait — an abstraction over agents

The system supports Claude Code, Gemini CLI, Cursor Agent, and any future agent. Each has a different CLI, different flags, and different output formats.

The solution: an Executor trait that defines:

• How to locate the binary
• How to format the prompt
• How to parse stdout

The system is also LLM-agnostic and agent-agnostic. It doesn’t care who does the work, as long as they follow the protocol. If GPT-5 becomes the king of coding tomorrow? Just add a new Executor. A nice example of classic plugin-style architecture.

ts-rs-types across worlds

Backend in Rust, frontend in TypeScript. How do you keep types in sync? Automatically.

Rust structs annotated with #[derive(TS)] generate TypeScript interfaces. If you add a new state to TaskStatus in the backend, the frontend build will fail immediately if you don’t handle it.

Type-Driven Development bridging the language gap.

The “Attempt” model

And here we probably get my favorite innovation.

In Jira, you have a ticket, you work on it, you close it. A strict 1:1 relationship.

Here you have a Task (“Fix the login bug”) and Attempts — concrete executions by different agents:

• Attempt 1 (Claude 3.5): Failed, got stuck in a loop
• Attempt 2 (Gemini Pro): Success, but missed an edge case
• Attempt 3 (Claude with a new prompt): Perfect success

You can review attempts side by side and compare diffs. Code generation becomes an experiment where you sample the solution space with different models until you hit a good result.

This is an architectural reflection of the stochastic nature of LLMs… it burns tokens like crazy, but for the first time it enables real comparison of multiple implementations.

MCP in both directions

It’s 2026, so vibe-kanban implements the Model Context Protocol (MCP):

As a client, it connects to MCP servers (Postgres, Brave Search) and exposes those tools to agents.

As a server, it exposes itself as an MCP server. Other agents can create tasks, move cards, and read the board’s status.

The Kanban board becomes an API for AI. Agents managing agents - agentic “Inception.”

Dev Manager - the port-management daemon

You know this problem: Agent A starts on port 3000, Agent B tries the same thing, crash. Vibe-kanban solves this with a dedicated daemon (dev-manager-mcp) that manages a pool of ports. An agent asks for a port, gets a free one (e.g. 3010), the daemon starts the process and returns the URL.

Takeaways

Isolation is a prerequisite for autonomy. Don’t let agents roam free in your main directory — they’ll make a mess. Git Worktrees are a ready-made pattern for any AI tooling.

The “Attempt” pattern is the future of QA. We’re moving from “writing code” to “generating candidates.” Three solutions from three models, you pick the best one. Tools must evolve toward a 1:N relationship between a task and its solutions. And if you add tests up front, the circle is complete.

Interfaces > implementations. Today Claude Opus 4.0 is king. Tomorrow it might be GPT-6. Abstract agents behind interfaces and stay resilient to the volatility of the AI market.

Type safety across boundaries. In 2025/2026 there’s no excuse for loose typing between backend and frontend. Automatic type generation is a solved problem.

The senior skill of the future? Not memorizing syntax. Code review and system design. You need to look at AI-generated diffs and immediately spot a security hole. AI generates, you verify. But you’ve probably heard that enough times in 2025 already 😁.

BloopAI/vibe-kanban offers a glimpse into the near future. AI is already good enough to do the heavy lifting, but not good enough to be left unsupervised.

The project solves the so-called “doomscrolling gap” by turning the developer into a parallel processor. Unlike the slop feared by critics of AI-assisted coding, vibe-kanban wraps that “vibe” in solid Rust foundations and clever use of Git Worktrees, creating a safe playground for silicon interns.

And for that, it fully deserves our star. ⭐