busyyaks: self-hosted kanban for Claude Code

My agent agency merged 100 PRs in one day. I built them a kanban board so I can micro-manage them like a real boss. Now you can become one too :)

busyyaks is that board: an open-source, self-hosted kanban board for Claude Code agents. It watches every git repo under one directory, gives each repo a board, and lets Claude Code sessions work those boards through an MCP server. You read the board, answer questions on cards, and approve. Nothing merges without you.

Status: early stage, Apache-2.0, built for one operator on one Linux box. Roasts welcome on GitHub.

How I run it to 100 merged PRs a day — the backlog, the team leads, the ticket workflow — is in How I reached 100 quality PRs a day with an agents kanban. This post is the product: what you get, how it runs, and how to start.

What you get: boss features

FeatureWhat it does
Kanban per repoAgents claim cards, ask questions on them, and hand off work with the PR, the CI build and screenshots
Approval gateA card waits in Human Check until you approve it; with CI wired in, the Approve button also waits for green checks
Supervision from the browserLaunch agents in tmux, see which session waits on a permission prompt, answer it from the card
Today pageCommits, merged PRs, a year heatmap, dirty and unpushed repos — read from git and GitHub, never from a model
Daily reportA local LLM writes the prose, the server computes every number. Like a performance review, except accurate
GitHub networkWhat the people you follow starred and followed, plus your github.com feed, summarised

The kanban board

The busyyaks board for the demo repo acme/storefront: the launch bar with Launch, Worker, Sub team and Plain buttons and four running tmux sessions (team, teamlead, worker, worker_2) with iTerm, Terminal and Stop links; column counts Backlog 2, To do 1, In progress 3, QA 1, Human Check 1, Ready to merge 0, Merged 2 and 2 waiting for you; cards each showing the session that owns them, one in progress carrying a question with 3 choices; and the Agents sidebar with 4 sessions, 1 needing input and 1 in PR review.

Every repo gets a board. It works like Trello — drag and drop, labels, checklists, due dates, Trello-style keyboard shortcuts (?) — and agents use the same cards you do, so there is no second tracker to keep in sync.

The default columns are Backlog → To do → In progress → QA → Human Check → Ready to merge → Merged. Columns, their types and the named transitions between them are rows in the database; you edit them in a graph editor (the board’s Workflow button).

Nothing merges without your approval

A card's life on the default busyyaks board: Backlog, To do, In progress, QA, Human Check, Ready to merge, Merged. Prioritise, Start work, Send for QA and Fixes needed out of QA may be taken by an agent or the operator. Hand over (kanban_handoff, from In progress or QA into Human Check) is taken by agents only. Approve (Human Check to Ready to merge) is taken by the operator only, and so is Fixes needed out of Human Check, because an agent leaves a gate only after approval. Merge (Ready to merge to Merged) is open to both, to an agent only once the card is approved. Not drawn: a catch-all Move from any column to any column, by anyone. A card's life on the default board named transitions, coloured by who may take them Hand over · kanban_handoff · QA is optional Fixes needed Prioritise Start work Send for QA Approve Merge only you Backlogparked To doqueued In progressworking QAreview Human Checkgate Ready to mergegate Mergeddone an agent or youagents onlyonly younot drawn: the catch-all Move (* → *, by any) · an agent leaves a gate only once you approved
The default board. Pick a stage, or hover a column or an arrow (tap on a phone).
A card's life on the default busyyaks board: Backlog, To do, In progress, QA, Human Check, Ready to merge, Merged. Prioritise, Start work, Send for QA and Fixes needed out of QA may be taken by an agent or the operator. Hand over (kanban_handoff, from In progress or QA into Human Check) is taken by agents only. Approve (Human Check to Ready to merge) is taken by the operator only, and so is Fixes needed out of Human Check, because an agent leaves a gate only after approval. Merge (Ready to merge to Merged) is open to both, to an agent only once the card is approved. Not drawn: a catch-all Move from any column to any column, by anyone. A card's life on the default board transitions, coloured by who may take them Hand over · QA is optional Fixes needed Prioritise Start work Send for QA Hand over Approve · only you Merge Backlogparked To doqueued In progressworking QAreview Human Checkgate Ready to mergegate Mergeddone an agent or youagents onlyonly younot drawn: the catch-all Move (* → *, by any)an agent leaves a gate only once you approved
The default board. Pick a stage, or hover a column or an arrow (tap on a phone).
WhoCan
Agent (MCP)create and claim cards, comment, attach files, move cards between the working columns; after approval, merge the PR and move the card to Merged
Agent asks youonly through kanban_ask: the card keeps its column, is flagged as waiting for you, and the options become buttons
Agent → Human Checkonly through kanban_handoff with the QA steps and the PR URL (the CI URL too once you set requires_ci_url); a UI change is refused without screenshots
You (web)everything, and you are the only one who moves a card out of Human Check into Ready to merge

