Skip to content
Back to search

kanzo

Self-hosted kanban for humans and agents. One 4 MB binary, starts in 2 ms, zero setup.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/emanuele-em/kanzo with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/emanuele-em/kanzo'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/emanuele-em--kanzo/badge.svg)](/listings/emanuele-em--kanzo)

HTML

<a href="/listings/emanuele-em--kanzo"><img src="/api/listings/emanuele-em--kanzo/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

curl -LsSf https://github.com/emanuele-em/kanzo/releases/latest/download/kanzo-installer.sh | sh

For macOS and Linux, including every Raspberry Pi. Every release is signed by GitHub: check a download with `gh attestation verify <file> --repo emanuele-em/kanzo`. Or with Cargo:

cargo install kanzo

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 296 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="docs/img/kanzo-dark.jpg">
  4. <img alt="kanzo: a tiny kanban board for you and your coding agents" src="docs/img/kanzo-light.jpg">
  5. </picture>
  6. </p>
  7. <p align="center">
  8. <a href="https://github.com/emanuele-em/kanzo/actions/workflows/ci.yml"><img src="https://github.com/emanuele-em/kanzo/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  9. <a href="https://crates.io/crates/kanzo"><img src="https://img.shields.io/crates/v/kanzo" alt="crates.io"></a>
  10. <a href="LICENSE"><img src="https://img.shields.io/badge/license-AGPL--3.0-blue" alt="AGPL-3.0"></a>
  11. </p>
  12. <p align="center">
  13. English | <a href="README.zh.md">简体中文</a> | <a href="README.tr.md">Türkçe</a>
  14. </p>
  15. Kanzo is a kanban board in your browser and an MCP server in one 4.7 MB program, so you and your coding agents work on the same tasks: on one computer, or on one board shared by all of them. No account, no server, no setup: run `kanzo` and it works.
  16. You never edit a file. Everything is done in one of three places:
  17. - **the board**, in your browser, for you;
  18. - **MCP**, for your agents: they take tasks, move cards and comment;
  19. - **the `kanzo` command**, for the terminal and scripts.
  20. <picture>
  21. <source media="(prefers-color-scheme: dark)" srcset="docs/img/board-dark.gif">
  22. <img alt="The Kanzo board: agents move cards while you watch, ⌘K finds a task in any project, a task is made to wait on another, two selected tasks are dragged together, a list groups the tasks by status, the sidebar folds, Laptop A shares the board and Laptop B joins it" src="docs/img/board-light.gif">
  23. </picture>
  24. ## Install
  25. > [!TIP]
  26. > **Just ask your agent:** *"install Kanzo from github.com/emanuele-em/kanzo."*
  27. ```sh
  28. curl -LsSf https://github.com/emanuele-em/kanzo/releases/latest/download/kanzo-installer.sh | sh
  29. ```
  30. For macOS and Linux, including every Raspberry Pi. On Windows, in PowerShell:
  31. ```powershell
  32. powershell -ExecutionPolicy Bypass -c "irm https://github.com/emanuele-em/kanzo/releases/latest/download/kanzo-installer.ps1 | iex"
  33. ```
  34. Both add Kanzo to your `PATH`, for terminals you open from then on. To use it in the one you installed from, run `source $HOME/.cargo/env` (`env.fish` in fish), or open a new one.
  35. Or download the Windows zip from the [latest release](https://github.com/emanuele-em/kanzo/releases/latest) and put `kanzo.exe` in a folder named `bin` on your `PATH`, like `%USERPROFILE%\.cargo\bin`: the board updates itself only there.
  36. Every release is signed by GitHub: check a download with `gh attestation verify <file> --repo emanuele-em/kanzo`. Or with Cargo:
  37. ```sh
  38. cargo install kanzo
  39. ```
  40. ## Start
  41. > [!TIP]
  42. > **Just ask your agent:** *"start Kanzo and keep it running at login."*
  43. ```sh
  44. kanzo
  45. ```
  46. The board opens at http://localhost:4242. That's all the setup there is: the first run creates `~/kanzo`, and the whole board lives in it.
  47. | Key | Does |
  48. | --- | --- |
  49. | `n` | New task |
  50. | `/` or `⌘K` | Search every project |
  51. | `f` | Filter the board; `↵` keeps the filter |
  52. | `Tab` | Move to the description |
  53. | `⌘↵` | Save and close |
  54. | `Esc` | Keep what you typed in a description or tags; cancel other fields |
  55. ## Use the board
  56. > [!TIP]
  57. > **Just ask your agent:** *"mark kanzo#12 as human, and set its URL to github.com/acme/api/pull/482."*
  58. - **Select tasks:** `⌘`-click them, or drag on empty board space, then move, tag or delete them together. Drag one and the rest follow.
  59. - **List view:** the list icon shows the same tasks as rows to sort and group.
  60. - **Human tasks:** mark a task Human and agents leave it to you. The person icon shows only those.
  61. - **Images:** paste or drop one into a task or a comment.
  62. - **Links:** give a task a URL, like its pull request, and open it from its card. Agents set it with `url`.
  63. - **Files:** `[name](file:///path)` in a description or comment opens in your editor.
  64. - **Task panel:** drag its left edge to resize it, or expand it to the whole window. Double-click the edge to reset it.
  65. - **Sidebar:** the panel button beside search folds it to its icons. Drag a project to reorder the list, for everyone on a shared board.
  66. - **App:** in Chrome or Edge, **Install app** at the bottom of the sidebar makes the board an app of its own. `⌘1`–`⌘8` pick a project, `⌘9` the last one, `⌘0` all of them. On macOS, `kanzo` then opens it instead of a tab, on the default port.
  67. - **Updates:** when a new version is out, the sidebar offers it. One click installs it.
  68. ## Connect your agents
  69. > [!TIP]
  70. > **Just ask your agent:** *"add Kanzo as your MCP server,"* then restart it.
  71. ```sh
  72. claude mcp add kanzo --scope user -- kanzo mcp # Claude Code
  73. codex mcp add kanzo -- kanzo mcp # Codex
  74. ```
  75. Other MCP clients: run `kanzo mcp` (apps like Raycast need the full path, from `which kanzo`), or use the running board at `http://localhost:4242/mcp`.
  76. Then ask: *"take the next task from kanzo and do it."* The agent:
  77. - finds the project from the git remote of its repo; link more repos from the project's ⋯ menu;
  78. - moves the card to `doing` and comments as it works;
  79. - on `review`, comments how to resume its session.
  80. <picture>
  81. <source media="(prefers-color-scheme: dark)" srcset="docs/img/task-dark.jpg">
  82. <img alt="A task open on the board, with Claude Code's comments, one saying how to resume its session, and a reply" src="docs/img/task-light.jpg">
  83. </picture>
  84. ## Park ideas in a backlog
  85. Turn on Backlog in Settings for a column agents leave alone, until you move its tasks to `todo`.
  86. <picture>
  87. <source media="(prefers-color-scheme: dark)" srcset="docs/img/backlog-dark.jpg">
  88. <img alt="The board with the Backlog column on, left of Todo" src="docs/img/backlog-light.jpg">
  89. </picture>
  90. ## Make a task wait on others
  91. > [!TIP]
  92. > **Just ask your agent:** *"make kanzo#12 wait on #10 and #11."*
  93. - **Set it:** type in Waits on, in a task's panel, to find tasks in its project and pick them. Agents pass `waits_on`.
  94. - **Until those tasks are done:** `next_task` skips it, and its card is dimmed and says what it waits on. You can still move it yourself.
  95. - **What counts:** only `done`. A task in `review` still blocks.
  96. - **Find them:** filter by `is:waiting`.
  97. <picture>
  98. <source media="(prefers-color-scheme: dark)" srcset="docs/img/waits-dark.jpg">
  99. <img alt="A task's panel with log typed in Waits on, offering two tasks to pick, beside a dimmed card that says Waits on #7" src="docs/img/waits-light.jpg">
  100. </picture>
  101. ## Filter and search
  102. > [!TIP]
  103. > **Just ask your agent:** *"take the next kanzo task tagged billing,"* or *"list what's left in kanzo with tag:billing."*
  104. The board's filter (`f`), search (`/`) and the `filter` of `list_tasks` and `next_task` all understand the same words, like on GitHub:
  105. - Every part must match.
  106. - `-` negates a qualifier: `tag:billing -status:done`.
  107. - Qualifiers turn blue as you type them.
  108. <picture>
  109. <source media="(prefers-color-scheme: dark)" srcset="docs/img/filter-dark.jpg">
  110. <img alt="The board filtered by a saved tag:backend chip and is:waiting in the filter box, with the two matching tasks, each saying what it waits on" src="docs/img/filter-light.jpg">
  111. </picture>
  112. | Qualifier | Finds | Example |
  113. | --- | --- | --- |
  114. | `tag:` | that exact tag | `tag:bug`, `tag:"needs review"` |
  115. | `status:` | a column | `status:doing` |
  116. | `project:` | a project | `project:api` |
  117. | `title:`, `description:`, `url:`, `comment:` | text in that field | `title:login`, `comment:"on hold"` |
  118. | `id:`, `comments:`, `images:` | a number, or a range | `id:12`, `comments:>2`, `images:1..3` |
  119. | `created:`, `updated:` | a date, or a range | `created:2026-11-05`, `updated:<2026-01-31` |
  120. | `is:human` | tasks for you, not agents | `-is:human` |
  121. | `is:waiting` | tasks waiting on unfinished ones | `-is:waiting` |
  122. | `has:`, `no:` | `description`, `tags`, `url`, `comments` or `images` | `has:url`, `no:tags` |
  123. Anything else is plain text. Use quotes for a phrase, `"on hold"`, or to look for text that reads like a qualifier, `"tag:bug"`. Agents can't filter through a property you've hidden in Settings.
  124. ## Use it on several computers
  125. Two ways, neither with any setup: share one board live, or sync it between machines.
  126. ### Share it live
  127. > [!TIP]
  128. > **Just ask your agent:** *"share my Kanzo board"* on one computer, and *"join the Kanzo board at 192.168.1.20"* on the others.
  129. Several computers, one board, at the same time: everyone sees the same tasks, and every agent works on them.
  130. 1. On the computer with the board, click the share icon next to New task and turn on **Share this board**. Copy an address it shows.
  131. <picture>
  132. <source media="(prefers-color-scheme: dark)" srcset="docs/img/share-dark.jpg">
  133. <img alt="The share popover on the computer with the board: sharing is on, with its addresses to copy and the computers connected" src="docs/img/share-light.jpg">
  134. </picture>
  135. 2. On each other computer, click the share icon, paste the address and click **Join**.
  136. <picture>
  137. <source media="(prefers-color-scheme: dark)" srcset="docs/img/join-dark.jpg">
  138. <img alt="The share popover on another computer: connected to the shared board, with a Leave button" src="docs/img/join-light.jpg">
  139. </picture>
  140. Nothing restarts and nothing needs configuring. Their board shows the shared one, and their agents use it through the same `kanzo mcp`, still finding the project from the repo they work in. Turn sharing off, or click **Leave**, at any time.
  141. From a terminal, or for an agent, it's `kanzo share on` and `kanzo join <address>`, then `kanzo share off` and `kanzo leave`.
  142. The same two commands work wherever the board lives; only the address changes:
  143. **Your computer shares its board.** Others join it from theirs, on the same network.
  144. ```mermaid
  145. flowchart LR
  146. B["💻 Laptop B<br><code>kanzo#nbsp;join#nbsp;192.168.1.20</code>"] -- home network --> A["💻 Laptop A<br><i>192.168.1.20</i><br><code>kanzo#nbsp;share#nbsp;on</code>"]
  147. ```
  148. **A Raspberry Pi keeps the board.** Every computer joins it, and none has to stay on.
  149. ```mermaid
  150. flowchart LR
  151. A["💻 Laptop A<br><code>kanzo#nbsp;join#nbsp;192.168.1.50</code>"] -- home network --> pi["🍓 Raspberry Pi<br><i>192.168.1.50</i><br><code>kanzo#nbsp;share#nbsp;on</code>"]
  152. B["💻 Laptop B<br><code>kanzo#nbsp;join#nbsp;192.168.1.50</code>"] -- home network --> pi
  153. ```
  154. **The Raspberry Pi is somewhere else, over the internet.** Put a VPN on the Pi and on each computer, like [Tailscale](https://tailscale.com), [NetBird](https://netbird.io) or WireGuard: `kanzo share on` then shows the Pi's VPN address too.
  155. ```mermaid
  156. flowchart LR
  157. A["💻 Laptop A<br><code>kanzo#nbsp;join#nbsp;100.101.32.7</code>"] -- VPN --> net(("🌐 Internet"))
  158. B["💻 Laptop B<br><code>kanzo#nbsp;join#nbsp;100.101.32.7</code>"] -- VPN --> net
  159. net -- VPN --> pi["🍓 Raspberry Pi<br><i>100.101.32.7</i><br><code>kanzo#nbsp;share#nbsp;on</code>"]
  160. ```
  161. On a Pi, `kanzo service install` keeps the board running after a restart. There are no logins: share only on a network you trust.
  162. ### Sync it between machines
  163. > [!TIP]
  164. > **Just ask your agent:** *"sync my Kanzo board,"* or the first time, *"set up Kanzo sync with github.com/you/kanzo-data."*
  165. To carry the board between machines you use one at a time, a private git repo you own keeps it in step.
  166. 1. [Create an empty private repo](https://github.com/new?name=kanzo-data&visibility=private) on GitHub, or anywhere git can push.
  167. 2. Click Settings at the bottom of the sidebar, choose Sync and paste its URL. Kanzo makes `~/kanzo` a git repo and pushes the board.
  168. 3. On each other machine, do the same with the same URL: Kanzo offers to use the board that's already there.
  169. From then on, choose Sync, or run `kanzo sync`, when you switch machines. It commits the board and pulls or pushes it, and it's safe while the board and your agents are running. If both machines changed the board, Kanzo asks which one to keep. To move to another repo, change it in Settings, under Sync.
  170. ## Commands
  171. | Command | Does |
  172. | --- | --- |
  173. | `kanzo` | Starts the board at http://localhost:4242 and opens it; `--port` for another port, `--no-open` to not open it |
  174. | `kanzo service install` | Keeps the board running and starts it at login; `uninstall` removes it |
  175. | `kanzo mcp` | The MCP server for agents: they start it, not you |
  176. | `kanzo share on` | Shares the board with the other computers on your network; `off` stops, while the board keeps running |
  177. | `kanzo join <ip>` | Uses the board another computer shares, from this one's board and agents; `kanzo leave` goes back |
  178. | `kanzo sync` | Commits the board and pulls or pushes it; `--repo <url>` sets the repo, `--keep-local` or `--keep-remote` when both sides changed |
  179. | `kanzo export` | Prints the board as Markdown; `-f json` for JSON, `-p <project>` for one project, `-o <file>` to save it |
  180. | `kanzo update` | Installs the latest release and restarts the board's service; the board offers new versions too |
  181. | `kanzo init` | Creates the data folder; the first run does this too |
  182. | `kanzo --version` | Prints the version |
  183. Every command takes `--home <dir>` to use another data folder.
  184. ## Settings
  185. > [!TIP]
  186. > **Just ask your agent:** *"run Kanzo on port 4300."*
  187. Everything lives in `~/kanzo`: the board in `kanzo.db`, settings in `config.toml`. You never need to open either; use another folder with `--home` or `KANZO_HOME`.
  188. ```toml
  189. port = 4242
  190. listen = "127.0.0.1" # sharing opens the board to your network; "0.0.0.0" keeps it open
  191. mcp_http = true # MCP at /mcp
  192. editor = "/usr/local/bin/cursor" # opens file:/// links; on macOS, your text editor without it
  193. ```
  194. These settings stay on each machine: `kanzo sync` leaves them out.
  195. Settings on the board:
  196. - **Task properties:** turn one off, like tags or comments, to hide it there and leave it out of what agents get. Nothing is deleted.
  197. - **Language:** English or Chinese, under Board.
  198. - **Theme:** system, light or dark, under Board.
  199. - **What's new:** this version's notes, under About.
  200. ## Small and fast
  201. | | |
  202. | --- | --- |
  203. | Program | 4.7 MB, SQLite included |
  204. | Memory | 5 MB idle, 12 MB with 3,000 tasks |
  205. | Start | 3 ms |
  206. | Board of 3,000 tasks | 17 ms to load in the browser |
  207. | Agents' tool list | about 1,000 tokens, once per session |
  208. | Agents' replies | 10 to 60 tokens of plain text |
  209. Measured on an Apple M4.
  210. ## License
  211. [AGPL-3.0](LICENSE): use it, change it and share it; if you offer a changed version over a network, share its source too. To help, see [CONTRIBUTING](.github/CONTRIBUTING.md).
  212. <sub>mcp-name: io.github.emanuele-em/kanzo</sub>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.