Skip to main content
Glama

Kanbini

CI License: MIT Jigglyy/kanbini MCP server

A kanban board that lives on your machine - and lets your AI move the cards. Offline-first. Plain text on disk. No cloud, no accounts, no telemetry.

Kanbini is a Trello-style kanban app built for one person and their AI. Your boards live in a local SQLite file and export to plain Markdown + JSON, so you own your data outright. A built-in local MCP server lets any AI that speaks MCP - Claude, ChatGPT, Cursor, or your own agent - read and rearrange your board while you watch the cards move in real time.

The pitch is simple: your tasks shouldn't need an internet connection, a login, or a monthly fee just to exist. Kanbini keeps your whole board in a local file you fully own, runs as a fast native app, and - when you want a hand - lets an AI pull up a chair and move the cards in real time while you watch.

The name mashes kanban with konbini, the Japanese corner store that never closes: a board that's yours, local, and always on.

Why Kanbini

  • Offline by default. No accounts, no network, no telemetry. The only things that ever leave your machine are the ones you explicitly turn on

    • link previews and one-way Obsidian export - both off by default.

  • You own your data. Everything is a local SQLite file with first-class, lossless plain-text export (Markdown + JSON), verified byte-identical by a round-trip test.

  • AI-native. A token-gated local MCP server exposes read/write tools; the AI's edits stream into the live UI as it works.

  • Free and open source under the MIT license.

Related MCP server: sanban

Screenshots

Agenda + all your boards

Card detail, with where the card lives

Boards home with the agenda

Card detail

Waiting on, comments (one from the AI) + activity

Right-click menus with fly-outs

Card comments and activity

Card menu with the Labels fly-out open

Select several cards, act on all of them

Ctrl+F search across every board

Multi-select with the bulk action bar

Command palette

Swimlanes - group by priority

Light theme

Swimlanes

The board in the light theme

