Skip to main content
Glama

Move or reorder a card

kanbini_move_card

Move a card between lists or reorder it within its current list, using a neighbouring card to set the exact position. Works across boards and follows WIP limits and sort modes.

Instructions

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.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "id": "<id>",
      "toListId": "<toListId>"
    },
    "name": "kanbini_move_card"
  }
}

Input Schema

NameRequiredDescriptionDefault
idYes
afterIdNoCard that will sit directly BELOW the moved card
boardIdNoThe board's id or exact name. Needed when you name a card by number (#142) or a list / label by name.
beforeIdNoCard that will sit directly ABOVE the moved card
toListIdYes
toBoardIdNoBoard of `toListId` when you name that list and it is on another board (id or name)

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changedv0.17.0
    • changedInput schema / properties / boardId / description
      Previous value: -"Only when a card is given by number (#142): the board it is on"New value: +"The board's id or exact name. Needed when you name a card by number (#142) or a list / label by name."
    • addedInput schema / properties / toBoardId
      Added value: +{
      +  "description": "Board of `toListId` when you name that list and it is on another board (id or name)",
      +  "type": "string"
      +}
  2. Changed3 schema fields changedv0.15.0
    • addedInput schema / properties / afterId / description
      Added value: +"Card that will sit directly BELOW the moved card"
    • addedInput schema / properties / beforeId / description
      Added value: +"Card that will sit directly ABOVE the moved card"
    • addedInput schema / properties / boardId
      Added value: +{
      +  "description": "Only when a card is given by number (#142): the board it is on",
      +  "type": "string"
      +}
  3. First observedv0.13.0

TDQS

A4.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and mostly succeeds: it discloses that `wipLimit` is advisory and not enforced, that sorted lists override placement, and that a cross-board move renumbers the card and re-resolves labels by name/colour. It omits what the call returns and any failure behaviour when a neighbour card is missing or on a different list.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose and placement semantics are front-loaded and nearly every sentence carries information. The block is dense, however, with the board-numbering and label-following rules and the id-vs-number addressing compressed into long trailing sentences that could be split for scanability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a six-parameter mutation with no annotations and no output schema, this covers addressing, ordering, batch sequencing, WIP limits, sorted lists, and cross-board effects. The remaining gap is the response shape and error behaviour, which nothing else in the definition supplies.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Adds substantial meaning beyond the 67% schema coverage: the `beforeId`/`afterId` fields are reframed from the moved card's point of view with a concrete worked example, the undocumented `id` param is explained as accepting either an id or a `#142`-style number, and the `boardId`/`toBoardId` pairing for naming cards and lists is spelled out.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Opens with a specific verb and resource plus the two distinct modes: 'Move a card between lists, or reorder within its current list.' This separates it from kanbini_move_list (lists, not cards) and kanbini_copy_card (which duplicates rather than relocates).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-do-what rules: omit both neighbours to append, pass only `afterId` to put the card at the top, and use `beforeId: Y` to land under card Y. It also names kanbini_batch as the mechanism for ordering several cards and warns that sortMode lists ignore the requested position.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.