How to Tame the Chaos of a Dozen AI Agents in One Project

Recently I tried to run Claude Code for refactoring a module and GitHub Copilot CLI for rewriting tests at the same time. I quickly got lost in terminal tabs, and local branches accidentally overwrote each other's changes. It seems the creators of the Kandev project faced the same problem when they decided to build their own tool for managing AI developers.

Kandev is an open platform with a web interface and Kanban board that transforms chaotic work with autonomous coders into a clear and controlled process.

What's the main idea

Over the past year, many CLI utilities for coding have emerged: Claude Code, Codex, Copilot CLI, Gemini, Cursor agent, Devin, and a couple dozen more alternatives. Each has its own strengths, but when you run them directly in your laptop's terminal, standard complications arise:

1. Changes are inconvenient to review through console output.
2. Running multiple agents in parallel in the same folder leads to Git conflicts.
3. Load on local CPU and RAM grows with every new process.

The Kandev developers propose a different approach: a person sets tasks, distributes them across columns on the board, and reviews the final diffs, while all routine generation remains with the neural networks.

The project isn't tied to any specific vendor's cloud and is distributed under the AGPL-3.0 license. There's no telemetry collection, and you can run the server on your own hardware or an isolated VPS.

Parallel tasks without branch conflicts

To prevent agents from interfering with each other and corrupting the working directory, Kandev actively uses Git worktree mechanisms. Each card gets its own isolated environment with its own branch. You can run three different neural networks simultaneously: one will fix the layout, the second will rewrite SQL queries, and the third will handle documentation.

The workspace screen inside Kandev is laid out like a familiar IDE. One window contains:

• chat with the agent or direct CLI terminal;
• built-in code editor with LSP support;
• file tree and Git changes panel;
• result preview window in the browser.

Thanks to this layout, you view the finished result and diff in a normal visual editor, rather than trying to parse endless lines of text in the console.

Building chains from different providers

An interesting feature of Kandev is creating pipelines from multiple neural networks. The tool supports the open ACP (Agent Client Protocol), through which more than twenty different agents connect.

If desired, you can set up step-by-step task processing:

1. Claude Code designs the architecture and creates a plan.
2. GitHub Copilot generates code based on the compiled plan.
3. Codex checks the received changes for errors and vulnerabilities.

If the tool doesn't yet support ACP directly, Kandev runs it in TUI mode right inside the built-in PTY terminal emulator. This means you can add any console script in literally a couple of minutes through profile settings.

Working with multiple repositories and subtasks

Often a task affects both backend and frontend simultaneously. Kandev can link one card to multiple repositories. The system will create a separate worktree for each project, generate branches, and collect grouped changes in a single review window.

If a task becomes too large, the agent can spawn subtasks that inherit the parent session's context. This helps when you need to split a big refactoring into several independent pull requests.

The project also has built-in MCP (Model Context Protocol) support. Agents inside Kandev get access to utility tools: they can create subtasks, send messages to neighboring cards, and read the dialogue history of other agents.

Where to run the agents themselves

Heavy codebases require considerable resources. If you run three autonomous agents on a laptop, the fans will immediately start roaring at maximum. Kandev solves this with flexible runtime selection.

The server sends tasks for execution to different environments:

• local process on your computer;
• isolated Docker container;
• remote server via SSH;
• cloud emulators like sprites.dev.

You can deploy Kandev on a powerful server in the office or at home, and manage cards and review diffs even from a smartphone via browser. For secure connection from an external network, the authors recommend using Tailscale or any familiar VPN.

Technical internals under the hood

The Kandev architecture is quite straightforward. The backend is written in Go and handles process orchestration, task lifecycle, and WebSocket gateway. The entire database and session history are stored locally in SQLite at ~/.kandev.

The frontend is built with React using Vite and Zustand for state management. Monaco Editor is used for code work, xterm.js for the terminal, and the flexible window grid is built on the dockview library.

The team is also developing a desktop application on Tauri for those who prefer a separate window instead of a browser tab.

Currently in development is an autonomy layer called Office mode. This is a mode for permanent agent teams with their own roles, budget limits, memory, and automatic task handoff between agents.

Quick start

You can install the tool with a few commands. For macOS and Linux, a Homebrew package is available:

brew install kdlbs/kandev/kandev
kandev

If you prefer Node.js, launching via npx will do everything in one step:

npx kandev@latest

For Windows users, there's Scoop:

scoop bucket add kandev https://github.com/kdlbs/scoop-kandev
scoop install kandev
kandev

After startup, the server will bring up the web interface, prepare SQLite, and let you immediately attach local or remote repositories.

Who this project is for

Kandev is unlikely to be needed by those who only occasionally ask a chatbot to generate a short script. But it will save a lot of effort if you:

• actively use CLI agents in everyday development;
• want to run tasks in parallel without losing control over commits;
• prefer to keep source code and session data on your own servers;
• are looking for a way to offload heavy code generation from your laptop to a remote machine.

The project is still young, with just over 500 stars on GitHub, but the idea of combining Kanban, Git worktree, and different neural networks into one interface looks quite ready for use.