With approval: { requires_green_ci: true } the Approve button (and the named Approve transition) is refused until the PR’s checks are green. Dragging the card into Ready to merge still approves it, logged as dragged: CI not asked.

Sessions own cards

A lead adopts the cards that wait for you, a worker is spawned for an ownerless card in a working column, and a sub team runs alongside the lead. Your comments, moves and answers are typed straight into the owner’s tmux session, so agents end their turn and wait instead of polling. When nobody is listening, the card says so.

A card

A busyyaks card opened: Typo-tolerant product search in progress on acme/storefront, owned by the session acme_storefront_worker; a description, a Steps checklist at 50 percent, the activity log with each comment, checklist tick and move the agent made with timestamps, and the owner session panel with its model and iTerm and Terminal links.

A card carries the checklist, every move and comment with who made it, the PRs assigned to it, and the session its comments are typed into. The board knows a card’s PRs only from explicit assignments (kanban_pr_assign), never from branch names, so the CI checks it gates on are the right ones.

The Today page

The busyyaks Today page with demo data: tiles for 13 commits today, 10 of them mine, 5 repos and 3 PRs merged, each with a 7-day sparkline; a year commit heatmap of 791 commits; a Daily 7d table of commits, own commits, repos and PRs per day; the list of 21 merged PRs in 7 days across the acme repos; and the Agents sidebar.

The numbers come from the scanner’s git reads and from GitHub, never from a model. A day the PR search did not cover shows —, never 0: unknown is not zero.

The daily report

Optional. bin/daily-report runs on the host from a systemd timer and starts a runner (today: Hermes) whose only tools are the busyyaks MCP server and read-only git log / git status. The model writes the prose; every figure comes from daily_facts, and check_report rejects a draft that names repos, people or events the server does not know. If your LLM gateway is down there is no report (or one NOT RUN report after the cutoff) — never a stand-in model.

How it works

How busyyaks runs: the browser reaches the web container with a session cookie; Claude Code sessions in tmux reach the mcp container with a bearer token; web, notifier, mcp, scanner and github run in docker compose over one database (a SQLite file or PostgreSQL); web, notifier and mcp reach bin/launcher on the host through a unix socket, and the launcher starts the tmux sessions and types into them; scanner reads the git repos through a read-only mount and github reads the GitHub API with a read-only token. How busyyaks runs 5 containers · 1 database · 1 launcher on the host docker compose 5 containers · every port binds to 127.0.0.1 session cookie unix socket bearer token libgit2 read-only token Youbrowser bin/launcheron the host Claude Codesessions in tmux your reposread-only mount GitHub APIPRs · checks webSPA + /api JSON notifierpings · watchdog mcpMCP · local only scannergit log · status githubPRs · feed one databasea SQLite file by default, or PostgreSQL · every service reads and writes it you and the datathe agents' pathnot drawn: the optional bin/daily-report timer
How busyyaks runs. Pick a path, or hover a box or a wire (tap on a phone) to see what it does.
How busyyaks runs: the browser reaches the web container with a session cookie; Claude Code sessions in tmux reach the mcp container with a bearer token; web, notifier, mcp, scanner and github run in docker compose over one database (a SQLite file or PostgreSQL); web, notifier and mcp reach bin/launcher on the host through a unix socket, and the launcher starts the tmux sessions and types into them; scanner reads the git repos through a read-only mount and github reads the GitHub API with a read-only token. How busyyaks runs 5 containers · 1 database · 1 host launcher cookie unix socket bearer libgit2 token Youbrowser bin/launcheron the host Claude Codetmux sessions webSPA + API notifierpings mcplocal only one databaseSQLite or PostgreSQL scannergit reads githubPRs · feed docker compose 5 containers your reposread-only GitHub APIread-only you · dataagents
How busyyaks runs. Pick a path, or hover a box or a wire (tap on a phone) to see what it does.

Five Docker containers (web, mcp, scanner, github, notifier) plus two host processes (bin/launcher and the optional bin/daily-report timer), over one database: a SQLite file by default, or PostgreSQL. The launcher runs on the host because containers cannot reach the host’s tmux. The board itself is a separate module, busyyaks_agents_kanban_module, vendored into busyyaks so other projects can ingest it too.

