kataban.app · Download · Docs · Releases

Kataban

A native macOS kanban board where every card is an AI agent session. Review the plan, then run Claude Code, Codex, or OpenCode in parallel on separate git worktrees.

Move a card into a column and Kataban starts an agent on it inside your project folder. The plan, the files it touched, the session transcript, and the resulting changes all stay attached to that card.

This is a showcase repo. Kataban is a commercial product and its source code is private. This page covers what it does, how it's built, and my role in building it.

What it does

• Uses the AI you already pay for. Kataban runs the real Claude Code, Codex, and OpenCode CLIs, so there's no extra AI fee, and your skills, MCP servers, and config come along.
• Configurable trust, phase by phase. Each column has its own permission mode, from "read the plan first" all the way to full autonomy.
• Run several agents at once without collisions. Every card gets its own git branch and worktree.
• Review everything before it ships. Comment on plans inline, then read every changed line before you stash, sync, or commit.
• Your board is an MCP server. Agents (or any MCP client) can read, create, and move cards, so one session can file follow-up work for the next.
• Multi-device sync and a web app (beta). Cards sync through the cloud, a second Mac can drive sessions running on another, and web.kataban.app shows the same board in a browser.

Feature tour

Plan review: read and comment on the plan before it runs.	Changes: review every line, then stash, sync, or commit.
Worktrees: every card gets its own branch and worktree.	Columns: hotkey, WIP limit, permission mode, and arrival prompt.
MCP: any MCP client can read and write your cards.	Files: browse and edit project files in a built-in editor.
Pinned tasks follow you across every project.	Projects: point Kataban at any local folder.

My role

Founder and lead engineer. I designed the product, set the architecture, and wrote the large majority of the codebase (about 89% of commits). That covers:

• the Rust agent session supervisor and the adapters for Claude Code, Codex, and OpenCode
• the local-first SQLite store and the sync engine
• the embedded MCP server
• the cloud backend, built on ProductBase, my own PocketBase product framework
• licensing and seat activation
• the desktop, web, and account portal frontends
• the marketing site and the product documentation

I build with AI coding agents (Claude Code, Codex) as a force multiplier. Once Kataban could run its own cards, I used it to plan, review, and ship its own features. The board in the screenshot above is Kataban's real backlog.

Team

• @remainstheday: release pipeline (TeamCity build chain, signing and notarization, Railway deploys), the app icon set, site contributions, and the YouTube series.

Engineering highlights

Agent session supervisor (Rust). Each card owns one supervised agent process, and its lifecycle follows the board: dropping a card into an active column starts or switches the session's mode, and an idle column stops it. Agents plug in through an AgentAdapter trait that covers both runtime shapes: a long-lived streaming process (Claude Code's stream-json) and one-process-per-turn CLIs resumed by session id (Codex, OpenCode). Stops are deferred until it's safe, so background subagents are never killed mid-task.

Local-first sync (beta). The desktop keeps a full SQLite replica and stays fully usable offline. A sync engine pushes every 5 s, pulls every 60 s, and listens for realtime updates over SSE. Before reconnecting it pulls from a checkpoint, so missed events replay exactly once. Writes carry a client op id so the app drops its own echoes; conflicts resolve last-write-wins; rows that fail back off individually instead of blocking the queue. A desktop without the project checked out can still drive agent sessions on a host machine through a durable input queue.

Embedded MCP server. A streamable-HTTP MCP server (axum) runs inside the app, bound to 127.0.0.1 with bearer-token auth, and exposes 20+ board tools. It calls the same repository layer as the UI, so a card an agent creates syncs exactly like one you typed, and destructive tools ask for confirmation in the app.

Git worktree isolation. Every card can run in its own worktree and branch, with afterClone and beforeRemove hook scripts. Board columns and settings can be checked into the repo as a kataban.json file, so a team shares one workflow.

Offline-verifiable licensing. License keys are ed25519-signed payloads, minted by the Go backend and verified offline by the Rust app against a public key built into the binary. Both sides test against the same cross-language fixtures. Purchase is a one-time Stripe checkout with no account required.

A deliberate security boundary. The frontend can only reach folders the user granted through the native folder picker, and a test enforces that the grant command takes no path argument. Paths are canonicalized and checked for symlink escapes, the Tauri asset protocol is disabled, and the capability and CSP settings are pinned by tests.

Release engineering. Developer ID signing and Apple notarization, minisign-signed auto-update manifests served from Cloudflare R2, separate prerelease and release channels, and Railway infrastructure declared as code. The in-app updater shows release notes for every version you skipped.

Architecture

flowchart LR
  subgraph Mac["Desktop app (Tauri 2)"]
    UI["React 19 UI"]
    Core["Rust core"]
    DB[("SQLite replica")]
    Agents["Claude Code / Codex / OpenCode CLIs"]
    MCP["MCP server (localhost)"]
    UI <-->|IPC| Core
    Core <--> DB
    Core -->|supervises| Agents
    Agents <-->|board tools| MCP
    MCP <--> Core
  end

  subgraph Cloud["Cloud"]
    PB["PocketBase + Go (ProductBase)"]
  end

  Web["Web app (beta)"]
  Accounts["Accounts portal"]
  Site["Marketing site + docs (VitePress)"]

  Core <-->|"push / pull / realtime sync (beta)"| PB
  Web <--> PB
  Accounts <--> PB
  PB -->|Stripe| Accounts

Loading

Tech stack

Layer	Tools
Desktop UI	React 19, TypeScript, Zustand, TanStack Query, Tailwind CSS 4, CodeMirror 6, xterm.js, dnd-kit, cmdk
Desktop core	Rust, Tauri 2, tokio, sqlx (SQLite), axum, reqwest, portable-pty, ed25519-dalek
Cloud	Go 1.25, PocketBase 0.38, Stripe, ProductBase
Web and accounts	React 19 SPAs on the PocketBase JS SDK
Site and docs	VitePress
Testing	Vitest, cargo test with wiremock, Go tests, Playwright end-to-end
Delivery	GitHub Actions, TeamCity, Railway, Cloudflare R2, Apple notarization

By the numbers

• 1,400+ commits in about five and a half months (May to October 2026)
• 85k+ lines of Rust, 265k+ lines of TypeScript, 34k+ lines of Go
• 9,000+ automated tests across Vitest, Rust, Go, and Playwright
• 225 Tauri IPC commands and 220 schema migrations across local SQLite and PocketBase
• 20 public releases, from 0.1.12 to 1.7

---

© 2026 Remains the Day LLC. All rights reserved. · kataban.app · ched.dev