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
| Feature | What it does |
|---|---|
| Kanban per repo | Agents claim cards, ask questions on them, and hand off work with the PR, the CI build and screenshots |
| Approval gate | A card waits in Human Check until you approve it; with CI wired in, the Approve button also waits for green checks |
| Supervision from the browser | Launch agents in tmux, see which session waits on a permission prompt, answer it from the card |
| Today page | Commits, merged PRs, a year heatmap, dirty and unpushed repos — read from git and GitHub, never from a model |
| Daily report | A local LLM writes the prose, the server computes every number. Like a performance review, except accurate |
| GitHub network | What the people you follow starred and followed, plus your github.com feed, summarised |
The kanban board
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
| Who | Can |
|---|---|
| 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 you | only through kanban_ask: the card keeps its column, is flagged as waiting for you, and the options become buttons |
| Agent → Human Check | only 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 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 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
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
| Tool | Does |
|---|---|
whats_new | that day’s reports, commits per repo since midnight, dirty and unpushed repos |
list_projects · project | repos with branch, last commit and window counts |
daily_facts | the 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
- No fallbacks. A missing env or config key stops the boot. A failed scan or GitHub read is shown next to the last good one, never replaced by a guess.
- Unknown is not zero. A value the server could not read shows
—, never 0. - Numbers come from the server. Reports and pages show computed figures; a model never counts.
- Agents never approve their own work.
kanban_*has no approve tool. - A deployment is configuration, never code. One place per value; an unknown or missing key is an error.
Not for
- Teams. One operator; there are no roles beyond operator and agent.
- Non-Linux machines. The launcher drives tmux, confirms sessions through
/proc, and types only into Claude Code panes. - Repos spread over many machines. The scanner reads one directory tree on the box it runs on.
- The public internet without auth.
provider: noneis for localhost; a public deployment needs an auth provider you write. The MCP endpoint stays local, always.
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.
Related
- How I reached 100 quality PRs a day with an agents kanban — the process busyyaks runs.
- How I manage teams of coding agents on a private project locally — the board before it was open source.
- broker_parrot — a self-hosted job fleet on the database you already run — another self-hosted tool from the same box.
Try it, break it, roast it: github.com/robertziel/busyyaks.