Stack: Ruby 3.4 · Hanami 2.3 · Sequel on SQLite or PostgreSQL · React 18 + TypeScript + Vite · an MCP server for Claude Code · Docker Compose.

MCP tools for Claude Code

ToolDoes
whats_newthat day’s reports, commits per repo since midnight, dirty and unpushed repos
list_projects · projectrepos with branch, last commit and window counts
daily_factsthe daily report’s numbers, computed by the server
kanban_* (32 tools)the board: kanban_board, kanban_card, kanban_create, kanban_claim, kanban_comment, kanban_ask, kanban_pr_assign, kanban_handoff, kanban_move, kanban_workflow, labels, checklists, due dates, attachments

The server’s instructions tell an agent how to behave: claim before working, ask on the card instead of in chat, hand off with kanban_handoff, never poll.

Quickstart

You need Linux, Docker with the compose plugin, openssl, Ruby 3.x (for bin/env, the one .env reader) and a directory of git repos. The launcher also needs git, tmux, the claude CLI and a systemd user manager. GITHUB_TOKEN is any read-only token; the block below reads it with the GitHub CLI.

git clone https://github.com/robertziel/busyyaks && cd busyyaks
cp .env.example .env
cp config/busyyaks.example.yml config/busyyaks.yml
cp config/kanban.example.yml config/kanban.yml

# secrets and the host user into .env
sed -i -e "s/^SESSION_SECRET=.*/SESSION_SECRET=$(openssl rand -hex 64)/" \
       -e "s/^MCP_TOKEN=.*/MCP_TOKEN=$(openssl rand -hex 32)/" \
       -e "s/^MCP_REPORT_TOKEN=.*/MCP_REPORT_TOKEN=$(openssl rand -hex 32)/" \
       -e "s/^GITHUB_TOKEN=.*/GITHUB_TOKEN=$(gh auth token)/" \
       -e "s/^HOST_UID=.*/HOST_UID=$(id -u)/" -e "s/^HOST_GID=.*/HOST_GID=$(id -g)/" .env
$EDITOR .env    # PROJECTS_ROOT, GITHUB_LOGIN, TZ, LAUNCHER_RUN_DIR (a persistent dir), the rest

mkdir -p data
vars=$(bin/env LAUNCHER_RUN_DIR) && eval "$vars" && mkdir -m 700 -p "$LAUNCHER_RUN_DIR"
docker compose up -d --build web mcp scanner github notifier

Open http://127.0.0.1:$WEB_HOST_PORT. Then connect Claude Code to the MCP server:

vars=$(bin/env MCP_HOST MCP_HOST_PORT MCP_TOKEN) && eval "$vars"
claude mcp add --transport http --scope user busyyaks "http://$MCP_HOST:$MCP_HOST_PORT/mcp" \
  --header "Authorization: Bearer $MCP_TOKEN"

and install the host launcher (a systemd --user unit):

deploy/install-launcher.sh

Without the launcher the dashboard, the scanner and MCP’s read tools work, but agents cannot register, claim, create or ask on cards.

The full setup — every .env key, the auth provider, the agent-session collector and the daily-report timer — is in the README. The repo also ships a prompt you can hand to a coding agent to set it up and get its tests green.

Design rules

Not for

FAQ

What is busyyaks?

An open-source (Apache-2.0), self-hosted web dashboard that runs a team of Claude Code agents from a kanban board per git repo. Agents work the board through MCP tools; you approve their work.

Can an agent merge without me?

No. An agent enters Human Check only with a handoff carrying the QA steps and the PR, and only you move a card from there to Ready to merge. The agent merges after that.

Does it work with agents other than Claude Code?

It is built for Claude Code. A launcher can also be of kind hermes, but comments and answers are typed only into Claude Code panes.

Does it need a cloud service?

busyyaks itself needs none: everything it runs is on your Linux box, in Docker. Two things still leave the box: the agents are Claude Code, which talks to Anthropic, and the github service reads GitHub with a read-only token. The optional daily report needs an OpenAI-compatible LLM gateway of your choice.

Why not Trello or GitHub Projects?

Those track work for people. busyyaks is the same kind of board plus the wiring agents need: MCP tools, a gate they cannot pass, and your replies typed into their tmux session.

Try it, break it, roast it: github.com/robertziel/busyyaks.

Questions? Let's Chat :)

open source