Building Kanbots: AI Agents, Git Worktrees, and Desktop Automation

Orchestrating Development with AI Agents and Isolated Workspaces

Modern software development often involves managing numerous tasks, collaborating with team members, and increasingly, leveraging AI for assistance. Imagine a tool that brings all these elements together: a personal Kanban board where each task card can host its own AI agents, operating in isolated Git environments, and collaborating on code generation, review, or other development workflows.

This guide will walk you through building Kanbots, a desktop Kanban application designed to do exactly that. We’ll combine the power of a local-first desktop application with the intelligence of AI agents and the robustness of Git worktrees to create a unique development automation platform.

Why Build Kanbots?

The motivation behind Kanbots is to address several practical challenges in modern development:

Local-First Control and Privacy: Unlike many cloud-based AI tools, Kanbots operates as a desktop application. This gives you direct control over your environment, data, and AI interactions, enhancing privacy and allowing direct filesystem access for agents.
Isolated AI Task Execution: AI agents often need to modify code or interact with a specific project context. Git worktrees provide a clean, isolated environment for each agent to operate without interfering with your main codebase or other agents. This prevents conflicts and simplifies context management.
Multi-Agent Collaboration: Real-world development tasks are complex. Kanbots enables you to orchestrate multiple AI agents, each potentially with a different persona (e.g., “Developer,” “Reviewer”), to collaborate on a single task card. This mimics human team dynamics for automated workflows.
Enhanced Development Workflow: Automate repetitive coding tasks, generate boilerplate, perform code reviews, or even prototype features directly from your task board, freeing up developer time for more complex problem-solving.
Understanding Modern Stack Integration: This project offers a hands-on opportunity to integrate a modern desktop framework (Tauri), a reactive frontend (Svelte), powerful version control (Git), and external AI APIs into a cohesive, functional system.

What We’re Building

Kanbots will be a cross-platform desktop application featuring:

An interactive Kanban board UI to manage tasks.
The ability to attach one or more AI agents to individual task cards.
Dynamic creation and management of Git worktrees, providing isolated sandboxes for each agent’s execution.
Orchestration logic for multi-agent workflows, allowing agents to collaborate sequentially or in parallel.
Persona-based task assignment, enabling agents to adopt specific roles (e.g., code generation, review, testing).
Real-time UI feedback on agent progress, outputs, and control mechanisms (pause, resume).
Secure handling of AI API keys and robust error reporting.

By the end of this guide, you will have a functional Kanbots application and a deep understanding of how to architect desktop applications with Rust, manage complex Git operations programmatically, and orchestrate intelligent agents for practical development tasks.

Core Technologies and Versions

We’ll be leveraging a powerful and modern stack for Kanbots:

Tauri v2: The framework for building cross-platform desktop applications using web technologies. Tauri’s Rust backend provides performance, security, and direct system access, while its web frontend offers flexibility.
Svelte 5: A reactive JavaScript framework for building the user interface. Svelte compiles your components into highly optimized vanilla JavaScript, resulting in small bundle sizes and excellent performance.
Rust: The primary language for Kanbots’ backend logic, handling file system interactions, Git operations, and AI API orchestration.
TypeScript: Used for type-safe frontend development with Svelte, improving code quality and maintainability.
AI Agent APIs: We will integrate with external AI models like Claude Code (from Anthropic) or Codex (from OpenAI, or its successors).
- Claude Code: Exact stable version checked unknown as of 2026-05-24. Please confirm the latest stable release from Anthropic’s official documentation.
- Codex (or successors): Exact stable version checked unknown as of 2026-05-24. Please confirm the latest stable release from OpenAI’s official documentation.
Git: The distributed version control system, fundamental for managing worktrees and code changes.
- Exact stable version checked unknown as of 2026-05-24. Please confirm the latest stable release from Git’s official documentation.

Prerequisites and Setup

Before we begin, ensure you have the following installed and configured on your desktop operating system (Windows, macOS, or Linux):

Rust Toolchain: Install rustup by following the instructions on the official Rust website. This will provide rustc, cargo, and other necessary tools.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Node.js & npm/yarn: For the Svelte frontend. We recommend using a Node.js LTS version.

# For Node.js (e.g., via nvm)
nvm install --lts
nvm use --lts
# Or directly from nodejs.org

Git: Ensure Git is installed and configured with your user name and email.

# Check if installed
git --version
# Configure (if not already)
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Code Editor: A robust code editor like VS Code with Rust Analyzer and Svelte extensions is highly recommended.
AI API Keys: Obtain API keys for your chosen AI agent (e.g., Claude Code or OpenAI’s models). Keep these secure; we will discuss secure handling in a later chapter.

Architecture at a Glance

Kanbots follows a clear architectural pattern:

Tauri Core: The application is built with Tauri, where a Rust backend handles system-level operations, and a Svelte web frontend provides the user interface.
IPC Communication: The Svelte frontend communicates with the Rust backend via Tauri’s Inter-Process Communication (IPC) layer. This allows UI actions to trigger backend logic and backend events to update the UI.
Rust Backend Orchestration: The Rust backend is the brain of Kanbots. It manages the creation, deletion, and switching of Git worktrees, orchestrates calls to external AI agent APIs, and handles the intricate logic of multi-agent workflows.
Isolated Agent Environments: Each Kanban card can be associated with one or more AI agents. When an agent is active, the Rust backend ensures it operates within its own dedicated Git worktree. This worktree is a separate, lightweight copy of a Git repository, allowing agents to make changes without affecting the main branch or other agents.
External AI Intelligence: The Rust backend makes secure HTTP requests to AI agent APIs (like Claude Code or OpenAI’s services) to send prompts and receive generated outputs.
Local-First Data: While AI interactions are external, the core Kanban board data and agent states will be managed locally, prioritizing user control and responsiveness.

Learning Path

This guide is structured into incremental milestones, allowing you to build and verify Kanbots step-by-step.

Setting Up Your Kanbots Workshop: Tauri v2 and Svelte 5

Configure the development environment for Tauri (v2) and Svelte (5), initialize the project, and verify the basic desktop application setup.

Building the Core Kanban Board UI

Develop the interactive Kanban board user interface with functionality for adding, editing, and moving cards and columns.

Mastering Git Worktrees for Isolated Agent Tasks

Implement Rust backend logic to dynamically create, manage, and switch between git worktrees, providing isolated execution environments for each Kanban card’s tasks.

Integrating Your First AI Agent: Claude Code or Codex

Connect a single AI agent (e.g., Claude Code or Codex) to a Kanban card, enabling it to perform a simple task within its dedicated git worktree.

Orchestrating Multi-Agent Workflows with Personas

Design and implement the system for orchestrating multiple AI agents to collaborate on a task, demonstrating a practical code generation and review cycle using distinct personas.

Real-time Agent Progress and User Control UI

Enhance the frontend UI to display real-time agent progress, outputs, and provide user controls like pausing or resuming agent tasks.

Securing API Keys and Robust Error Handling

Implement secure storage and retrieval for AI API keys and establish robust error handling mechanisms for agent failures and API communication issues.

Logging Agent Activities and Deployment Considerations

Integrate comprehensive logging for agent activities and outputs, and discuss essential considerations for packaging and deploying the Kanbots desktop application.

Important Considerations and Potential Pitfalls

Building a system like Kanbots involves managing several complex interactions. As we progress, we’ll discuss strategies for:

Managing Git Worktree State: Ensuring worktrees are correctly created, cleaned up, and switched without data loss or conflicts.
Agent Orchestration Complexity: Designing workflows that prevent deadlocks, manage concurrent agent actions, and handle unexpected outputs.
AI Agent Reliability: Addressing potential hallucinations, infinite loops, or API rate limits from AI models.
Security: Securely handling sensitive API keys and managing agent access to the local filesystem.
Performance: Optimizing frequent Git operations and AI API calls to maintain a responsive application.
Debugging: Strategies for debugging distributed logic across the frontend, Rust backend, and multiple AI agents.

This guide will provide practical solutions and best practices to navigate these challenges, ensuring you build a robust and functional application. Let’s get started on bringing your AI-powered development assistant to life.

References

This page is AI-assisted and reviewed. It references official documentation and recognized resources where relevant.