Features

  • Boards, lists, cards with drag-and-drop (live cross-list reorder), labels, due dates, priorities, per-list colours, and swimlanes (group by priority).

  • Card depth - WYSIWYG description (saved as Markdown), checklists, comments, local attachments (paste an image straight in), cover images, and a per-card activity log. Cards with a description show a small marker in the list.

  • Long boards stay readable - each list scrolls on its own, a card can be collapsed to a one-line summary (or a whole list set to compact), and a list can show just its first 10 / 20 / 50 cards with a "Show more" button.

  • Multi-select - Ctrl/Cmd-click cards (or Shift-click for a range) to pick several at once, then complete, set priority, re-label, move, or delete them in bulk from a floating action bar (or a right-click menu) - and drag the whole group between lists.

  • Local MCP server - a token-gated 127.0.0.1 control channel + stdio server (@kanbini/mcp) with 30 read/write tools: cards, lists, boards, labels, comments, checklists, attachments, archiving, list settings (card limit, sort, colour, compact cards, how many to show), "waiting on" links, search, and a cross-board agenda. Edits stream into the open UI live. See docs/MCP.md.

  • Claude Code plugin - /plugin marketplace add Jigglyy/kanbini, then /plugin install kanbini@kanbini. Adds /kanbini:agenda, /kanbini:new-card, and /kanbini:log (write up this session's work as a finished card), and needs no token or path: it finds the Kanbini app you installed. See plugins/kanbini.

  • Scriptable HTTP API - the same token-gated 127.0.0.1 control channel is also a plain local HTTP API (REST routes for reads + writes, plus a batch endpoint that lands as one undo step) for non-MCP tools, scripts, and automation. Loopback only. See docs/MCP.md.

  • Own your data - lossless plain-text export/import (kanbini.json + cards/*.md + attachment files); Backup + Restore live in Settings.

  • Daily backups - a copy of everything once a day, the last 7 days kept, restorable in one click from Settings (and a copy of the current state is kept before any restore).

  • Move or copy cards between boards - labels follow by name.

  • Export a board to a file (.kanbini), with or without its cards, and import it as a new board on any Kanbini.

  • Cross-board search via a Ctrl/Cmd+F command palette.

  • Repeating cards - make a card repeat daily, weekly, monthly, yearly, or every N of those. Completing it adds the next one with its due date moved on, labels and checklist carried over (unticked).

  • Waiting on - mark that a card can't start until another is done, even one on a different board. The card shows "Blocked" until then.

  • Agenda on the home screen - what's overdue, due today, coming up this week, and recently completed, across every board. Tick a card off right there, or click it to jump to the card.

  • Templates for boards and lists.

  • Undo / redo with full snapshot restore on delete. One Ctrl+Z takes back everything an AI just changed on a board.

  • Customizable keyboard shortcuts.

  • Runs in the tray if you like - closing the window can keep Kanbini (and your AI tools' connection to it) running, with your recent boards one click away.

  • Board backgrounds (colour / gradient / image) and continuous zoom.

  • Trello import - bring an exported Trello board JSON in as a new board (boards home > Import board).

  • Opt-in integrations (off by default): link previews and one-way push to an Obsidian vault.

Install

Windows: the Releases page has three downloads (the "Source code" ones are for developers). All three use the same boards, in %APPDATA%\Kanbini.

  • Kanbini.Setup.X.Y.Z.exe installs Kanbini for your user (no admin rights needed) with a Start menu entry and an uninstaller. To update, run the newer installer.

  • Kanbini-X.Y.Z-win-x64-portable.zip is the portable folder: extract it anywhere and run Kanbini.exe inside. Nothing is installed and nothing goes in the registry. To update, replace the folder.

  • Kanbini-X.Y.Z-win-x64-portable-single-file.exe is the same portable app as one file: just run it. It unpacks itself into a temporary folder each time (so it takes a few seconds longer to open) and cleans that up when you close it. Connecting an AI to it needs Node.js installed.

Builds are unsigned, so Windows SmartScreen warns on the first run ("More info", then "Run anyway").

macOS: download Kanbini-X.Y.Z-mac-universal.dmg (one app for both Apple Silicon and Intel Macs), open it and drag Kanbini into Applications. The app isn't notarized by Apple, so the first launch is blocked with "Apple could not verify..." Click "Done", then go to System Settings → Privacy & Security, scroll down and click "Open Anyway". You only do this once. Boards live in ~/Library/Application Support/Kanbini.

Linux (x64): two downloads, both using the same boards in ~/.config/Kanbini.

  • Kanbini-X.Y.Z-linux-amd64.deb for Debian and Ubuntu: sudo apt install ./Kanbini-X.Y.Z-linux-amd64.deb. The best pick on Ubuntu 24.04 and newer, because it sets up the browser sandbox that release needs.

  • Kanbini-X.Y.Z-linux-x86_64.AppImage for any distro: chmod +x it and run it. Needs FUSE 2 (libfuse2). On Ubuntu 24.04 and newer, run it with --no-sandbox (or use the .deb). Connecting an AI to it needs Node.js installed.

Or run it from source:

pnpm install
pnpm --filter @kanbini/desktop dev

It opens on a seeded sample board. After a fresh clone or any Electron version bump, run the native rebuild once:

pnpm --filter @kanbini/desktop rebuild:native

To build it yourself, see docs/PACKAGING.md. Each platform builds on its own OS (Windows on Windows, the .dmg on a Mac, the AppImage + .deb on Linux or WSL2); the release workflow does all three on GitHub Actions and boots each packaged app before publishing. Windows is the platform used day to day; the macOS and Linux builds are newer, so please open an issue if something's off there.

Web edition (Docker)

To share boards with other people, run the web edition: the same app in a browser, served from a Docker container on a machine you control (a home server or NAS). It adds accounts, optional 2FA, and shared workspaces with viewer / editor / manager roles, and AI tools connect to it over HTTPS. It's separate from the desktop app, which stays offline and single-user. Setup, sign-in, workspaces and running it behind a reverse proxy are in apps/web/README.md.

Wire up an AI

The MCP server speaks the standard Model Context Protocol, so any MCP-capable client can drive your board while it's open. Claude Desktop and Claude Code are what we test against, but ChatGPT desktop, Cursor, or your own agent work the same way - one config shape covers them all. The snippet + token live in the app under Settings → AI integration; details in docs/MCP.md.

Develop

pnpm verify   # typecheck + unit tests + launch smoke (~20 s)
pnpm e2e      # Playwright end-to-end suite against the real Electron app

Exercise the MCP surface end-to-end (desktop app must be running):

pnpm --filter @kanbini/mcp run build         # one-time / after MCP changes
pnpm --filter @kanbini/mcp run smoke         # read-tool check
pnpm --filter @kanbini/mcp run smoke:write   # create → update → comment → checklist → delete

Prove the export/import round-trip is lossless (no live app needed):

pnpm --filter @kanbini/desktop run test:roundtrip

Layout

/apps
  /desktop      Electron main + hardened preload + control channel
  /renderer     React + Vite + Tailwind v4 + ShadCN
  /mcp          @kanbini/mcp - stdio MCP server
  /desktop-e2e  Playwright end-to-end suite
  /web          web edition: the app in a browser, for Docker
/packages
  /shared       zod schemas, channel names, id/order utils
  /db           Drizzle schema + migrations + data access
/docs           DESIGN.md, MCP.md, PACKAGING.md

Contributing

Issues and pull requests are welcome. pnpm verify should be green before you push. New features in @kanbini/shared, @kanbini/db, or @kanbini/renderer should land with tests in the same change; bug fixes should come with a regression test.

License

MIT © Jigglyy and Kanbini contributors.

Available Tools

42 tools
kanbini_add_attachmentAttach a file to a cardA

Attach a file to a card, from ONE of two sources. (1) path: an absolute path to a local file, which the app copies in (up to 100 MB) - use this for files that already exist on disk. (2) filename + content: inline data you produce yourself, as encoding: "utf8" text (the default - notes, CSV, code) or encoding: "base64" for small binaries (up to 10 MB decoded). The filename's extension sets the file type; unsafe characters are replaced. Returns the stored attachment ({ id, filename, mime, size, ... , boardId }). To show an image as the card's cover, pass the returned id as coverAttachmentId to kanbini_update_card. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: cardId (required), path, boardId, content, +2 more.

kanbini_add_blockerMark a card as waiting on anotherA

Record that card cardId waits on card blockerId (a "blocked by" link). The card shows as blocked in the app until the blocker is completed or archived. The two cards may be on different boards. Adding a link that already exists does nothing. Rejected when both are the same card, or when blockerId already waits on cardId directly or through other cards (that would make a loop). A card's links are in the blockedBy and blocking arrays of kanbini_get_card. The user can undo in the app. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on). Two numbers must both be on that board; for a blocker on another board, use its id.

Inputs: cardId (required), blockerId (required), boardId.

kanbini_add_checklist_itemAdd a checklist itemC

Append an item to an existing checklist. Returns { id, boardId }.

Inputs: text (required), checklistId (required).

kanbini_archive_boardArchive or restore a boardA

Archive (archived: true) or restore (archived: false) a board. An archived board is hidden from the home picker (the user can still reach it with "Show archived") and its cards drop out of search. Nothing is deleted. kanbini_list_boards still returns archived boards, flagged archived: true. id is the board id or its exact name.

Inputs: id (required), archived (required).

kanbini_archive_cardArchive or restore a cardA

Archive (archived: true) or restore (archived: false) a card. An archived card disappears from the board, search, and card counts but keeps its list, position, checklists, comments, and attachments, so restoring puts it back exactly where it was. Tell the user the card was archived rather than deleted: they can see and restore it in the app from the board's pencil menu > Archived..., and kanbini_list_archived finds it too. Prefer this over kanbini_delete_card when the user wants a card "out of the way". A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: id (required), archived (required), boardId.

kanbini_archive_listArchive or restore a listA

Archive (archived: true) or restore (archived: false) a whole list (column). An archived list is hidden from the board along with every card in it, and its cards drop out of search and counts; nothing is deleted, and restoring brings the list back in its original slot with its cards. Tell the user: they can see and restore it in the app from the board's pencil menu > Archived..., and kanbini_list_archived finds it too. A list can be given by its id, or by its exact name with boardId.

Inputs: id (required), archived (required), boardId.

kanbini_batchMake many changes at onceA

Apply many changes in ONE call, as one change: all of them land or none do, and one Ctrl+Z in the app takes them all back. Use it whenever you would otherwise call write tools several times (filling a board, tidying a list, moving or relabelling many cards). steps (up to 200) run in order; each is { op, ...arguments } where op is a write tool name without kanbini_ (create_card, update_card, move_card, set_card_labels, archive_card, create_list, create_label, post_comment, create_checklist, ...) and the arguments are exactly that tool's. boardId (id or name) is the default board for every step, so steps can name cards by number (#142) and lists / labels by name without repeating it; a step may still pass its own. A step that creates something can take ref: "name", and later steps use "$name" wherever an id goes, e.g. [{ op: "create_list", name: "Sprint 4", ref: "s4" }, { op: "create_card", listId: "$s4", title: "Plan" }]. Lists and labels a step creates can also be named by their name later on. Attachments are not available here. Returns { changes, steps: [{ step, op, id, ref? }] } with the id of what each step changed or made. A failing step is reported by number and nothing is changed.

Inputs: steps (required), boardId.

kanbini_copy_cardCopy a cardA

Make a copy of a card in any list, on this board or another one. The copy gets the title (or title), description, due date, priority, repeat rule, completion, labels (on another board: the label with the same name there, or a new one in the same colour), checklists with their ticks, and attachments. Comments, activity and "waiting on" links stay with the original. Position works like kanbini_move_card: beforeId is the card that will sit directly ABOVE the copy, afterId the one directly BELOW; omit both for the end of the list. So to put the copy right under the original, pass the original as beforeId. Returns { id, boardId } of the copy, which gets its own card number. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on). The list can be named too: on boardId, or on toBoardId for another board.

Inputs: id (required), toListId (required), title, afterId, +3 more.

kanbini_create_boardCreate a boardA

Create a new empty board (no lists, no cards). name is the required board title; description is an optional short blurb shown on the home picker. Returns { id, boardId } - both equal the new board's id. Add columns next with kanbini_create_list, then cards with kanbini_create_card (or all of it in one kanbini_batch).

Inputs: name (required), description.

kanbini_create_cardCreate a cardA

Create a card, complete in ONE call: title plus any of description (Markdown, with real line breaks), due (YYYY-MM-DD) or dueAt (epoch ms at local midnight), priority ('low' | 'medium' | 'high' | 'urgent'), labels (names or ids of labels on that board; make a missing one with kanbini_create_label), checklists ([{ name, items: [text, ...] }]), repeat, and completed. It goes at the end of the list unless you give beforeId (the card that will sit directly ABOVE it) or afterId (the card directly BELOW). Returns { id, boardId }. Respect a list's wipLimit: it is advisory and not enforced, so check the card count before adding when one is set. A list can be given by its id, or by its exact name with boardId. Labels by name and cards by number need boardId too.

Inputs: title (required), listId (required), due, dueAt, +9 more.

kanbini_create_checklistAdd a checklist to a cardA

Create a checklist on a card, with its items (texts, in order) in the same call. Returns { id, boardId }; add more later with kanbini_add_checklist_item. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: name (required), cardId (required), items, boardId.

kanbini_create_labelCreate a labelA

Create a new label on a board (boardId: id or name). Labels are board-scoped: put it on that board's cards by name or id. Check the board's labels first so you reuse an existing label instead of making a near-duplicate. Returns { id, boardId }. Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

Inputs: name (required), color (required), boardId (required).

kanbini_create_listCreate a list (column)A

Create a new list (column) at the right end of a board. boardId is the board id or its exact name. Returns { id, boardId }; cards can then name the list by its id or name.

Inputs: name (required), boardId (required).

kanbini_delete_attachmentDelete an attachmentA

Delete an attachment from its card, including the stored file. If it was the card's cover, the cover is cleared. The user can undo this in the app (Ctrl+Z) but the undo restores only the entry, NOT the file, so confirm intent first. Attachment ids come from kanbini_get_card.

Inputs: id (required).

kanbini_delete_boardDelete a boardA

Permanently delete a board with all of its lists, cards and labels. Prefer kanbini_archive_board unless the user clearly asks for it to be deleted; confirm the board by name first. The user can undo it in the app (Ctrl+Z from the boards home). id is the board id or its exact name.

Inputs: id (required).

kanbini_delete_cardDelete a cardA

Permanently delete a card. Its checklists, comments, and attachment rows are removed by the FK cascade. Files attached to the card stay on disk until the GC sweep - they cannot be restored from the UI, so confirm intent before calling. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: id (required), boardId.

kanbini_delete_checklistDelete a checklistA

Delete a whole checklist with all of its items. The user can undo in the app.

Inputs: id (required).

kanbini_delete_checklist_itemDelete a checklist itemC

Remove one item from a checklist. The user can undo in the app.

Inputs: id (required).

kanbini_delete_commentDelete a commentA

Delete a comment from a card. Comments the user wrote (author null) are theirs: delete one only when they ask. The user can undo in the app.

Inputs: id (required).

kanbini_delete_labelDelete a labelA

Delete a label from its board. It is removed from EVERY card that carries it. The user can undo this in the app (Ctrl+Z), which puts it back on the same cards, but confirm intent first when the label is in use. Labels can be given by id or by name. (by name with boardId).

Inputs: id (required), boardId.

kanbini_delete_listDelete a listA

Permanently delete a list (column) and every card in it. Prefer kanbini_archive_list unless the user asks for it to be deleted, and say how many cards go with it before you do. The user can undo it in the app (Ctrl+Z on that board). A list can be given by its id, or by its exact name with boardId.

Inputs: id (required), boardId.

kanbini_get_agendaGet the user's agenda across all boardsA

What's on the user's plate, across every board in one call. Returns four sections: overdue (open cards due before today), today (open cards due today), upcoming (open cards due in the next upcomingDays, default 7), and completed (cards marked complete today or in the previous completedDays, default 7, newest first). Due sections are ordered soonest first, then by priority. Each item carries cardId, title, boardId, boardName, listName, dueAt (epoch ms, local midnight of the due day), priority, completedAt, and blocked (still waiting on an open card, so it cannot really start yet). totals counts every card per section even when limit (default 50 per section, max 100) trims the arrays. "Today" is the local calendar day on the user's machine; dayStart is its midnight. Archived cards, archived lists, and archived boards are left out. Use this for "what should I work on", "what is overdue", or "what did I get done this week" instead of walking every board. When the desktop app is closed, falls back to the last on-disk export.

Inputs: limit, upcomingDays, completedDays.

kanbini_get_boardGet Kanbini boardA

Return one board: its labels, and every list with its cards. By default (detail: "summary") each card is one short line: number (the #N shown on the card, counted per board), title, and only what applies: completed, due (YYYY-MM-DD), priority, labels (names), checklist ("ticked/total"), description: true when it has one, comments / attachments counts, blocked (waiting on an open card), repeat. A list shows its first cardsPerList cards (default 50, in board order); a longer one says how many it left out in moreCards, and kanbini_get_list_cards filters or pages through them. Cards are named by number: pass #142 with this boardId to any tool that takes a card, and use kanbini_get_card for its description, checklists, comments and history. For one list, filtered (open / done, label, priority, due, text) or paged, use kanbini_get_list_cards. detail: "full" returns every card with all of its content, which is very large on a big board: avoid it. Archived cards are left out; archived lists show closed: true with no cards (kanbini_list_archived lists both). A list's visibleCardLimit / cardDensity and a card's collapsed are display settings only: every card is still returned. boardId is the id or exact name; omitted, the first board. Returns null if it matches nothing. When the desktop app is closed, falls back to the last on-disk export.

Inputs: detail, boardId, cardsPerList.

kanbini_get_cardGet Kanbini cardA

Return one Kanbini card by id OR by its number - #142 or 142, the short #N the app shows on the card, which is how the user refers to cards. Numbers are counted per board, so a number needs its boardId (the id or name of the board the user means; without one this errors and lists the boards that have that number). Numbers handed out before they were per board are gone: look a card up again rather than trusting an old number. boardId is ignored for an id. Includes its id, number and boardId (keep the number and board together), title, description, priority (low/medium/high/urgent or null), checklists (with item ids), comments, attachments, recent activity feed, and its "waiting on" links: blockedBy (cards it waits on) and blocking (cards waiting on it), each with title, completed, archived, board, and list. A card is blocked while any blockedBy card is neither completed nor archived. Works for archived cards too (see kanbini_list_archived). Returns null if the id, or the number on that board, does not exist. When the desktop app is closed, falls back to the last on-disk export.

Inputs: id (required), boardId.

kanbini_get_list_cardsGet a list's cardsA

One list's cards, optionally filtered and paged. listId is the list's id or exact name, on boardId (id or name). Filters, all optional and combined: status "open" | "completed" | "all" (default); label (name or id) the card carries; priority (low/medium/high/urgent, or "none"); dueFrom / dueTo (YYYY-MM-DD, inclusive; a card without a due date never matches them); hasDue true/false; query (text in the title or description, any case). Returns { boardId, list: { id, name, cardCount }, matched (cards matching the filters), offset, cards, more (true when another page follows: call again with offset + cards.length) }. Cards come in the order the list shows them, as the same one-line summaries kanbini_get_board gives; detail: "full" returns them with all of their content (descriptions, checklists, comments, history). limit defaults to 50, max 200. Good for "what is still open in To Do", "every Bug card", or walking a long list page by page. When the desktop app is closed, falls back to the last on-disk export.

Inputs: listId (required), boardId (required), dueTo, label, +8 more.

kanbini_list_archivedList archived cards and listsA

Return what a board has archived: lists (archived lists, with how many live cards are inside) and cards (archived cards, most recently touched first, each with its list name). A card whose listClosed is true sits in an archived list, so restoring the card alone will not make it visible - restore the list too. Use the ids with kanbini_archive_card / kanbini_archive_list (archived: false) to bring things back. Returns null for an unknown boardId. When the desktop app is closed, falls back to the last on-disk export.

Inputs: boardId (required).

kanbini_list_boardsList Kanbini boardsA

Enumerate every board in the database with id, name, description, archived flag, list/card counts, and updatedAt (epoch ms; blends the board's own timestamp with the most recent activity-log entry for it, so the array sorts by real recency). Use this first to discover boardIds before calling kanbini_get_board. Returns [] if no boards exist. When the desktop app is closed, falls back to the last on-disk export and prefixes the response with a notice.

Inputs: no named parameters.

kanbini_move_cardMove or reorder a cardA

Move a card between lists, or reorder within its current list. toListId is the destination list. The position is optional and named from the moved card's point of view: beforeId is the card that will sit directly ABOVE it, afterId the card directly BELOW it. So to put card X right under card Y, pass beforeId: Y (not afterId). One neighbour is enough, the server works out the other. Omit both to add the card to the END of the list; pass only afterId = the first card to put it at the top. To place several cards in order, move the first one, then each next one with beforeId = the card you just moved (in one kanbini_batch). Respect the destination list's wipLimit when one is set (advisory, not enforced). Lists with a sortMode order themselves, so a move into one lands wherever the sort puts it. Card numbers are per board: a move to another board gives the card that board's next number, and its labels follow by name (the other board's label with the same name, or a new one there in the same colour). A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on). The list can be named too: on boardId, or on toBoardId for another board.

Inputs: id (required), toListId (required), afterId, boardId, +2 more.

kanbini_move_checklist_itemReorder or move a checklist itemA

Move a checklist item within its checklist or to another checklist (toChecklistId, which may be on another card). beforeId is the item that will sit directly ABOVE it, afterId the one directly BELOW; one is enough, and omitting both puts it at the end.

Inputs: id (required), toChecklistId (required), afterId, beforeId.

kanbini_move_listReorder a listA

Move a list (column) to a new position on its board. Named from the moved list's point of view: beforeId is the list that will sit directly to its LEFT, afterId the list directly to its RIGHT. So to put list X just right of list Y, pass beforeId: Y. One neighbour is enough, the server works out the other. Omit both for the far right; pass only afterId = the first list for the far left. Neighbours must be lists on the same board (closed lists count too, since they keep their slot). A list can be given by its id, or by its exact name with boardId.

Inputs: id (required), afterId, boardId, beforeId.

kanbini_post_commentPost a comment as the AIA

Post a comment on a card. Author is automatically set to 'ai' so it renders with the AI badge in the UI (and is distinguishable from human-written comments). Body is Markdown - put real line breaks between paragraphs and list items. A literal backslash-n renders as the text "\n", not a line break. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: body (required), cardId (required), boardId.

kanbini_remove_blockerStop a card waiting on anotherA

Remove the link that makes card cardId wait on card blockerId. Removing a link that doesn't exist does nothing. Neither card changes otherwise. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: cardId (required), blockerId (required), boardId.

kanbini_rename_checklistRename a checklistA

Rename a card's checklist (ids are in the checklists of kanbini_get_card).

Inputs: id (required), name (required).

kanbini_search_cardsSearch cards across all boardsA

Global card search by case-insensitive substring on title, description, and label name; a query like #142 or 142 also finds each board's card with that number (numbers are per board; check boardName). Returns up to limit (default 50, max 100) hits, each carrying cardId + number + title + boardId + boardName + listName + matchedLabels + matchKind ("number" | "title" | "label" | "description") + updatedAt. Sort puts the numbered cards first, then title matches, then label, then description; ties break by recency. Archived cards and closed lists are excluded. Use cardId with kanbini_get_card to fetch full detail for any hit. When the desktop app is closed, falls back to the last on-disk export.

Inputs: query (required), limit.

kanbini_set_card_labelsSet, add or remove card labelsA

Change a card's labels. labelIds are label ids or names (labels must belong to the card's board; make a missing one with kanbini_create_label). mode "replace" (the default) sets exactly these labels (an empty array removes all), "add" adds them to the ones it has, "remove" takes them off. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: id (required), labelIds (required), mode, boardId.

kanbini_toggle_checklist_itemCheck or uncheck a checklist itemC

Set the completed flag on a checklist item. Pass true to mark it done, false to reopen.

Inputs: id (required), completed (required).

kanbini_update_boardUpdate board settingsA

Patch a board. name renames it; description is the short blurb on the home picker (null clears it); color is the board accent shown on its home card and header tint (null clears it); pinned favourites it to the top of the home picker. Omit fields you do not want to change. id is the board id or its exact name. To archive a board use kanbini_archive_board. Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

Inputs: id (required), patch (required).

kanbini_update_cardUpdate card fieldsA

Patch one or more card fields. title and description are strings; description accepts Markdown - use real line breaks for paragraphs and lists (a literal backslash-n renders as text, not a break). due is a YYYY-MM-DD day (or dueAt, epoch ms), null clears it. completed toggles the checkbox. coverAttachmentId is the attachment id to use as the cover banner, or null to clear. priority is one of 'low' | 'medium' | 'high' | 'urgent', or null to clear. collapsed only changes how the card is DRAWN in its list: true shows it compact, false keeps it full even in a compact list, null follows the list's cardDensity. It hides nothing from you, so change it only when the user asks for a tidier board. repeat makes the card repeat: { unit: 'day' | 'week' | 'month' | 'year', every: 1-99 } (e.g. { unit: 'week', every: 2 } for every two weeks), or null to stop. When a repeating card is completed, the app adds the next one to the list it was worked in, due one repeat after the old due date (always in the future), with the same title, description, labels, priority, and unticked checklists; the rule moves to the new card. Omit fields you do not want to change. Labels: kanbini_set_card_labels. A card can be given by its id, or by its number (#142, as shown on the card) with boardId (the id or name of the board it is on).

Inputs: id (required), patch (required), boardId.

kanbini_update_checklist_itemEdit a checklist itemA

Change a checklist item's text, and/or tick it (completed). Omit what you do not want to change.

Inputs: id (required), text, completed.

kanbini_update_commentEdit a commentA

Replace the text of a comment (ids are in the comments of kanbini_get_card). Markdown, with real line breaks. Comments the user wrote (author null) are theirs: change one only when they ask. The user can undo in the app.

Inputs: id (required), body (required).

kanbini_update_labelRename or recolour a labelA

Patch a label. name renames it and color recolours it - the change shows on every card carrying the label. Omit fields you do not want to change. Labels can be given by id or by name. (by name with boardId). Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

Inputs: id (required), patch (required), boardId.

kanbini_update_listUpdate list settingsA

Patch a list (column). name renames it. color tints the list header and border (null clears it). wipLimit sets a work-in-progress cap - a positive integer, or null to remove it; the app shows the count against the cap and blocks drags past it, but the limit is NOT enforced for writes, so check the card count yourself before adding. sortMode orders the cards: "manual" (drag order, the default), "created-asc"/"created-desc" (card creation time), "added-asc"/"added-desc" (when the card entered this list), "due-asc" (soonest due first, undated last), "title-asc"/"title-desc" (alphabetical), "priority-desc" (urgent first). Switching back to "manual" freezes the current sorted order as the new drag order. onEnter runs when a card is moved INTO this list from another one: "complete" marks it done, "uncomplete" reopens it, null removes the rule. cardDensity "compact" draws every card in the list compact (a card can opt out with kanbini_update_card collapsed: false); "full" is the default. visibleCardLimit shows at most that many cards on screen, then a "Show N more" button (1-1000); 0 always shows every card; null (the default) lets the app shorten a list of more than 30 cards to its first 20 (the user can turn that off). Both are display only: the reads always return EVERY card, so never read a limit as the list being shorter. Change them only when the user asks. To reorder lists use kanbini_move_list; to hide one use kanbini_archive_list. A list can be given by its id, or by its exact name with boardId. Colours: pass a palette name (red, orange, amber, yellow, lime, green, teal, cyan, sky, blue, indigo, purple, pink, rose) so it matches the app's swatch picker.

Inputs: id (required), patch (required), boardId.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 42 tools

    Disambiguation4/5

    Tools are cleanly partitioned by resource+action (board/list/card/label/checklist/comment/attachment/blocker), with clear read-vs-write and archive-vs-delete separation. The only real overlaps are toggle_checklist_item vs update_checklist_item (the former is a subset of the latter) and create_checklist vs add_checklist_item, both of which the descriptions do distinguish.

    Naming Consistency5/5

    Every tool follows the same kanbini_<verb>_<noun> snake_case pattern (create_card, update_board, archive_list, remove_blocker, set_card_labels). Verb choice is semantically consistent — get_ for single-resource reads, list_ for enumerations, move_/copy_/archive_ for specific mutations.

    Tool Count3/5

    42 tools is well above the comfortable band, but the domain genuinely spans nine entities (boards, lists, cards, checklists, checklist items, comments, labels, attachments, blockers) plus search, agenda, and batch. A few slots feel redundant (toggle_checklist_item, and the get_board/get_list_cards/get_card trio could be consolidated), so it is heavy rather than tight.

    Completeness5/5

    Full lifecycle is covered for boards, lists, cards, labels, checklists/items, comments, and attachments, plus blockers, archival, global search, an agenda view, and an atomic batch tool that composes the write surface. No obvious dead ends; the only minor omission is reading back attachment file content.

    Maintenance

    ActivityActive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers