Kanbini
Kanbini's MCP server gives an AI full read/write control over local kanban boards — browsing, searching, and editing cards, lists, boards, labels, checklists, comments, attachments, and blockers.
Read & discover: list boards, get a board with its labels/lists/cards (summary or full), page/filter a single list's cards (status, label, priority, due range, text), fetch one card by id or
#number, search cards across all boards, and get an agenda (overdue / today / upcoming / completed) with totals and blocked flags.Create: boards, lists, cards (with description, due date, priority, labels, checklists, repeat rule, completion, explicit position), labels, checklists and their items, and comments posted with an AI badge.
Update: card fields (title, Markdown description, due, priority, completed, repeat rule, cover image, collapsed), card labels (replace/add/remove), board settings (name, description, colour, pinned), list settings (name, colour, WIP limit, sort mode, on-enter rule, card density, visible card limit), labels (rename/recolour), checklists (rename, edit items, tick/untick), and comments.
Move & reorganize: move or reorder cards across lists and boards (labels follow by name, new card number), copy cards between lists/boards, reorder lists, and reorder items within or between checklists.
Archive & delete: archive/restore cards, lists, and boards (with guidance to prefer archiving), list a board's archived items, and permanently delete cards, lists, boards, labels, comments, checklists, checklist items, and attachments — with confirm-intent warnings.
Dependencies: add or remove "waiting on / blocked by" links between cards, including across boards, with loop and self-link rejection.
Attachments: attach files by local path (up to 100 MB) or inline utf8/base64 content (up to 10 MB), and delete attachments (file removal is not undoable).
Batch operations: up to 200 write steps in one atomic call with one undo step, a default
boardIdfor all steps, andref/$nameplaceholders to reference things created earlier in the batch.Resilience: works while the desktop app is closed by falling back to the last on-disk export (read tools only), flagging that in the response.
Kanbini
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 |
|
|
Waiting on, comments (one from the AI) + activity | Right-click menus with fly-outs |
|
|
Select several cards, act on all of them | Ctrl+F search across every board |
|
|
Swimlanes - group by priority | 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. Seedocs/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. Seeplugins/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.exeinstalls 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.zipis the portable folder: extract it anywhere and runKanbini.exeinside. Nothing is installed and nothing goes in the registry. To update, replace the folder.Kanbini-X.Y.Z-win-x64-portable-single-file.exeis 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.debfor 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.AppImagefor any distro:chmod +xit 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 devIt 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:nativeTo 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 appExercise 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 → deleteProve the export/import round-trip is lossless (no live app needed):
pnpm --filter @kanbini/desktop run test:roundtripLayout
/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.mdDesign & architecture →
docs/DESIGN.mdMCP integration →
docs/MCP.mdPackaging →
docs/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 toolskanbini_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
Scored across 42 tools
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.
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.
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.
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
Related MCP Connectors
Remote MCP for Kanban AI boards—manage projects, tasks, and comments from AI tools.
Create, read and live-edit visual boards, Kanban plans, Gantt timelines and diagrams with AI agents.
Read and manage your EasyKanban kanban boards: to-do summaries, create, update, and move cards.
Kanban boards your AI agent can use: add, complete, move and recall tasks with your team.
Related MCP Servers
AlicenseAqualityCmaintenanceEnables AI assistants to manage Kanban Zone workspaces via 23 tools for boards, cards, comments, checklists, and tasks.2747 npm1MIT- AlicenseBqualityDmaintenanceEnables AI agents to manage kanban boards with tasks, including creating boards, items, moving between columns, and searching.81MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to manage Kanban tasks, boards, teams, and checklists via natural language, with full CRUD operations and live updates.MIT
- FlicenseNot gradedqualityCmaintenanceEnables AI assistants to manage a local-first Kanban board with Azure DevOps-style workflow rules, including task creation, status updates, subtask breakdown, full-text search, daily summaries, and next-task suggestions.-







