AI · Desktop Application

Agentic Project Management

A desktop app that orchestrates autonomous AI agents to plan, decompose, and execute software development work — bridging high-level thinking and hands-on execution.

Role Solo Creator

Stack React, Tauri (Rust), SQLite

AI Claude CLI + MCP + ACP

Status In Development

agent_runner.rs

// Spawn Claude CLI and stream output
pub async fn spawn_agent(
    config: &AgentConfig,
    prompt: &str,
    session_id: Option<String>,
) -> Result<AgentHandle> {
    let mut cmd = Command::new("claude");
    cmd.arg("--output-format")
       .arg("stream-json");

    // Stream events to frontend
    app.emit("agent-output", &event)?;
}

01 — Overview

What is AgentBoard?

AgentBoard is a cross-platform desktop application that lets you plan complex software features with AI, then watch autonomous agents execute the work. It combines a Kanban board, an AI planning assistant, and an execution engine into a single interface — connected by a custom Agent Communication Protocol (ACP) designed specifically for agentic project management.

You describe a feature at a high level. The PM agent decomposes it into boards, tickets, and execution waves with dependency mapping. You review and approve. Then developer, architect, and reviewer agents autonomously execute the work — writing code, reviewing changes, and tracking progress in real time.

02 — The Problem

AI coding without orchestration

AI coding assistants are powerful, but they operate in isolation. You prompt one agent for one task, copy context manually, and manage the overall plan in your head (or in a separate tool). There's no orchestration layer that connects high-level planning to autonomous execution.

Project management tools track what needs to be done. AI agents can do the work. But nothing connects the two — nothing that decomposes a feature into tasks, respects dependencies, assigns agents with the right roles, and orchestrates execution while you watch.

"The gap isn't AI capability — it's AI coordination."

03 — Genesis

From frustration to architecture

As a sole technical owner at Worlds, I managed every phase of development myself — planning, architecture, implementation, QA, and project management. I was already using AI assistants for individual tasks, but the overhead of orchestrating them was nearly as much work as doing it manually.

I wanted a system where I could think at the feature level — describe what I wanted — and have AI agents handle the decomposition, dependency mapping, and execution. Not a chat interface. A proper project management tool that happens to have agents built in.

04 — The Planning Flow

Structured AI planning

The core innovation is a structured AI planning session that transforms high-level feature ideas into executable work plans — mimicking real-world software development cycles but with agents. The system minimizes overlap and conflicts by decomposing scope into logical work groups, mapping dependencies, and orchestrating execution in waves.

Each planning session walks through structured steps: scope decomposition, task generation, dependency mapping, architecture review, and orchestrated execution. The result is a fully populated Kanban board with tickets assigned to agents and ready to run — all from a single feature description.

"The same discipline that makes a well-run sprint work for a human team — clear scope, dependency awareness, phased execution — makes agents dramatically more effective."

05 — Architecture

React + Rust + AI subprocess orchestration

AgentBoard is a Tauri desktop application — React on the frontend, Rust on the backend. The Rust layer handles subprocess management, database operations, and event streaming. Agents run as Claude CLI subprocesses, communicating via JSON streaming and Tauri events.

Frontend

React 19 + TypeScript

Backend

Tauri 2 (Rust)

Database

SQLite (embedded)

State

Zustand (7 stores)

AI Runtime

Claude CLI (subprocess)

Tool Protocol

MCP + ACP

Styling

Tailwind CSS

Routing

React Router 7

06 — Key Features

What makes it work

Multi-Agent Roles

Create agents with distinct roles — Developer, Architect, Reviewer, PM — each with role-specific prompts and configurable model selection (Sonnet or Opus).

Live Execution Monitoring

Real-time terminal output from every agent. A persistent execution bar shows wave/phase progress, agent status, and activity feed across the entire app.

Session Continuity

Agents maintain conversation context across messages. Send follow-up prompts to a running agent without losing prior context — full session resume via Claude CLI.

Quick PM Widget

A floating, draggable chat overlay available from any screen — minimizes to a 56px bubble, expands to a full planning card. Create tickets and update boards without leaving your current view.

Draft/Live Isolation

Planning creates draft boards and tickets that never pollute the Kanban until approved. On execution launch, drafts flip to live — clean separation between planning and reality.

Vibe Mode

Auto-approval mode that runs through all 6 planning steps autonomously. Describe a feature, hit go, and the PM agent plans everything without interruption.

07 — Deep Dive: Agent Subprocess Management

The hardest part

The most technically challenging aspect of AgentBoard is the subprocess orchestration layer in Rust. The system spawns Claude CLI as child processes, streams their JSON output line-by-line via async Tokio tasks, parses text blocks, content deltas, and tool calls, and emits typed events to the React frontend via Tauri's event system.

Each agent's session ID is persisted in SQLite, enabling conversation resume across multiple interactions. The MCP server exposes board/ticket manipulation tools directly to agents — planning tools for PM/Architect agents, execution tools for all roles — with environment variables plumbing the right context (session ID, agent ID, ticket ID) into each subprocess.

Error resilience is built-in: CLI not on PATH, process crashes, stale sessions, and duplicate agent starts are all handled gracefully with meaningful error messages in the UI.

08 — Agent Communication Protocol

ACP — built for this problem

Existing protocols like MCP are designed for tool access — giving an AI model the ability to call functions. But orchestrating multiple agents working on interdependent tasks requires something more: awareness of board state, ticket ownership, execution phase, and cross-agent coordination.

ACP (Agent Communication Protocol) evolved from the specific needs of agentic project management. It defines how agents read and write to the shared project state, how planning-mode tools differ from execution-mode tools, and how context (session ID, agent role, current ticket) flows into each subprocess. Planning tools create draft data that stays isolated until approved; execution tools operate on live state with dependency-aware sequencing.

Rather than adopting a generic protocol and bending it to fit, ACP was designed from the ground up for the specific communication patterns that emerge when AI agents collaborate on structured work — and it continues to evolve as the tool matures.

09 — Why It Matters

The future of development workflows

AgentBoard represents a bet that the future of software development isn't individual AI assistants — it's orchestrated AI teams. The tool doesn't replace engineers. It gives them a way to think at a higher level while autonomous agents handle the structured decomposition and execution.

This project pushed me across every discipline I care about: Rust systems programming, React state management, real-time event architectures, AI integration, and desktop application design. It's the most technically ambitious thing I've built.